MyBatis-Plus 是基于 MyBatis 框架的一个增强工具，惠州保洁13825404095主要目的是简化 MyBatis 的开发过程，提供更加简洁、方便的 CRUD 操作。它是在保留 MyBatis 强大功能的基础上，通过封装和优化一些常见操作来提高开发效率。
MyBatis-Plus 提供了许多开箱即用的功能，包括自动 CRUD 代码生成、分页查询、性能优化、以及支持多种数据库。与 MyBatis 相比，MyBatis-Plus 的 部分 核心特性包括：
无侵入设计：不会改变 MyBatis 原有的 API 和使用方式，你可以自由选择 MyBatis 和 MyBatis-Plus 的功能。
自动 CRUD：通过 BaseMapper 和 ServiceImpl 接口，MyBatis-Plus 提供了一系列 CRUD 操作的方法，如 insert、delete、update 和 select，减少了重复的 SQL 编写工作。
条件构造器：MyBatis-Plus 提供了条件构造器（如 QueryWrapper），可以通过链式编程方式轻松构建复杂的查询条件。
1、准备工作 1.1 添加依赖创建一个 springboot 项目， 在 pom.xml 文件中的 dependencies 标签中添加所需要的依赖。
打开 maven官网 搜索所需依赖。大家添加最新版本的就行
mybatis plus
mysql
mybatis spring
这个依赖最好加上，它可以解决部分 mybatis 和 spring 之间的兼容性问题
在 mybatis plus 官网 给的有 sql 语句, 执行生成数据表和数据
在 application.properties 文件中添加下面信息连接数据库
spring.datasource.url=jdbc:mysql://localhost:3306/yourDatabaseName?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8 spring.datasource.username=YourUserName spring.datasource.password=YourPassword spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driveridea连接数据库，创建pojo，mapper，service，controller文件就不多赘述了..
2、mapper层基本的操作BaseMapper 是 MyBatis-Plus 提供的一个基础 Mapper 接口，它简化了数据访问层（Data Access Layer）的开发。BaseMapper 提供了一系列通用的数据库操作方法，这样你就不必手动编写常见的 SQL 语句，从而提升了开发效率。
1. 使用 BaseMapper假设我们有一个用户实体类 User，如下：
public class User { private Long id; private String name; private Integer age; private String email; // Getter 和 Setter }你可以创建一个 UserMapper 接口来继承 BaseMapper<User>：
import com.baomidou.mybatisplus.core.mapper.BaseMapper; public interface UserMapper extends BaseMapper<User> { // 你可以在这里添加自定义方法 }通过继承 BaseMapper<User>，UserMapper 立即拥有了所有的 CRUD 操作方法。你可以在你的服务层（Service Layer）中直接使用这些方法，无需再编写任何 SQL 语句。
2. BaseMapper 提供的常用方法 2.1 增（Insert）简单示例：
// 定义用户实体类 public class User { private Long id; private String username; private String email; } // 使用 MyBatis-Plus 提供的 BaseMapper 接口 public interface UserMapper extends BaseMapper<User> { } // 插入一条记录 User user = new User(); user.setUsername("john_doe"); user.setEmail("john@example.com"); // 调用 insert 方法 userMapper.insert(user);解释：这里的 insert 方法直接使用实体类对象 user，将其插入到数据库中。MyBatis-Plus 自动生成的 insert 方法会根据实体类的属性映射到数据库表的字段。
2.2 删（Delete）简单示例：
// 根据 ID 删除一条记录 userMapper.deleteById(1L);解释：deleteById 方法通过传入用户的 id 删除该用户。这个方法直接删除主键为 1 的用户。
2.3 改（Update）简单示例：
// 创建一个用户对象，设置要修改的字段 User user = new User(); user.setId(1L); // 设置要更新的用户 ID user.setEmail("newemail@example.com"); // 修改用户邮箱 // 更新用户信息 userMapper.updateById(user);解释：updateById 方法根据 id 更新用户记录，这里只更新了邮箱字段，其他字段保持不变。
2.4 查（Select）简单示例：
// 根据 ID 查询用户 User user = userMapper.selectById(1L); // 输出用户信息 System.out.println(user.getUsername());解释：selectById 方法根据传入的 id 查询对应的用户信息，然后可以输出或使用这个用户信息。
2.5 条件查询简单示例：
// 构建查询条件 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); // <-------- 下面会讲到 queryWrapper.eq("username", "john_doe"); // 设置条件：用户名为 john_doe // 执行查询 List<User> users = userMapper.selectList(queryWrapper); // 输出查询结果 for (User u : users) { System.out.println(u.getUsername()); }解释：QueryWrapper 是 MyBatis-Plus 提供的一个工具类，用于构建查询条件。selectList 方法根据条件查询所有符合条件的记录。
3. Mybatis 的补充在 Java 接口中使用注解来编写 SQL。
2. 常用注解@Select
用于执行 SQL 查询并返回结果。
@Select("SELECT * FROM table_name WHERE id = #{id}") Object selectById(@Param("id") Integer id);#{id}：表示占位符，表示将会被参数 id 的值替换。
@Insert
用于执行插入操作。
@Insert("INSERT INTO table_name (column1, column2) VALUES (#{value1}, #{value2})") void insert(@Param("value1") String value1, @Param("value2") Integer value2);@Update
用于执行更新操作。
@Update("UPDATE table_name SET column1 = #{value1} WHERE id = #{id}") void update(@Param("id") Integer id, @Param("value1") String value1);@Delete
用于执行删除操作。
@Delete("DELETE FROM table_name WHERE id = #{id}") void delete(@Param("id") Integer id); 3. 参数传递在使用注解时，方法参数可以通过 @Param 注解进行命名，从而在 SQL 中使用。
public interface MyMapper { @Select("SELECT * FROM users WHERE username = #{username} AND age = #{age}") User selectByUsernameAndAge(@Param("username") String username, @Param("age") Integer age); }在这里，@Param("username") 和 @Param("age") 用于将方法参数与 SQL 查询中的占位符对应起来。
4. 返回值处理SQL 查询的返回值可以是单个对象、多个对象的列表或简单的原始类型（如 int、String 等）。
单个对象：
@Select("SELECT * FROM users WHERE id = #{id}") User selectById(@Param("id") Integer id);
列表：
@Select("SELECT * FROM users") List<User> selectAll();
原始类型：
@Select("SELECT COUNT(*) FROM users") int countUsers(); 5. 事务处理在使用注解定义 SQL 查询时，事务管理通常在服务层进行。你可以使用 Spring 的 @Transactional 注解来管理事务。
@Service public class UserService { @Autowired private UserMapper userMapper; @Transactional public void createUser(User user) { userMapper.insert(user); // 其他逻辑... } } 3、service层基本的操作ServiceImpl 和 IService 是 MyBatis-Plus 中用于服务层（Service Layer）的两个重要接口和类，它们帮助简化和规范了与数据库交互的业务逻辑。下面是它们的详细介绍：
1. IService 接口IService 是 MyBatis-Plus 提供的一个通用服务接口。它定义了一些常见的 CRUD（Create, Read, Update, Delete）操作，并将这些操作抽象成方法。这意味着，当你使用 IService 接口时，你无需自己手动编写这些常见的数据库操作方法。
IService 中的一些常用方法：boolean save(T entity): 保存一个实体类对象到数据库。
boolean removeById(Serializable id): 根据 ID 删除数据。
boolean updateById(T entity): 根据 ID 更新数据。
T getById(Serializable id): 根据 ID 查询数据。
List<T> list(): 查询所有数据。
Page<T> page(Page<T> page): 分页查询数据。
2. ServiceImpl 类ServiceImpl 是 MyBatis-Plus 提供的一个基础实现类，它实现了 IService 接口中的方法。ServiceImpl 通常是被继承的，它提供了具体的数据库操作方法的实现。开发者只需在自己定义的服务实现类中继承 ServiceImpl 类，就可以获得默认的 CRUD 功能。
使用示例假设你有一个用户表 User，并为其定义了一个实体类 User 和一个 Mapper 接口 UserMapper。你可以定义一个服务接口 UserService 和一个服务实现类 UserServiceImpl。
1. 定义服务接口： public interface UserService extends IService<User> { // 可以定义一些自定义的服务方法 } 2. 定义服务实现类： @Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { // 你可以重写 ServiceImpl 中的方法，或者定义更多的业务逻辑 }在这个例子中，UserServiceImpl 继承了 ServiceImpl<UserMapper, User> 并实现了 UserService 接口。通过这种方式，UserServiceImpl 类可以直接使用 ServiceImpl 提供的基本 CRUD 方法。
Mapper 和 Service 中有很多的方法，具体用法可以参考
MyBatis-Plus 的自动映射规则主要涉及如何将数据库表和字段自动映射到 Java 实体类及其属性。
1. 表名与实体类名的映射默认规则：MyBatis-Plus 默认使用实体类名作为数据库表名的前缀。比如，如果你的实体类名为 User，那么它会映射到名为 user 的数据库表。
自定义规则：你可以使用 @TableName 注解来指定自定义的表名。例如：@TableName("sys_user") public class User { // 属性和方法 }
2. @TableField 字段名与属性名的映射默认规则：字段名和属性名默认是直接映射的。例如，数据库中的 user_name 字段会映射到实体类中的 userName 属性。
驼峰命名规则：MyBatis-Plus 默认启用了驼峰命名转换。即，数据库中的下划线命名（如 user_name）会被自动转换为 Java 属性的驼峰命名（如 userName）。
自定义字段映射：可以使用 @TableField 注解来指定自定义的字段名。例如：@TableField("user_name") private String userName;
@TableField的其他用法:
如果表中字段存在 sql语句的关键词 ，比如 desc , 那么需要按照下面的写法, 否则mybatis plus 拼接含有 desc字段 的sql语句时会报错
@TableField("`desc`") private String desc;
@TableField(select = false)
作用：用于指定某个字段在执行 SQL 查询时不参与查询，即在 SELECT 语句中不包含该字段。
用途：通常用于那些只需要在数据库操作中存在，但不需要在查询结果中显示的字段。例如，逻辑删除字段、内部使用的字段等
@TableField(exist = false)
作用：用于指定某个字段不对应数据库中的任何字段，即在数据库表中不存在该字段。
用途：通常用于那些只在 Java 实体中存在的字段，但在数据库表中没有相应的字段。例如，用于计算或临时存储的数据。
在 MyBatis-Plus 中，@TableId 注解用于标识实体类中的主键字段。@TableId 注解有两个主要属性：value 和 type。它们分别用于指定字段名和主键生成策略。
@TableId 注解属性
value:
用途：指定数据库表中的主键列名。它的值应该是数据库表中实际的列名。
示例：如果数据库表中的主键列名是 user_id，则在实体类中可以这样配置：@TableId(value = "user_id", type = IdType.ASSIGN_UUID) private String userId;
type:
用途：指定主键生成策略。MyBatis-Plus 提供了多种主键生成策略，IdType 枚举类定义了这些策略。
常用的生成策略：
IdType.AUTO：数据库自动生成（通常是自增长 ID）。
IdType.INPUT：用户输入 ID（即需要手动设置）。
IdType.ASSIGN_ID：由 MyBatis-Plus 生成的 ID（通常是 UUID）。
IdType.ASSIGN_UUID：生成 UUID（字符串类型的唯一 ID）。
示例：如果你想使用 UUID 作为主键，你可以使用 IdType.ASSIGN_UUID：
@TableId(value = "user_id", type = IdType.ASSIGN_UUID) private String userId; 5、条件构造器 常用查询MyBatis-Plus 提供了强大的条件构造器，使得在查询数据库时可以灵活地构建条件，而无需手动编写复杂的 SQL 语句。主要通过 Wrapper 接口及其常用实现类 QueryWrapper 和 LambdaQueryWrapper 来实现条件查询。
1. Wrapper 接口Wrapper 是 MyBatis-Plus 提供的条件构造器接口，用于构建动态 SQL。它有多个实现类，其中最常用的是 QueryWrapper 和 LambdaQueryWrapper。
2. QueryWrapperQueryWrapper 是 MyBatis-Plus 提供的一个通用条件构造器，用于以非 Lambda 表达式的方式构建查询条件。
常用方法：eq: 等于
ne: 不等于
gt: 大于
ge: 大于等于
lt: 小于
le: 小于等于
between: 在两者之间
like: 模糊查询
or: 或条件
and: 并且条件
orderByAsc: 升序排序
orderByDesc: 降序排序
in: 在指定范围内
inSql: 允许你使用子查询的结果集作为 IN 条件的范围
isNull: 判断字段是否为 NULL
isNotNull: 判断字段是否不为 NULL
示例： QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper .eq("name", "张三") // name 等于 张三。 eq也可以写三个参数, 第一个参数是boolean, false 表示这个条件不起作用, true 表示起作用 .ge("age", 18) // age 大于等于 18 .like("email", "gmail.com") // email 包含 gmail.com .orderByDesc("create_time"); // 按 create_time 降序排列 List<User> users = userMapper.selectList(queryWrapper); 3. LambdaQueryWrapperLambdaQueryWrapper 是 QueryWrapper 的 Lambda 版本，用于在构建条件时避免使用字符串来指定字段，增加了类型安全性。它推荐使用字段的 Lambda 表达式来构建条件。
示例： LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>(); lambdaQuery .eq(User::getName, "张三") // name 等于 张三 .ge(User::getAge, 18) // age 大于等于 18 .like(User::getEmail, "gmail.com") // email 包含 gmail.com .orderByDesc(User::getCreateTime); // 按 create_time 降序排列 List<User> users = userMapper.selectList(lambdaQuery); 4. UpdateWrapper 和 LambdaUpdateWrapper这两个类分别是用于构建更新条件的构造器，功能与 QueryWrapper 和 LambdaQueryWrapper 类似，但用于 UPDATE 操作。
示例： UpdateWrapper<User> updateWrapper = new UpdateWrapper<>(); updateWrapper .eq("name", "张三") .set("age", 30); // 将年龄更新为 30 userMapper.update(null, updateWrapper);具体用法可参考 Mybatis plus 官网
假设你想统计各个年龄段的人数，可以使用如下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.select("age", "COUNT(*) as count"); queryWrapper.groupBy("age"); List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper); 生成的 SQL： SELECT age, COUNT(*) as count FROM user GROUP BY age; 6.2 聚合查询 示例 ：按 age 分组并过滤统计结果（HAVING）如果你只想统计人数大于 1 的年龄段，可以添加 HAVING 条件：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.select("age", "COUNT(*) as count"); queryWrapper.groupBy("age"); queryWrapper.having("COUNT(*) > 1"); List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper); 生成的 SQL： SELECT age, COUNT(*) as count FROM user GROUP BY age HAVING COUNT(*) > 1; 6.3 排序查询 示例 1：按 age 升序和 name 升序排序假设你想首先按用户的年龄升序排序，然后按姓名升序排序，可以使用如下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.orderByAsc("age").orderByAsc("name"); List<User> result = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user ORDER BY age ASC, name ASC; 示例 2：按 age 降序排序假设你想按用户的年龄降序排序，可以使用如下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.orderByDesc("age"); List<User> result = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user ORDER BY age DESC; 示例 3：按 age 升序和 name 降序组合排序假设你想先按年龄升序排序，再按姓名降序排序，可以使用如下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.orderByAsc("age").orderByDesc("name"); List<User> result = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user ORDER BY age ASC, name DESC; 示例 4：按多字段排序，并指定是否为空假设你想按 age 升序排序，并希望将 name 为空的记录排在前面，可以使用如下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.orderByAsc("age").orderByAsc("name", true); List<User> result = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user ORDER BY age ASC, name ASC; 6.4 逻辑查询func 方法是 MyBatis-Plus 提供的一个非常灵活的功能，它允许你将一段自定义的逻辑包装到查询条件中。这对于需要根据不同的条件来动态构建查询的场景特别有用。下面是对 func 方法的详细解释。
1. func 方法的基本用法func 方法接收一个 Consumer，该 Consumer 的参数是 QueryWrapper（或 LambdaQueryWrapper）的一个实例。你可以在这个 Consumer 中编写自定义的逻辑，并根据不同的条件来动态地添加或修改查询条件。
语法结构 queryWrapper.func(wrapper -> { // 在这里编写自定义逻辑 if (condition) { wrapper.eq("column", value); } else { wrapper.ne("column", value); } }); 主要参数Consumer<QueryWrapper> 或 Consumer<LambdaQueryWrapper>：这是一个函数式接口，允许你传入一个 Lambda 表达式或方法引用。你可以在这个接口的 accept 方法中实现自己的逻辑。
实际应用场景假设你有一个用户查询接口，允许用户根据不同的条件来过滤结果，例如按 id 或按 name。你可以使用 func 来根据用户输入动态地构建查询条件。
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>(); lambdaQueryWrapper.func(wrapper -> { if (userInput != null && userInput.isValid()) { wrapper.eq(User::getName, userInput.getName()); } else { wrapper.ne(User::getId, 1); } }); List<User> users = userMapper.selectList(lambdaQueryWrapper);示例解释：
如果 userInput 非空且有效，则查询条件为 name = userInput.getName()。
否则，查询条件为 id != 1。
2. and 和 or 的使用在 MyBatis-Plus 中，and 和 or 用于在构建查询条件时处理多条件的逻辑运算。它们允许你在查询中组合多个条件，以实现复杂的查询逻辑。
and 方法and 方法用于将多个查询条件通过逻辑“与” (AND) 连接在一起。它将多个条件组合成一个大的 AND 条件，从而要求所有这些条件都必须满足。
示例假设你有一个 User 表，你想查询年龄大于 20 且名字为 "Jack" 的用户。可以使用以下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 20).and(wrapper -> wrapper.eq("name", "Jack")); List<User> users = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user WHERE age > 20 AND name = 'Jack';在这个例子中，and 方法的作用是将 .gt("age", 20) 和 .eq("name", "Jack") 这两个条件通过 AND 组合在一起。
or 方法or 方法用于将多个查询条件通过逻辑“或” (OR) 连接在一起。它将多个条件组合成一个大的 OR 条件，只要其中一个条件满足，就会返回符合的结果。
示例假设你有一个 User 表，你想查询年龄大于 20 或名字为 "Jack" 的用户。可以使用以下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 20).or(wrapper -> wrapper.eq("name", "Jack")); List<User> users = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user WHERE age > 20 OR name = 'Jack';在这个例子中，or 方法的作用是将 .gt("age", 20) 和 .eq("name", "Jack") 这两个条件通过 OR 组合在一起。
组合使用 and 和 or你还可以结合使用 and 和 or 方法，以构建更复杂的查询。例如，如果你想查询年龄大于 20 且（名字为 "Jack" 或邮箱为 "test@example.com"）的用户，可以使用以下代码：
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 20) .and(wrapper -> wrapper.eq("name", "Jack") .or().eq("email", "test@example.com")); List<User> users = userMapper.selectList(queryWrapper); 生成的 SQL： SELECT * FROM user WHERE age > 20 AND (name = 'Jack' OR email = 'test@example.com');在这个例子中，and 和 or 方法的结合使用允许你在 age > 20 的基础上，增加一个组合条件 (name = 'Jack' OR email = 'test@example.com')。
6.5 其他查询 apply 方法apply 方法允许你直接在 QueryWrapper 中插入自定义的 SQL 片段。apply 方法中的 SQL 片段会被添加到 WHERE 子句的末尾。这允许你在现有的查询条件基础上，添加更复杂的条件或函数。
基本用法：
QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.apply("DATE_FORMAT(create_time, '%Y-%m-%d') = {0}", "2024-09-01");在这个示例中：
apply 方法接受一个 SQL 片段作为第一个参数，并可以通过 {} 占位符来插入参数。
这里使用了 DATE_FORMAT 函数来格式化 create_time 字段，并将其与特定的日期进行比较。
last 方法last 方法用于在生成的 SQL 查询的末尾添加额外的 SQL 片段。通常用于添加额外的 SQL 语句，如 ORDER BY, LIMIT, OFFSET 等，这些操作是在生成的 SQL 的最后部分进行的。
基本用法：
QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.last("LIMIT 5");在这个示例中：
last 方法添加了一个 LIMIT 5 子句到查询的末尾，用于限制结果集的返回行数。
示例假设你有一个 User 表，并且想要查询所有 age 大于 20 的用户，并且结果按照 id 降序排列，并且只返回前 10 条记录。你可以使用 apply 和 last 方法来实现这个需求：
QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.gt("age", 20) // age > 20 .orderByDesc("id") // 按 id 降序排序 .last("LIMIT 10"); // 限制返回结果为前 10 条以上内容包含了 mybatis plus 的大部分常用内容，基本能满足大部分需求。
其他内容 ... 待更~
