This article demonstrates how Fluent Mybatis can build complex SQL without XML, compares its implementation with native Mybatis and Mybatis‑Plus for a student score statistics query, and reviews code‑generation settings and feature overviews to help developers choose the most efficient data‑access framework.
This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to query a student_score table for term‑wise statistics of English, Math, and Chinese scores, providing complete code examples, SQL statements, mapper definitions, and code‑generation configurations for each approach.
This article provides a detailed tutorial on using MyBatis-Plus in Java, covering setup, entity and mapper definitions, CRUD operations, annotations, condition builders, pagination, AR mode, logical deletion, automatic field filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, configuration options, and code generation.
This article provides a detailed tutorial on using MyBatis-Plus with Spring Boot, covering installation, quick start, CRUD operations, annotation usage, condition builders, pagination, AR mode, primary key strategies, configuration options, code generation, logical deletion, auto-filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, and best‑practice summaries.
This article provides a detailed tutorial on using MyBatis‑Plus with Spring Boot, covering quick setup, entity and mapper definitions, CRUD operations, condition wrappers (including lambda and chain wrappers), pagination, ActiveRecord mode, primary‑key strategies, configuration options, code generation, and advanced features such as logical deletion, auto‑fill, optimistic locking, performance analysis, multi‑tenant and dynamic table name handling.
This comprehensive tutorial demonstrates how to integrate MyBatis-Plus with Spring Boot, covering basic setup, entity and mapper creation, CRUD operations, condition wrappers, pagination, logical deletion, automatic field filling, optimistic locking, and advanced features such as multi‑tenant and dynamic table name handling, complete with code examples.
MyBatis‑Plus enhances MyBatis by automatically injecting CRUD SQL via BaseMapper, using entity annotations and template methods to map classes to tables, eliminating repetitive manual SQL, supporting lambda queries, pagination, and performance tools, all with minimal intrusion and overhead.
This comprehensive guide walks you through MyBatis-Plus fundamentals, non‑intrusive features, quick project setup, CRUD operations, automatic field filling, optimistic and logical locking, powerful wrapper queries, pagination, and the built‑in code generator, all illustrated with runnable examples and code snippets.
This article provides a step‑by‑step guide for using MyBatis‑Plus with Spring Boot, covering database and table creation, entity and mapper definitions, CRUD examples, automatic field filling, optimistic and logical deletion, performance plugins, query wrappers, and a code generator for rapid development.
This article provides a step‑by‑step tutorial on using MyBatis‑Plus with Spring Boot, covering database creation, table definition, Maven dependencies, entity and mapper setup, CRUD operations, automatic field filling, optimistic locking, pagination, logical deletion, performance monitoring, query wrappers, and code generation, all illustrated with complete code examples.
This guide walks through setting up a MySQL database, configuring a Spring Boot project with MyBatis‑Plus, defining entities and mappers, and demonstrates CRUD operations, pagination, logical and physical deletes, optimistic locking, performance monitoring, and code generation, providing complete code snippets and configuration details.
This article provides a comprehensive step‑by‑step guide on using MyBatis‑Plus in a Spring Boot application, covering table creation, Maven dependencies, configuration, entity and mapper definitions, CRUD testing, auto‑fill, optimistic and logical deletion, pagination, performance monitoring, query wrappers, and code generation.
This article explains why Spring Boot 2.x combined with MyBatis‑Plus 3.4.1 emits duplicate mapper bean warnings, analyzes the root cause in the MyBatis‑Spring integration, and provides a step‑by‑step fix by aligning dependency versions, especially upgrading the pagehelper‑spring‑boot‑starter to 1.3.0.
This article explains how to enhance MyBatis-Plus by adding Maven dependencies, creating custom injector and mapper interfaces, and implementing a true batch‑insert method for MySQL, enabling developers to persist collections of entities efficiently in a Spring Boot backend.
MyBatis-Plus (MP) is a non‑intrusive MyBatis enhancement tool that offers a rich set of CRUD features, multi‑database support, code generation, and plugins, and this article explains its key capabilities, architecture diagram, and provides a step‑by‑step quick‑start example with Maven dependencies and sample query code.
This article explains MyBatis-Plus's key features, shows how to add Maven dependencies, demonstrates the built‑in batch‑insert API, and provides step‑by‑step code to extend MyBatis‑Plus with a custom mapper and service for fast MySQL batch inserts.
This article introduces a SpringBoot-based backend demo that integrates MyBatis-Plus, Apache Shiro, and JWT, outlines its custom annotations and security features, explains the request flow, and provides step‑by‑step instructions for setting up the database, configuring the environment, and running the application.
This article explains the concepts of multi‑tenant architecture, compares three data isolation strategies, and provides a complete Spring Boot example that uses MyBatis‑Plus to automatically inject a tenant identifier into SQL queries, including configuration, entity definitions, and unit tests.
mall‑tiny is an open‑source SpringBoot + MyBatis‑Plus scaffold that streamlines backend development by providing a lightweight project skeleton with integrated permission management, Docker support, Swagger documentation, and code generation tools, enabling rapid setup, customization, and deployment of secure REST APIs.
This article introduces MyBatis‑Plus, a powerful Java ORM that eliminates the need for manual XML mappings by providing ready‑made CRUD APIs, demonstrates how to configure Maven dependencies, define entity and mapper classes, and implement common database operations such as insert, delete, update, select, pagination, and complex conditional queries within a Spring Boot controller, all while showing the generated SQL statements.
This article introduces a SpringBoot-based backend project that integrates JWT for stateless authentication, Apache Shiro for flexible authorization, MyBatis-Plus for enhanced ORM, custom annotations for logging and validation, and demonstrates setup, deployment, and usage instructions.
This article introduces a SpringBoot-based scaffold project that integrates JWT authentication and Apache Shiro authorization, outlines its key features such as custom annotations, bcrypt password encryption, and AOP transaction handling, and provides step‑by‑step instructions for setup, configuration, and running the application.
This article explains how MyBatis-Plus adds data-security protection to Spring Boot applications by encrypting datasource and property file values, details the custom EnvironmentPostProcessor implementation, loading mechanisms, and offers extension ideas and alternatives such as jasypt-spring-boot-starter.
Version 3.3.2 of MyBatis‑Plus introduces elegant data‑security measures, including YML‑based encrypted configuration, AES key generation, and encrypted database credentials, while also delivering numerous bug fixes and enhancements such as pagination improvements, generator updates, and support for additional databases.
This article explains how to replace noisy try‑catch blocks with Spring's @ControllerAdvice and custom Assert utilities, using enums for error codes, unified response structures, and practical MyBatis‑Plus examples to achieve clean, maintainable backend exception handling.
This article introduces a SpringBoot-based backend project that integrates Mybatis-Plus, Apache Shiro, and JWT for secure API development, outlines custom annotations, transaction handling, and provides step‑by‑step instructions for building, configuring, and running the application.
This tutorial demonstrates how to set up a Spring Cloud project, add MyBatis-Plus dependencies, configure the data source and MyBatis-Plus settings, and perform full CRUD operations with Java code examples, providing a practical guide for backend developers.
This tutorial walks through setting up a Spring Cloud micro‑service project by cloning a code‑generator framework, adding backend code, configuring database and Maven settings, launching the generator service, generating CRUD code, and integrating a common utility module with required dependencies.
This guide walks through adding MyBatis-Plus to a Spring Boot project, covering Maven dependencies, datasource configuration, mapper scanning, pagination plugin setup, entity and mapper definitions, and a unit test that demonstrates pagination and the rich CRUD methods provided by BaseMapper.
This article explains the concept of multi‑tenancy, compares three data‑isolation strategies, and demonstrates how to configure MyBatis‑Plus, Spring Boot, and H2 to achieve transparent tenant filtering and automatic tenant‑ID handling using a custom SQL parser and context component.
The article provides a series of advanced MyBatis-Plus query examples, including table creation, data initialization, and four detailed cases that demonstrate the use of like, nested, in, and limit clauses with QueryWrapper, accompanied by SQL statements, Java test code, and execution screenshots.
This article walks through building a MySQL user table, defining the corresponding Java entity and MyBatis‑Plus mapper, and demonstrates basic query operations such as selectList, selectById, selectBatchIds, and selectByMap with full code examples and the generated SQL statements.
This article presents a series of MyBatis-Plus advanced query cases, including data preparation, detailed SQL and Java QueryWrapper examples, difficulty ratings, and complete code snippets to help developers master complex query operations in a Java backend environment.
This article provides a step‑by‑step tutorial on using MyBatis‑Plus select queries, including data preparation, SQL table creation, and detailed Java code examples for retrieving specific fields and filtering by age with both simple and advanced query wrappers.
This article guides readers through configuring a Maven project for MyBatis-Plus by adding the necessary dependencies, installing Lombok, and addressing typical IDE and dependency‑resolution errors, providing code snippets and screenshots to help Java backend developers get started quickly.
This article demonstrates how to use MyBatis-Plus for complex queries—including date filtering, sub‑queries, INNER JOIN, dynamic SQL with the apply method, and the inSql helper—while highlighting potential SQL‑injection pitfalls and providing complete runnable code examples.
This tutorial demonstrates how to create a User table, define the corresponding entity and mapper classes, and perform basic MyBatis-Plus queries such as selectList, selectById, selectBatchIds, and selectByMap, including the required SQL scripts and Java code examples.
This tutorial demonstrates several advanced MyBatis-Plus query scenarios—including combined AND conditions, nested expressions, IN clauses, and limiting results—by providing complete SQL setup, Java QueryWrapper code samples, execution logs, and result screenshots for each case.
This article demonstrates how to perform sophisticated MyBatis‑Plus queries—such as date filtering, manager name prefix matching, sub‑queries, INNER JOIN, dynamic SQL with apply, and inSql—while highlighting potential SQL‑injection risks and providing complete Java test code examples.
This article presents a series of MyBatis-Plus advanced query examples, including how to filter users by name patterns, age ranges, and email presence, and demonstrates ordering and combined conditions with complete Java test code and a sample User table schema.
This tutorial demonstrates how to perform advanced MyBatis-Plus queries—including subqueries, INNER JOIN, apply, and inSql methods—while highlighting difficulty levels, code examples, and the risk of SQL injection in dynamic query construction.
This tutorial showcases MyBatis-Plus advanced query techniques through three practical case studies, providing sample data, detailed SQL conditions, and complete Java test code snippets to help developers master complex database queries.
