MybatisPlus
- 1 MybatisPlus简介
- 1.1 MybatisPlus概述
- 1.2 MP愿景
- 1.3 MP特性
- 1.4 开发MP版本
- 2 MP快速入门
- 2.1 MP入门流程分析
- 2.2 数据库环境准备
- 2.3 创建工程，引入场景依赖
- 2.4 编写DataSource相关配置
- 2.5 编码
- 2.6 测试
- 3 MP实现常规增删改操作
- 3.1 MP实现插入操作
- 3.2 MP主键字段注解-@TableId
- 3.3 普通列注解-@TableField
- 3.4.MP实现删除操作
- 3.5 MP实现更新操作
- 4.MP实现查询操作
- 4.1 MP实现分页查询
- 4.2 QueryWrapper实现基础查询
- 4.3 QueryWrapper逻辑查询or
- 4.4 QueryWrapper模糊查询like
- 4.5 QueryWrapper排序查询
- 4.6 QueryWrapper限定字段查询
- 4.7 QueryWrapper实现分页条件查询
- 4.8 LambdaQueryWrapper查询
- 4.9 LambdaQueryWrapper实现删除和更新操作
- 4.10 自定义查询接口实现分页查询
- 5 MP实现Service封装
- 5.1 MP封装Service介绍
- 5.2 MP封装Service快速入门
- 5.3 MP封装Service实现CRUD操作
- 6 逻辑删除
- 7 乐观锁
- 8 MP实现属性自动填充
1 MybatisPlus简介
1.1 MybatisPlus概述
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生（提供了快速使用mybatis的方式）。
官网：https://mybatis.plus/或 https://mp.baomidou.com/
1.2 MP愿景
MP愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。
1.3 MP特性
- 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
- 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
- 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
- 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
- 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
- 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
- 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
- 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
- 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
- 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
- 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
- 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
1.4 开发MP版本
com.baomidou mybatis-plus 3.4.22 MP快速入门
2.1 MP入门流程分析
SpringBoot 整合 MyBatis-Plus，并实现根据Id查询功能。
- 数据库环境准备
- 创建SpringBoot工程，引入MyBatisPlus场景依赖
- 在yml中编写DataSource相关配置
- 编写mapper
- 测试
2.2 数据库环境准备
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for tb_user 没有给自增 -- ---------------------------- DROP TABLE IF EXISTS `tb_user`; CREATE TABLE `tb_user` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `user_name` varchar(255) DEFAULT NULL, `password` varchar(255) DEFAULT NULL, `name` varchar(255) DEFAULT NULL, `age` int(11) DEFAULT NULL, `email` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; -- ---------------------------- -- Records of tb_user -- ---------------------------- BEGIN; INSERT INTO `tb_user` VALUES (1, '赵一伤', '123456', 'zys', 19, 'zys@qq.cn'); INSERT INTO `tb_user` VALUES (2, '钱二败', '123456', 'qes', 18, 'qes@qq.cn'); INSERT INTO `tb_user` VALUES (3, '孙三毁', '123456', 'ssh', 20, 'ssh@qq.cn'); INSERT INTO `tb_user` VALUES (4, '李四摧', '123456', 'lsc', 20, 'lsc@qq.cn'); INSERT INTO `tb_user` VALUES (5, '周五输', '123456', 'zws', 20, 'zws@qq.cn'); INSERT INTO `tb_user` VALUES (6, '吴六破', '123456', 'wlp', 21, 'wlp@qq.cn'); INSERT INTO `tb_user` VALUES (7, '郑七灭', '123456', 'zqm', 22, 'zqm@qq.cn'); INSERT INTO `tb_user` VALUES (8, '王八衰', '123456', 'wbs', 22, 'wbs@qq.cn'); INSERT INTO `tb_user` VALUES (9, '张无忌', '123456', 'zwj', 25, 'zwj@qq.cn'); INSERT INTO `tb_user` VALUES (10, '赵敏', '123456', 'zm', 26, 'zm@qq.cn'); INSERT INTO `tb_user` VALUES (11, '赵二伤', '123456', 'zes', 25, 'zes@qq.cn'); INSERT INTO `tb_user` VALUES (12, '赵三伤', '123456', 'zss1', 28, 'zss1@qq.cn'); INSERT INTO `tb_user` VALUES (13, '赵四伤', '123456', 'zss2', 29, 'zss2@qq.cn'); INSERT INTO `tb_user` VALUES (14, '赵五伤', '123456', 'zws', 39, 'zws@qq.cn'); INSERT INTO `tb_user` VALUES (15, '赵六伤', '123456', 'zls', 29, 'zls@qq.cn'); INSERT INTO `tb_user` VALUES (16, '赵七伤', '123456', 'zqs', 39, 'zqs@qq.cn'); COMMIT; SET FOREIGN_KEY_CHECKS = 1;
2.3 创建工程，引入场景依赖
org.springframework.boot spring-boot-starter-parent 2.3.10.RELEASE 1.8 mysql mysql-connector-java org.projectlombok lombok true org.springframework.boot spring-boot-starter-test test com.baomidou mybatis-plus-boot-starter 3.4.22.4 编写DataSource相关配置
#datasource spring: datasource: url: jdbc:mysql://192.168.200.150:3306/mp?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver说明：如果想在mybatis-plus自行是看打印的sql，可配置：
#mybatis-plus配置控制台打印完整带参数SQL语句 mybatis-plus: configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
2.5 编码
实体类：
package com.shen.sh.pojo; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; /** * @Description: * @Version: V1.0 */ @TableName("tb_user") // 指定表名 @Data @NoArgsConstructor @AllArgsConstructor @Builder public class User { private Long id; private String userName; private String password; private String name; private Integer age; private String email; }@TableName("tb_user”) : 如果数据库的表名和实体类一致时可以省略
编写mapper：
package com.shen.sh.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.shen.sh.pojo.User; /** * 使用mp定义Mapper，需要让Mapper接口继承 BaseMapper接口。 */ public interface UserMapper extends BaseMapper { }启动类增加 @MapperScan 注解
package com.shen.sh; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @MapperScan("com.shen.sh.mapper") public class MpApplication { public static void main(String[] args) { SpringApplication.run(MpApplication.class, args); } }2.6 测试
package com.shen.sh; import com.shen.sh.mapper.UserMapper; import com.shen.sh.pojo.User; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @SpringBootTest public class UserMapperTest { @Autowired private UserMapper userMapper; /** * 根据id查询 */ @Test public void testSelectById() { User user = userMapper.selectById(1L); System.out.println(user); } }3 MP实现常规增删改操作
通过查看BaseMapper源码，我们发现该接口几乎定义了所有常规的增删改查操作：
3.1 MP实现插入操作
BaseMapper定义操作方法
注意事项：
1.如果主键对应的实体类属性中没有设置主键的生成策略，那么MP自动为主键生成值，且回填到实体对象下；
2.如果未指定主键生成策略，即使表的主键是主键自增，也不会使用主键自增；
代码测试
@Test public void testInsert() { User user = User.builder() .userName("shen") .name("qq") .age(15) .email("qq@qq.cn") .password("111111") .build(); int insert = userMapper.insert(user); System.out.println(insert); }插入数据时，我们发现表中ID设置默认自增，但是实际生成的id却是很长串的数字？
3.2 MP主键字段注解-@TableId
注解@TableId介绍
@TableId注解作用：
- 映射表中主键字段与实体类属性的关系（尤其表中主键字段名称与实体类属性名称不一致时）；
- 定义主键生成策略；
@TableId使用：
添加在实体类的主键对应的成员属性上即可；
@TableName("tb_user") // 指定表名 @Data @NoArgsConstructor @AllArgsConstructor @Builder public class User { @TableId(value="id")//字段不一致时，通过value值指定table中主键字段名称 private Long userId; private String userName; private String password; private String name; private Integer age; private String email; }MP主键生成策略介绍
主键生成策略:
是指为数据库生成主键的方式，我们前面学的数据库主键自增也是一种生成主键的策略，当然除了数据库服务端帮助我们维护主键之外，客户端也可以对主键值进行生成维护。
MP主键生成策略示例：
//指定主键自增的生成策略 @TableId(value = "user_id",type = IdType.AUTO) private Integet userId;
MP常用主键生成策略
MP提供的常用主键生成策略如下：
生成策略 应用场景 特点 IdType.AUTO 数据库主键自增(确保数据库设置了 主键自增 否则无效) 1.使用数据库自带的主键自增值；
2.数据库自增的主键值会回填到实体类中；
3.数据库服务端生成的；IdType.ASSIGN_ID 主键类型为number类型或数字类型String 1.MP客户端生成的主键值；
2.生成的主键值是数字形式的字符串
3.主键对应的类型可以是数字类型或者数字类型的字符串
4.底层基于雪花算法，让数据库的唯一标识也参与id的生成运算，保证id在分布式环境下，全局唯一（避免id的主键冲突问题）；IdType.ASSIGN_UUID 主键类型为 string（包含数字和字母组成） 1.生成的主键值包含数字和字母组成的字符串；
2.注意事项：如果数据库中主键值是number类型的，可不可用雪花算法
通过翻阅源码，我们发现IdType.ASSIGN_ID底层基于雪花算法保证主键ID的唯一性：
说明：生成ID的过程让时间戳、数据库服务器标识、序列化号等参与运算，保证分布式环境下ID的唯一性，避免主键冲突；
雪花算法：说白了就是指定在那个机房（机房id）的那台机器（机器的id）在什么时间点（时间戳）下生成的，如果同一台机器存在并发生成主键值，则序列号参（并发的版本号）数运算；
3.3 普通列注解-@TableField
注解@TableField作用
注解@TableField作用：
- 指定表中普通字段与实体类属性之间的映射关系；
- 忽略实体类中多余属性与表中字段的映射关系(@TableField(exist = false))；
以下情况可以省略：
- 名称一样
- 数据库字段使用_分割，实体类属性名使用驼峰名称（自动开启驼峰映射）
代码示例
/** * 实体类的属性名和数据库的字段名自动映射： * 1. 名称一样 * 2. 数据库字段使用_分割，实体类属性名使用驼峰名称 */ @TableName("tb_user") @Data public class User { //设置id生成策略:AUTO 数据库自增 @TableId(type = IdType.AUTO) private Long id; //@TableField("user_name") private String userName; private String password; @TableField("t_name") private String name; private Integer age; private String email; //增删改查操作时，忽略该属性 @TableField(exist = false) private String address; }3.4.MP实现删除操作
BaseMaper定义的常用删除方法：
根据id删除
int count = userMapper.deleteById(8L);
根据id集合批量删除
List ids = new ArrayList(); ids.add(6); ids.add(7); userMapper.deleteBatchIds(ids);根据map构造条件，删除
Map map = new HashMap(); //delete from tb_user where user_name = ? and age = ? map.put("user_name","qq"); map.put("age","18"); userMapper.deleteByMap(map);3.5 MP实现更新操作
根据实体对象中的id更新数据
注意事项：只更新实体类中存在的数据，如果对应的属性为null，不更新；
@Test public void testUpdateById() { User user = new User(); user.setId(2L); user.setPassword("1111111"); int count = userMapper.updateById(user); }4.MP实现查询操作
MP查询API概览：
4.1 MP实现分页查询
配置分页拦截器
package com.shen.sh.config; import com.baomidou.mybatisplus.annotation.DbType; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * @Description: * @Version: V1.0 */ @Configuration public class MybatisPlusConfig { @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL); // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false // paginationInterceptor.setOverflow(false); // 设置最大单页限制数量，-1不受限制 paginationInterceptor.setMaxLimit(-1L); interceptor.addInnerInterceptor(paginationInterceptor); return interceptor; } }查询测试
/** * 分页查询： * 1. 当前页码：currentPage * 2. 每页显示条数：size * * 注意：使用mp的分页要设置一个拦截器！！！ */ @Test public void testSelectPage() { int current = 1;//当前页码 int size = 2;//每页显示条数 IPage page = new Page(current,size); userMapper.selectPage(page,null); List records = page.getRecords();//当前页的数据 long pages = page.getPages();//总页数 2 long total = page.getTotal();//总记录数 4 System.out.println(records); System.out.println(pages); System.out.println(total); }4.2 QueryWrapper实现基础查询
/** * 基础比较查询 * Wrapper接口: * 1.QueryWrapper * LambdaQueryWrapper //查询 * 2.UpdateWrapper * LambdaUpdateWrapper //更新 */
QueryWrapper常用API
eq( ) : 等于 = ne( ) : 不等于 或者 != gt( ) : 大于 > ge( ) : 大于等于 >= lt( ) : 小于 Parameters: %伤%(String), 123456(String), 19(Integer), 25(Integer), 29(Integer) */ List users = userMapper.selectList(wrapper); System.out.println(users); }4.3 QueryWrapper逻辑查询or
OR查询说明
- 通过QueryWrapper多条件查询时，默认使用and关键字拼接SQL;
- 通过QueryWrapper调用or()方法时，底层会使用or关键字拼接方法左右的查询条件;
代码示例
业务要求：查询用户名为"lisi"或者年龄大于23的用户信息；
@Test public void testWrapper2(){ //1.创建查询条件构建器 QueryWrapper wrapper = new QueryWrapper(); //2.设置条件 wrapper.eq("user_name","lisi") .or() .lt("age",23); /* select * from tb_user where user_name = ? or age4.4 QueryWrapper模糊查询like
模糊查询常用方法
- like(“表列名”,“条件值”); 作用：查询包含关键字的信息，底层会自动添加匹配关键字，比如:%条件值%
- likeLeft(“表列名”,“条件值”); 作用：左侧模糊搜索，也就是查询以指定条件值结尾的数据，比如:%条件值
- likeRight(“表列名”,“条件值”);作用：右侧模糊搜索，也就是查询以指定条件值开头的数据，比如:条件值%
代码演示
/** * 模糊查询 */ @Test public void testWrapper3(){ //1.创建查询条件构建器 QueryWrapper wrapper = new QueryWrapper(); //2.设置条件 wrapper.likeLeft("user_name","zhang"); /* SELECT id,user_name,password,name,age,email from tb_user where user_name like ? %zhang */ List users = userMapper.selectList(wrapper); System.out.println(users); }4.5 QueryWrapper排序查询
核心方法
- orderByAsc 升序排序，方法内可传入多个字段
- orderByDesc 降序排序，方法内可传入多个字段
代码实现
需求：先根据age升序排序，如果年龄相同则按照id降序排序；
@Test public void testWrapper4(){ //1.创建查询条件构建器 QueryWrapper wrapper = new QueryWrapper(); //2.设置条件 wrapper.eq("user_name","lisi") .or() .lt("age",23) .in("name","李四","王五") //.orderBy(true,true,"age") .orderByDesc("age"); /* select * from tb_user where user_name = ? or age4.6 QueryWrapper限定字段查询
select方法说明
MP查询时，默认将表中所有字段数据映射查询，但是有时我们仅仅需要查询部分字段信息，这是可以使用select()方法限定返回的字段信息，避免I/O资源的浪费；
示例：
wrapper.select("字段1","字段2",......)代码示例
@Test public void testWrapper5(){ //1.创建查询条件构建器 QueryWrapper wrapper = new QueryWrapper(); //2.设置条件 wrapper.eq("user_name","lisi") .or() .lt("age",23) .in("name","李四","王五") //.orderBy(true,true,"age") .orderByDesc("age") .select("id","user_name"); /* select id,user_name from tb_user where user_name = ? or age4.7 QueryWrapper实现分页条件查询
方法说明
//参数1：分页对象 //参数2：查询条件 mapper.selectPage(page,wrapper);
代码实现
需求：查询年龄大于23的用户信息，并显示第2页，每页大小为3；
@Test public void testWrapper6(){ int current = 1;//当前页码 int size = 2;//每页显示条数 //1. 构建分页对象 Page page = new Page(current,size); //2. 构建条件对象 QueryWrapper wrapper = new QueryWrapper(); wrapper.lt("age",23); userMapper.selectPage(page,wrapper); List records = page.getRecords(); long total = page.getTotal(); long pages = page.getPages(); System.out.println(records); System.out.println(total);//2 System.out.println(pages);//1 }4.8 LambdaQueryWrapper查询
使用QueryWrapper开发存在的问题
- 使用QueryWrapper查询数据时需要手写对应表的列名信息，及其容易写错，开发体验不好；
- 使用QueryWrapper查询数据时，表的列名硬编码书写，后期一旦表结构更改，则会带来很大的修改工作量，维护性较差；
LambdaQueryWrapper可以解决上述出现问题，开发推荐使用；
代码实现
@Test public void testWrapper4() throws Exception{ // LambdaQueryWrapper wrapper = new LambdaQueryWrapper(); LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(); // wrapper.like("user_name", "%伤%") // .eq("password","123456") // .ge("age", 28) // .between("age",29 , 39); // 包含边界值 wrapper.like(User::getUserName, "%伤%") .eq(User::getPassword, "123456") .ge(User::getAge, 28) .between(User::getAge, 29, 39) .orderByDesc(User::getAge) .select(User::getId, User::getUserName); List users = userMapper.selectList(wrapper); System.out.println(users); }4.9 LambdaQueryWrapper实现删除和更新操作
条件删除
/** * 条件删除 * @throws Exception */ @Test public void testWrapper5() throws Exception{ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery().eq(User::getUserName, "武大郎"); int i = userMapper.delete(wrapper); System.out.println(i); }条件更新
/** * 条件更新 * @throws Exception */ @Test public void testWrapper6() throws Exception{ /** * UPDATE tb_user SET t_name=? WHERE (id = ?) */ // 参数1： 最新的值 User user = new User(); user.setUserName("张三丰"); // 参数2：更新时条件 LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(); wrapper.eq(User::getId, 15); int update = userMapper.update(user, wrapper); System.out.println(update); } /** * 条件更新 * @throws Exception */ @Test public void testWrapper7() throws Exception{ /** * UPDATE tb_user SET t_name=?, user_name=? WHERE (id = ?) */ // 参数1： 最新的值 // 参数2：更新时条件 LambdaUpdateWrapper wrapper = Wrappers.lambdaUpdate(); wrapper.eq(User::getId, 15) .set(User::getUserName, "张三丰666") .set(User::getName,"zsf666"); int update = userMapper.update(null, wrapper); System.out.println(update); }4.10 自定义查询接口实现分页查询
说明
目前我们使用MP自带的分页插件可以很友好的实现分页查询操作，但是如果一些查询需要我们自定义SQL,那该如何实现分页查询操作呢？
实现流程
- 自定义接口中直接传入Page分页对象即可；
package com.shen.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.shen.pojo.User; import org.apache.ibatis.annotations.Param; import java.util.List; /** * @Description 定义mapper接口 * @Created by shen */ //@Mapper public interface UserMapper extends BaseMapper { /** * 查询大于指定id的用户信息，并分页查询实现 * @param page * @param id * @return */ IPage findGtIdByPage(IPage page, @Param("id") Long id); }- 定义xml映射文件
select * from tb_user where id > #{id}- 测试
/** * @Description 自定义sql分页查询实现 */ @Test public void test19(){ IPage page=new Page(2,3); IPage users = userMapper.findGtIdByPage(page, 3l); System.out.println(users.getRecords()); System.out.println(user.getPages()); System.out.println(user.getTotal()); }5 MP实现Service封装
5.1 MP封装Service介绍
说明
MybatisPlus为了开发更加快捷，对业务层也进行了封装，直接提供了相关的接口和实现类;
我们在进行业务层开发时，可以继承它提供的接口和实现类，使得编码更加高效;
实现流程
- 定义一个服务扩展接口,该接口继承公共接口IService;
- 定义一个服务实现类，该类继承ServiceImpl,并实现自定义的扩展接口;
注意事项：
1.ServiceImpl父类已经注入了UserMapper对象，名称叫做baseMapper，所以当前实现类直接可以使用baseMapper完成操作
2.因为ServiceImpl已经实现了IService下的方法，所以当前服务类没有必要再次实现
思想：共性的业务代码交给框架封装维护，非共性的业务，在接口UserService定义，然后在当前的服务类下实现；
核心API介绍
5.2 MP封装Service快速入门
代码实现：
定义服务扩展接口
//在公共接口的基础上扩展 public interface UserService extends IService { }定义服务实现
@Service public class UserServiceImpl extends ServiceImpl implements UserService {}测试测试
package com.shen; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.itheima.mapper.UserMapper; import com.itheima.pojo.User; import com.itheima.service.UserService; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.omg.PortableInterceptor.USER_EXCEPTION; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import java.util.Arrays; import java.util.HashMap; import java.util.List; /** * @Description * @Created by shen */ @SpringBootTest public class MpTestService { @Autowired private UserService userService; /** * @Description 测试查询操作 根据id查询 */ @Test public void test1(){ User user = userService.getById(3l); System.out.println(user); } }5.3 MP封装Service实现CRUD操作
服务层API的封装大致与持久层一致：
/** * @Description 测试条件查询，且仅返回一个 * getOne:sql查询的结果必须为1条或者没有，否则报错 ！！！！ */ @Test public void test2(){ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(User.class); wrapper.gt(User::getAge,20); User one = userService.getOne(wrapper); System.out.println(one); } /** * @Description 根据条件批量查询 */ @Test public void test3(){ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(User.class); wrapper.gt(User::getAge,20); List list = userService.list(wrapper); System.out.println(list); } /** * @Description 根据条件批量查询并分页 */ @Test public void test4(){ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(User.class); wrapper.gt(User::getAge,20); //构建分页对象 IPage page=new Page(2,3); userService.page(page,wrapper); System.out.println(page.getRecords()); System.out.println(page.getPages()); System.out.println(page.getTotal()); } /** * @Description 测试服务层save保存单条操作 */ @Test public void test5(){ User user1 = User.builder().name("wangwu").userName("laowang4"). email("444@163.com").age(20).password("333").build(); boolean isSuccess = userService.save(user1); System.out.println(isSuccess?"保存成功":"保存失败"); } /** * @Description 测试服务层批量保存 */ @Test public void test6(){ User user2 = User.builder().name("wangwu2").userName("laowang2"). email("444@163.com").age(20).password("333").build(); User user3 = User.builder().name("wangwu3").userName("laowang3"). email("444@163.com").age(20).password("333").build(); boolean isSuccess = userService.saveBatch(Arrays.asList(user2, user3)); System.out.println(isSuccess?"保存成功":"保存失败"); } /** * @Description 根据id删除操作 */ @Test public void test7(){ boolean isSuccess = userService.removeById(17l); System.out.println(isSuccess?"保存成功":"保存失败"); } /** * @Description 根据条件批量删除 */ @Test public void test8(){ LambdaQueryWrapper wrapper = Wrappers.lambdaQuery(User.class); wrapper.gt(User::getId,12) .gt(User::getAge,20); boolean remove = userService.remove(wrapper); System.out.println(remove); } /** * @Description 测试根据id更新数据 */ @Test public void test9(){ //UPDATE tb_user SET password=?, t_name=? WHERE id=? User user2 = User.builder().name("wangwu2").password("333").id(3l).build(); boolean success = userService.updateById(user2); System.out.println(success); } /** * @Description 测试根据条件批量更新 */ @Test public void test10(){ LambdaUpdateWrapper wrapper = Wrappers.lambdaUpdate(User.class); //UPDATE tb_user SET age=? WHERE (id IN (?,?,?)) wrapper.in(User::getId,Arrays.asList(1l,3l,5l)).set(User::getAge,40); boolean update = userService.update(wrapper); System.out.println(userService); }6 逻辑删除
实际在删除数据时，为了数据留痕，一般选择逻辑删除，也就是为删除表添加逻辑删除字段，通过修改字段状态值来表示数据是否被删除；
案例：
为tb_user添加逻辑删除字段：
mp配置：
# 设置mp运行时行为 mybatis-plus: configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台输出sql global-config: db-config: logic-delete-field: deleted # 约定全局删除字段 logic-delete-value: 1 logic-not-delete-value: 0调整实体类：
@Data @NoArgsConstructor//主要用于mybatis底层反射构建user实体类对象 @AllArgsConstructor//主要是lombok基于构建者模式构建对象 @Builder /** * 如果变的名称与实体类名称一致，该注解可省略 */ @TableName("tb_user") public class User { //...... @TableLogic//指定逻辑删除字段 private Integer deleted; }测试
@Test public void testDelete(){ //根据id删除 int count = userMapper.deleteById(15l); System.out.println(count); }输出的效果：
但是对应的查询如果不加添加，则删除的无法查询到：
@Test public void testGetById(){ User user = userMapper.selectById(15l); System.out.println(user); }效果：
逻辑删除本质就是拦截sql，动态追加sql片段
查询 deleted=0
删除： 将sql转化成update操作；
7 乐观锁
乐观锁就是当前操作者认为在自己操作资源的过程中，其他人操作相同资源的可能性极低，所以无需加锁，而是通过设置一个版本号来加以约束；
悲观锁：排它锁，比如synchronized关键字就是悲观锁，当前线程做操作时，不允许其它线程做操作；
乐观锁：当前线程做操作时，允许其它线程做操作，但是如果其它线程做了操作，则当前操作失败；
乐观锁在数据库中有什么优势？
避免长事务场景锁定数据资源，导致其它线程操作该资源时阻塞，如果阻塞过多，那么导致数据库连接资源耗尽，进而数据库宕机了；
本质上就是在操作前，先获取操作行的version版本号，然后再做前天操作，然后最后再更新这一行，更新时，给sql条件一个判断版本号的sql片段： select version，xxx from user where id=100; version=30 --> 做其他操作(20s);—> update user set xxx,version=version+1 where xxxx and version=30;
使用场景：
1.业务操作周期长，如果业务整个加入事务，导致数据库资源锁定周期过长，性能降低；
2.如果资源争抢过于激烈，会导致失败重试次数过多，导致性能降低；
示例：
实体类配置：
@Data @NoArgsConstructor//主要用于mybatis底层反射构建user实体类对象 @AllArgsConstructor//主要是lombok基于构建者模式构建对象 @Builder /** * 如果变的名称与实体类名称一致，该注解可省略 */ @TableName("tb_user") public class User { //...... @Version private Integer version; }配置乐观锁拦截器：
/** * 注册插件 * @return */ @Bean public MybatisPlusInterceptor mybatisPlusInterceptor(){ //构建mp的插件注册器bean，通过该bean可批量注册多个插件 MybatisPlusInterceptor plusInterceptor = new MybatisPlusInterceptor(); //配置乐观锁拦截器 OptimisticLockerInnerInterceptor optimisticLockerInnerInterceptor = new OptimisticLockerInnerInterceptor(); //注册 plusInterceptor.addInnerInterceptor(optimisticLockerInnerInterceptor); return plusInterceptor; }测试：
/** * @Description 测试乐观锁 */ @Test public void testOp(){ User user = userMapper.selectById(5l); System.out.println(user); user.setName("zws777"); userMapper.updateById(user); }使用mp的乐观锁，需要先自己根据主键id查询用户信息，信息中包含了此时的version数据，然后再更新，更新时会将查询的version值作为更新条件取更新；
效果：
8 MP实现属性自动填充
在插入和更新数据时，我们会写大量重复的代码去设置更新时间和创建时间。而MP则将这一点进行了考虑帮我们实现了。当然自己通过自定义注解和AOP的方式也可以实现这一功能。
自动填充是 MyBatis-Plus 提供的一个功能，它允许你在插入或更新记录时自动填充某些字段，例如自动设置创建时间或更新时间字段。这个功能特别适用于那些几乎在每个业务中都需要的公共字段，比如创建时间、修改时间、操作人等。
如何使用自动填充
要在 MyBatis-Plus 中使用自动填充，你需要进行几个步骤的设置：
-
定义字段：在你的实体类中，定义需要自动填充的字段。
-
使用注解标记字段：使用 @TableField 注解标记这些字段，并指定 fill 属性。例如，对于一个需要自动填充创建时间和更新时间的字段，你可以这样做：
import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.FieldFill; import java.time.LocalDateTime; public class YourEntity { // 其他字段... @TableField(fill = FieldFill.INSERT) private LocalDateTime createTime; @TableField(fill = FieldFill.INSERT_UPDATE) private LocalDateTime updateTime; }这里 createTime 在插入时自动填充，而 updateTime 在插入和更新时都会自动填充。
-
实现 MetaObjectHandler 接口：你需要创建一个类来实现 MetaObjectHandler 接口，并在这个类中重写 insertFill 和 updateFill 方法来指定自动填充的逻辑。
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler; import org.apache.ibatis.reflection.MetaObject; import org.springframework.stereotype.Component; import java.time.LocalDateTime; @Component public class MyMetaObjectHandler implements MetaObjectHandler { @Override public void insertFill(MetaObject metaObject) { this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起名createTime this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); } @Override public void updateFill(MetaObject metaObject) { this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); } }
原理
MyBatis-Plus 实现自动填充的原理是基于 MyBatis 的拦截器（Interceptor）机制。当执行插入或更新操作时，MyBatis-Plus 会拦截这些操作，在 SQL 执行之前，根据你的配置调用 MetaObjectHandler 中相应的方法来自动填充指定的字段。
- 拦截操作：MyBatis 允许通过插件（Plugin）机制拦截对数据库操作的调用，MyBatis-Plus 利用这一机制来实现自动填充功能。
- 反射设置值：通过 MyBatis 提供的 MetaObject 对象，MyBatis-Plus 可以反射地访问和修改实体对象的属性，从而实现在 SQL 执行前自动填充指定字段的值。
这个过程大致如下：
- 在执行插入或更新前，MyBatis-Plus 的自动填充拦截器会被触发。
- 拦截器调用 MyMetaObjectHandler 实现类中的 insertFill 或 updateFill 方法。
- 在这些方法中，你定义了自动填充字段的逻辑，比如为 createTime 或 updateTime 设置当前时间。
- 这些值随后被设置到用户的实体对象中，并随着 SQL 的执行被插入或更新到数据库中。
通过这种方式，MyBatis-Plus 简化了数据持久层的开发工作，让开发者可以更专注于业务逻辑的实现。
通过AOP加上自定义注解的方式实现
引入依赖：
org.aspectj aspectjrt org.aspectj aspectjweaver自定义操作类型：
/** * 数据库操作类型 */ public enum OperationType { /** * 更新操作 */ UPDATE, /** * 插入操作 */ INSERT }ThreadLocal存储登录对象的用户id。
public class BaseContext { public static ThreadLocal threadLocal = new ThreadLocal(); public static void setCurrentId(Long id) { threadLocal.set(id); } public static Long getCurrentId() { return threadLocal.get(); } public static void removeCurrentId() { threadLocal.remove(); } }公共填充字段相关常亮。
/** * 公共字段自动填充相关常量 */ public class AutoFillConstant { /** * 实体类中的方法名称 */ public static final String SET_CREATE_TIME = "setCreateTime"; public static final String SET_UPDATE_TIME = "setUpdateTime"; public static final String SET_CREATE_USER = "setCreateUser"; public static final String SET_UPDATE_USER = "setUpdateUser"; }自定义注解
import com.shen.enumeration.OperationType; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 自定义注解，用于标识某个方法需要进行功能字段自动填充处理 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface AutoFill { //数据库操作类型，Update，Insert OperationType value(); }切面编程
import com.shen.annotation.AutoFill; import com.shen.constant.AutoFillConstant; import com.shen.context.BaseContext; import com.shen.enumeration.OperationType; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.stereotype.Component; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.time.LocalDateTime; /** * 自定义切面，实现公共字段自动填充处理的逻辑 */ @Aspect @Component @Slf4j public class AutoFillAspect { /** * 切入点 */ @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)") public void autoFillPointCut() { } /** * 前置通知，在通知中进行公共字段的赋值 */ @Before("autoFillPointCut()") public void autoFill(JoinPoint joinPoint) { log.info("开始进行公共字段自动填充...."); //获取当前被拦截的方法上的数据库操作类型 MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象 AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获取方法上的注解对象 OperationType operationType = autoFill.value();//获取数据库的操作类行 //获取当前被拦截的方法的参数--实体对象 Object[] args = joinPoint.getArgs(); if (args == null || args.length == 0) { return; } Object entity = args[0]; //准备赋值的数据 LocalDateTime now = LocalDateTime.now(); Long currentId = BaseContext.getCurrentId(); //根据当前不同的操作类型，为对应的属性通过反射来赋值 if (operationType == OperationType.INSERT) { //为四个公共字段赋值 try { Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class); Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class); Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class); Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class); //通过反射对对象赋值 setCreateTime.invoke(entity, now); setCreateUser.invoke(entity, currentId); setUpdateTime.invoke(entity, now); setUpdateUser.invoke(entity, currentId); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } } else if (operationType == OperationType.UPDATE) { try { Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class); Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class); setUpdateTime.invoke(entity, now); setUpdateUser.invoke(entity, currentId); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { e.printStackTrace(); } } } }在mapper层直接使用就OK了
/** * 根据id修改分类 * @param category */ @AutoFill(value = OperationType.UPDATE) void update(Category category);
- 测试
- 定义xml映射文件
