• Java修仙之高级功法篇-＞MybatisPlus

    学习技术请看目录。

    使用中的问题

    基于aop自动填充属性

    1. 步骤：
    2. 1：exclutin通过路径或自定义注解定位到方法
    3. 2：先拿到方法对象
    4. 3：通过方法对象获取：参数，注解，以及注解值
    5. 4：判断方法上的注解值，确定操作类型
    6. 5：通过反射确定方法并赋值

    apply会自动拼接and

    备注：apply里千万别用别名，不识别！！！！

    SQL语句加括号，MP的写法

    //一定要先判断，在组装条件，不然条件有问题，数据有问题

    1. //一定要先判断，在组装条件，不然条件有问题，数据有问题
    2.  
    3.    if (!EmptyUtil.isNullOrEmpty(storeVo.getStoreName())) {
    4.             queryWrapper.lambda().likeRight(Store::getStoreName,storeVo.getStoreName());
    5.         }

    初次学习及进阶知识在此开始

    1. Mapper层继承BaseMapper<实体类>
    2.  
    3. Servic层继承IService<实体类>
    4.  
    5. 实现类  继承 ServiceImpl   Mapp层，实体类
    6.  
    7. 开头	   wrapper.select(" user_name,count(*) user_id ");
    8. 结尾       wrapper.last("order by user_id desc  limit 10");
    9. 拼接SQL    wrapper.lambda().apply("mod(id," + numbers + " ) = " + index;
    10.  
    11.     版本Mybatis-PLUS 2.x常用方法:
    12. insert: 保存
    13. updateById: 根据主键更新
    14. deleteById: 根据主键删除
    15. selectById: 根据主键查询
    16. selectList: 查询所有,参数new EntityWrapper().like(“name”,“m”)
    17. selectPage: 分页查询,参数new Page(1,10),new EntityWrapper(new User())
    18. tails/120219250
    19.  
    20.     版本Mybatis-PLUS 3.x常用方法:
    21. save: 保存
    22. saveBath: 批量保存
    23. updateById: 根据主键更新
    24. updateBatchById: 根据主键批量更新
    25. removeById : 根据主键删除
    26. removeByIds: 根据多个id删除
    27. getById : 根据主键查询
    28. getOne: 根据条件返回一个结果
    29. list: 查询所有,参数new QueryWrapper()
    30. listByIds: 根据多个id查询
    31. listMaps: 参数new QueryWrapper(),返回List
    32. listByMap: 参数Map<String,Object>
    33. page: 分页查询,参数new Page(1,10),new QueryWrapper()
    34. pageMaps: 参数new QuweyWrapper(), 返回List

    @TableId注解作用：(标识主键)

    1. 标识实体类中主键对应属性；

    1. 指定主键生成策略
    1. //指定主键自增的生成策略
    2. @TableId(value = "user_id",type = IdType.AUTO)
    3. private Integet userId;
    4.  
    5. <!--小贴士: 可以通过下列语句 重置自增的值--> 
    6. ALTER TABLE table_name AUTO_INCREMENT = value;

    @TableField(标识字段)

    1.通过@TableField("表列名") 指定映射关系

    备注:名称一样 , 字段使用_分割，开启驼峰映射可忽略

    2.忽略某个字段的查询和插入 @TableField(exist = false)

    增

    1. 例:
    2. User user =
    3.     User.builder() 
    4.     .userName("itheima")
    5.     .name("itcast")
    6.     .build();
    7. int insert = userMapper.insert(user);
    8.

    删

    1. 根据id删除:
    2.  int count = userMapper.deleteById(8L);
    3.  
    4. 根据id集合批量删除:
    5.  List ids = new ArrayList();
    6.         ids.add(6);
    7.         ids.add(7);
    8. userMapper.deleteBatchIds(ids);
    9.  
    10. 根据map构造条件，删除:
    11. Map<String, Object> map = new HashMap<>();
    12. map.put("user_name","itcast");
    13. map.put("age","18");
    14. userMapper.deleteByMap(map);
    15. //delete from tb_user where user_name = ? and age = ?
    1. 1：判断传进来的数据有么有，对不对
    2. 2：根据传进来的数据去库里查。看看要修改的数据有没有。没有报错
    3.  /**
    4.      *区域删除
    5.      */
    6.     @Override
    7.     public boolean modifyRegion2(RegionEntity region) {
    8.         //判断关键数据
    9.         if (Strings.isNullOrEmpty(region.getName())||
    10.         Strings.isNullOrEmpty(region.getRemark())||
    11.                 ObjectUtils.isEmpty(region.getId())
    12.         ) {
    13.             throw new LogicException("关键参数与接口不匹配");
    14.         }
    15.         //判断业务数据
    16.         LambdaQueryWrapper<RegionEntity> wrapper = new LambdaQueryWrapper<>();
    17.         wrapper.eq(RegionEntity::getId, region.getId());
    18.         int count = this.count(wrapper);
    19.         if (count < 1) {
    20.             throw new LogicException("区域信息不存在");
    21.         }
    22.         // 3.修改区域数据并返回结果
    23.         boolean result = this.removeById(region.getId());
    24.         return result;
    25.  
    26.  
    27.  
    28.  
    29.     }

    改

    1. 更新：
    2. 更新的本质是根据id更新
    3. 1：库里id是否存在，id不存在，返回错误信息给前端。也有可能改为新增
    1. // 根据id去库里取数据，返回一个完整的数据
    2. TaskEntity task = this.getById(id);
    3. //修改数据的状态
    4. task.setTaskStatus(VMSystem.TASK_STATUS_FINISH);
    5. // 更新。传入修改后完整的数据
    6.  this.updateById(task);
    1. // 1：it里有id，2：要更新的值，3：直接updateById传入实体改
    2. public void ipd(Item it) {
    3.     LambdaQueryWrapper<Item> wrapper = new LambdaQueryWrapper<>();
    4.     itemMapper.updateById(it);// 也可以 this.updateById(it)
    5.     }
    1. updateById：直接丢进去要修改的实体。不要warp
    2. 根据实体对象中的id更新数据:  
    3. User user = new User();
    4.   user.setId(2L);
    5.   user.setPassword("1111111");
    6.   int count = userMapper.updateById(user);
    7. 备注:只更新实体类中存在的数据，如果对应的属性为null，不更新；
    8. ——————————————————————————————————————————————————————————————
    9.     备注变种： 根据id更新  it是传进来的数据，用实体类接的
    10. 	public void ipd(Item it) {
    11.         LambdaQueryWrapper<Item> wrapper = new LambdaQueryWrapper<>();
    12.         itemMapper.updateById(it);// 也可以 this.updateById(it)
    13.     }
    14.  
    15. ————————————————————————————————————————————————————————————
    16.  
    17.  根据id，部分修改  update（要修改的实体，根据什么条件修改）
    18.  // 参数1： 最新的值
    19.   User user = new User();
    20.   user.setUserName("张三丰");
    21.  
    22.  // 参数2：更新时条件  //这个好用：LambdaQueryWrapper<Item> wrapper = new LambdaQueryWrapper<>();
    23.   LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
    24.   wrapper.eq(User::getId, 15);
    25.  
    26. //开始更新
    27.   int update = userMapper.update(user, wrapper);
    28. ————————————————————————————————————————————————————————————————
    29. 在某个字段原先的基础上修改：
    30. //把num字段加5
    31. LambdaUpdateWrapper<User> updateWrapper = Wrappers.<User>lambdaUpdate()
    32.   .eq(User::getId, userId)
    33.   .setSql("count = count + 5");//“count = count  字段名=字段名+5”
    34.  
    35. userService.update(updateWrapper);
    36. 链式编程：itemUpdateWrapper.eq("id", id).setSql("stock=stock+" + num);
    37. __________________________________________________________________
    38.     UpdateWrapper:
    39.   var updateWrapper = new LambdaUpdateWrapper<TaskEntity>();
    40.     updateWrapper.set(TaskEntity::getTaskStatus, VMSystem.TASK_STATUS_PROGRESS);
    41.     updateWrapper.set(TaskEntity::getUpdateTime, LocalDateTime.now());
    42.     updateWrapper.eq(TaskEntity::getTaskId, task.getTaskId());
    43.     return this.update(updateWrapper);
    44. ——————————————————————————————————————————————————
    45. _________________________________________________________
    46. @Test
    47. public void testUpdateById() {
    48.   User user = new User();
    49.   user.setId(2L);
    50.   user.setPassword("1111111");
    51.   int count = userMapper.updateById(user);
    52. }
    53. ——————————————————————————————————————————————————————————————
    54.  /**
    55.      * UPDATE tb_user SET t_name=? WHERE (id = ?)
    56.      */
    57.   // 参数1： 最新的值。这里是set
    58.   User user = new User();
    59.   user.setUserName("张三丰");
    60.  
    61.   // 参数2：更新时条件  。 这里是where
    62.   LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
    63.   wrapper.eq(User::getId, 15);
    64.  
    65.   int update = userMapper.update(user, wrapper);
    66.  
    67. ——————————————————————————————————————————————————————————
    68.  
    69. 其余写法：
    70.   /**
    71.          * UPDATE tb_user SET t_name=?, user_name=? WHERE (id = ?)
    72.          */
    73.   // 参数1： 最新的值
    74.   // 参数2：更新时条件
    75.   LambdaUpdateWrapper<User> wrapper = Wrappers.<User>lambdaUpdate();
    76.   wrapper.eq(User::getId, 15)
    77.     .set(User::getUserName, "张三丰666")
    78.     .set(User::getName,"zsf666");
    79.  
    80.   int update = userMapper.update(null, wrapper);

    1. 1：判断传进来的数据有么有，对不对
    2. 2：根据传进来的数据去库里查。看看要修改的数据有没有。没有报错
    3. 3：...
    4. 4:没问题再修改
    5.     
    6.  @Override
    7.     public boolean modifyRegion(RegionEntity region) {
    8.         // 判断关键信息
    9.         if (Strings.isNullOrEmpty(region.getName())||Strings.isNullOrEmpty(region.getRemark())
    10.                 || ObjectUtils.isEmpty(region.getId())) {
    11.  
    12.             throw new LogicException("关键参数与接口不匹配");
    13.         }
    14.         //判断业务数据
    15.         // 区域信息，判断是否存在
    16.         LambdaQueryWrapper<RegionEntity> wrapper = new LambdaQueryWrapper<>();
    17.         wrapper.eq(RegionEntity::getId, region.getId());
    18.         int count = this.count(wrapper);
    19.         if (count < 1) {
    20.             throw new LogicException("区域信息不存在");
    21.         }
    22.         //修改区域数据并返回结果
    23.         this.updateById(region);
    24.         return false;
    25.     }

    update：

    查

    1. //返回库里所有数据
    2. List<User> users = userMapper.selectList(null);
    3.  
    4. // 穿个wrp拿数据，有没有id都行
    5. LambdaQueryWrapper<PolicyEntity> wrapper2 = new LambdaQueryWrapper<>();
    6.         wrapper2.eq(PolicyEntity::getCreateTime, date);
    7.         this.getById(wrapper2);
    8.  
    9. //查询一个
    10. this.getOne(wp);

    count

    1. count：返回的是符合条件的数据有几条
    2. LambdaQueryWrapper<RegionEntity> wrapper = new LambdaQueryWrapper<>();
    3. wrapper.eq(RegionEntity::getId, region.getId());
    4. int count = this.count(wrapper);

    分页

    1. getCurrent()：获取当前页数。     第几页
    2. getRecords() 方法返回的是当前页的数据记录列表    第几页的内容
    3. getTotal()：获取总记录数。
    4. getPages()：获取总页数。    
    5. getSize()：获取每页显示的条目数量。
    6. hasNext()：判断是否有下一页。
    7. hasPrevious()：判断是否有上一页。
    1. 牛皮写法： mp下，底层查实现类关联的库，然后分页。 有条件:加个lmdwp,装在this.page里
    2. Page<NodeEntity> pageEntity = new Page<>(page, paseSize);
    3. this.page(pageEntity); //这一步会返回一个结果集，里面封装了数据，但是看不到
    1.   int current = 1;//当前页码
    2.   int size = 2;//每页显示条数
    3.  
    4. 写法一：
    5.   IPage<User> page = new Page(current,size);
    6.   userMapper.selectPage(page,null); // 分页对象,查询条件(条件写wrps)
    7.   List<User> records = page.getRecords();//当前页的数据
    8.   long pages = page.getPages();//总页数 2
    9.   long total = page.getTotal();//总记录数 4
    10.  
    11.    pageEntity.getCurrent(); //当前的页数 这两条另加的
    12.    pageEntity.getSize(); //当前的条数
    13. 备注:配置类添加分页拦截器
    14.  
    15. //写法二：
    16. 1.创建分页对象（MP）
    17. Page<RegionEntity> pageEntity = new Page<>(pageIndex,pageSize);
    18. 2：构建查询对象
    19. LambdaQueryWrapper<RegionEntity> wrapper = new LambdaQueryWrapper<>();
    20.  wrapper.like(RegionEntity::getName,name);
    21. 3：查询数据并返回
    22. this.page(pageEntity,wrapper); //这一步会返回一个结果集，里面封装了数据，但是看不到
    23.  
    1. 1：看看page，size传没传。校验参数
    2. 2：如果page，size没有，看看给个默认值，还是报错
    3. 3：然后再查

    前置:配置分页拦截器

    1. @Configuration
    2. public class MybatisPlusConfig {
    3.     @Bean
    4.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
    5.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    6.  
    7.         PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
    8.         // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
    9.         // paginationInterceptor.setOverflow(false);
    10.         // 设置最大单页限制数量，-1不受限制
    11.         paginationInterceptor.setMaxLimit(-1L);
    12.         interceptor.addInnerInterceptor(paginationInterceptor);
    13.         return interceptor;
    14.     }
    15.     
    16. }

    自定义SQL实现分页查询

    1. /**
    2.      * @Description 自定义sql分页查询实现
    3.      */
    4. @Test
    5. public void test19(){
    6.     IPage<User> page=new Page<>(2,3);
    7.     IPage<User> users = userMapper.findGtIdByPage(page, 3l);
    8.     System.out.println(users.getRecords());
    9.     System.out.println(user.getPages());
    10.     System.out.println(user.getTotal());
    11. }

    Mapper层

    1. //@Mapper
    2. public interface UserMapper extends BaseMapper<User> {
    3.     /**
    4.      * 查询大于指定id的用户信息，并分页查询实现
    5.      * @param page
    6.      * @param id
    7.      * @return
    8.      */
    9.     IPage<User> findGtIdByPage(IPage<User> page, @Param("id") Long id);
    10. }

    XML

    1. "1.0" encoding="UTF-8" ?>
    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.itheima.mapper.UserMapper">
    6.  
    7.     <select id="findGtIdByPage" resultType="com.itheima.pojo.User">
    8.         select * from tb_user where id > #{id}
    9.     select>
    10. mapper>

    常用API

    1. eq( ) :  等于 =
    2. ne( ) :  不等于 <>
    3. gt( ) :  大于 >
    4. ge( ) :  大于等于  >=
    5. lt( ) :  小于 <
    6. le( ) :  小于等于 <=
    7. between ( ) :  BETWEEN 值1 AND 值2 
    8. notBetween ( ) :  NOT BETWEEN 值1 AND 值2 
    9. in( ) :  in
    10. notIn( ) ：not in
    11. like() :  模糊查询 '%xxx%'
    12. likeLeft();  模糊查询 '%xxx'
    13. likeRight();  模糊查询 'xxx%'

    QueryWrapper(条件组装工具)

    1. 例:查询用户中姓名包含"伤"，
    2.     密码为"123456",
    3.     且年龄为19或者25或者29，
    4.     查询结果按照年龄降序排序；
    5.  
    6. // 1:获取封装器
    7. QueryWrapper<User> wrapper = new QueryWrapper<>();
    8.  
    9.   // 2:封装查询条件
    10.   wrapper.like("user_name", "伤")
    11.     .eq("password","123456")
    12.     .in("age",19,25,29)
    13.     .orderByDesc("age","id");   // 降序   升序：asc
    14.  
    15. 	//3.查询仍要由Mapper对象完成
    16.   List<User> users = userMapper.selectList(wrapper);
    17.   System.out.println(users);

    or

    通过QueryWrapper调用or()方法时，底层会使用or关键字拼接方法左右的查询条件;

    1. 查询:姓名是lisi,或者年龄大于23,姓名是王五,李四其中一个
    2. //1.创建查询条件构建器
    3.     QueryWrapper<User> wrapper = new QueryWrapper<>();
    4.  
    5.  //2.设置条件
    6.     wrapper.eq("user_name","lisi")
    7.         .or()
    8.         .lt("age",23)
    9.         .in("name","李四","王五");//
    10.  
    11. //3.查询仍要由Mapper对象完成
    12. List<User> users = userMapper.selectList(wrapper);
    13.  
    14. select * from tb_user where user_name = ? or age < ? and name in (?,?)

    in

    1. //查询到list集合
    2. List<User> userList = userService.selectById(id);
    3. //结果集
    4. List<String> resultList = new ArrayList<>();
    5. //遍历集合取值
    6.  userList .forEach(item->{
    7.       resultList.add(item.getYouNeedId());
    8.  });
    9.  //条件构造器in上手使用
    10.  QueryWrapper<User> qw = new QueryWrapper<>();
    11.  qw.in("you_need_id", resultList);
    12.  //这里有个分页的查询，你也可以不用分页，用mybatisplus里面封装的其他方法
    13.  IPage<User> userIPage = userMapper.selectPage(page, qw);
    14.  //返回查询结果，getRecords也是mybatisplus里面封装的方法
    15.  return contractRecordIPage.getRecords();
    基于大于多少，小于多少去做

    大于小于

    1. // 发布时间 >= 开始时间
    2.         wrapper.ge(dto.getBeginPubDate() != null,WmNews::getPublishTime, dto.getBeginPubDate());
    3.         // 发布时间 <= 开始时间
    4.         wrapper.le(dto.getEndPubDate()!=null,WmNews::getPublishTime, dto.getBeginPubDate());

    like

    1. like("表列名","条件值");     
    2. 作用：查询包含关键字的信息，底层会自动添加匹配关键字，比如:%条件值%
    3.     
    4. likeLeft("表列名","条件值"); 
    5. 作用：左侧模糊搜索，也就是查询以  指定条件值结尾的数据，比如:%条件值
    6.  
    7. likeRight("表列名","条件值");
    8. 作用：右侧模糊搜索，也就是查询以  指定条件值开头的数据，比如:条件值%
    1.  //1.创建查询条件构建器
    2.         QueryWrapper<User> wrapper = new QueryWrapper<>();
    3.         //2.设置条件
    4.         wrapper.likeLeft("user_name","zhang");
    5.         /*
    6.             SELECT id,user_name,password,name,age,email
    7.              from tb_user
    8.              where user_name like ?
    9.              %zhang
    10.          */
    11.         List<User> users = userMapper.selectList(wrapper);

    orderBy排序

    orderByAsc 升序排序

    orderByDesc 降序排序

    1. 需求：先根据age升序排序，如果年龄相同则按照id降序排序；
    2.  
    3.  //1.创建查询条件构建器
    4.         QueryWrapper<User> wrapper = new QueryWrapper<>();
    5.         //2.设置条件
    6.         wrapper.eq("user_name","lisi")
    7.                 .or()
    8.                 .lt("age",23)
    9.                 .in("name","李四","王五")
    10.                 //.orderBy(true,true,"age")
    11.                 .orderByDesc("age");
    12.         /*
    13.             select * from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
    14.          */
    15.         List<User> users = userMapper.selectList(wrapper);

    限定查询字段

    即: 规定 select 的字段 ,增加查询效率,避免IO浪费

    wrapper.select("字段1","字段2",......)
    1.  //1.创建查询条件构建器
    2.         QueryWrapper<User> wrapper = new QueryWrapper<>();
    3.         //2.设置条件
    4.         wrapper.eq("user_name","lisi")
    5.                 .or()
    6.                 .lt("age",23)
    7.                 .in("name","李四","王五")
    8.                 //.orderBy(true,true,"age")
    9.                 .orderByDesc("age")
    10.                 .select("id","user_name"); // 这里规定了:只查 id跟username
    11.         /*
    12.             select id,user_name from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
    13.          */
    14.         List<User> users = userMapper.selectList(wrapper);
    15.         System.out.println(users);

    分页查询（及参数说明）

    1. getCurrent()：获取当前页数。
    2. getRecords() 方法返回的是当前页的数据记录列表
    3. getTotal()：获取总记录数。
    4. getPages()：获取总页数。
    5. getSize()：获取每页显示的条目数量。
    6. hasNext()：判断是否有下一页。
    7. hasPrevious()：判断是否有上一页。

    getRecords:获取查询数据

    apmIndexSetMapper.selectPage(page,wrapper).getRecords();

    1.     	//参数1：分页对象    参数2：查询条件
    2. mapper.selectPage(page,wrapper);
    1.     	int current = 1;//当前页码
    2.         int size = 2;//每页显示条数
    3.  
    4.         //1. 构建分页对象
    5.         Page<User> page = new Page<>(current,size);// 第几页,每页几条
    6.  
    7.         //2. 构建条件对象
    8.         QueryWrapper<User> wrapper = new QueryWrapper();
    9.         wrapper.lt("age",23);
    10.  
    11.     	// Mapper对象执行查询
    12.         userMapper.selectPage(page,wrapper);// 分页对象,查询条件
    13.         List<User> records = page.getRecords();//当前页的数据
    14.         long total = page.getTotal();//总页数 2
    15.         long pages = page.getPages();//总记录数 4
    16.  
    17. 备注:配置类添加分页拦截器

    LambdaQueryWrapper(推荐使用)

    例:

    1. 		QueryWrapper<User> wrapper = new QueryWrapper<>();
    2.         //2.设置条件
    3.         wrapper.likeLeft("user_name","zhang");// QueryWrapper需要手写字段
    4. 						//类名::字段 ,值  // lmd方式,不需要手写字段了
    5.  
    6.  
    1. 1.使用QueryWrapper查询数据时需要手写对应表的列名信息，及其容易写错，开发体验不好；
    2. 2.使用QueryWrapper查询数据时，表的列名硬编码书写，后期一旦表结构更改，则会带来很大的修改工作量，维护性较差

    使用:

    1. 更新为例:前置
    2. User user = new User();
    3. user.setUserName("张三丰");
    4.  
    5.  
    6. 1: 获取 lmd 的 组装器
    7. 	LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
    8. 2: 组装条件
    9. 	wrapper.eq(User::getId, 15);
    10. 3: Mapper对象执行查询
    11. 	userMapper.update(user, wrapper);// 要更新进去的值 , 条件
    12.  
    13.

    删除
    1. LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery().eq(User::getUserName, "武大郎");
    2. int i = userMapper.delete(wrapper);

    更新
    1.  // 参数1： 最新的值
    2.   User user = new User();
    3.   user.setUserName("张三丰");
    4.  
    5.  // 参数2：更新时条件
    6.   LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
    7.   wrapper.eq(User::getId, 15);
    8.  
    9. //开始更新
    10.   int update = userMapper.update(user, wrapper);

    Mapper层方法

    服务层方法：

    1. package com.itheima;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    5. import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
    6. import com.baomidou.mybatisplus.core.metadata.IPage;
    7. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    8. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    9. import com.itheima.mapper.UserMapper;
    10. import com.itheima.pojo.User;
    11. import com.itheima.service.UserService;
    12. import org.junit.jupiter.api.Assertions;
    13. import org.junit.jupiter.api.Test;
    14. import org.omg.PortableInterceptor.USER_EXCEPTION;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.boot.test.context.SpringBootTest;
    17.  
    18. import java.util.Arrays;
    19. import java.util.HashMap;
    20. import java.util.List;
    21.  
    22. /**
    23.  * @Description
    24.  * @Created by itheima
    25.  */
    26. @SpringBootTest
    27. public class MpTestService {
    28.     @Autowired
    29.     private UserService userService;
    30.  
    31.     /**
    32.      * @Description 测试查询操作 根据id查询
    33.      */
    34.     @Test
    35.     public void test1(){
    36.         User user = userService.getById(3l);
    37.         System.out.println(user);
    38.     }
    39.  
    40.     /**
    41.      * @Description 测试条件查询，且仅返回一个
    42.      * getOne:sql查询的结果必须为1条或者没有，否则报错 ！！！！
    43.      */
    44.     @Test
    45.     public void test2(){
    46.         LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
    47.         wrapper.gt(User::getAge,20);
    48.         User one = userService.getOne(wrapper);
    49.         System.out.println(one);
    50.     }
    51.  
    52.     /**
    53.      * @Description 根据条件批量查询
    54.      */
    55.     @Test
    56.     public void test3(){
    57.         LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
    58.         wrapper.gt(User::getAge,20);
    59.         List<User> list = userService.list(wrapper);
    60.         System.out.println(list);
    61.     }
    62.  
    63.     /**
    64.      * @Description 根据条件批量查询并分页
    65.      */
    66.     @Test
    67.     public void test4(){
    68.         LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
    69.         wrapper.gt(User::getAge,20);
    70.         //构建分页对象
    71.         IPage<User> page=new Page<>(2,3);
    72.         userService.page(page,wrapper);
    73.         System.out.println(page.getRecords());
    74.         System.out.println(page.getPages());
    75.         System.out.println(page.getTotal());
    76.     }
    77.  
    78.     /**
    79.      * @Description 测试服务层save保存单条操作
    80.      */
    81.     @Test
    82.     public void test5(){
    83.         User user1 = User.builder().name("wangwu").userName("laowang4").
    84.                 email("444@163.com").age(20).password("333").build();
    85.         boolean isSuccess = userService.save(user1);
    86.         System.out.println(isSuccess?"保存成功":"保存失败");
    87.     }
    88.  
    89.     /**
    90.      * @Description 测试服务层批量保存
    91.      */
    92.     @Test
    93.     public void test6(){
    94.         User user2 = User.builder().name("wangwu2").userName("laowang2").
    95.                 email("444@163.com").age(20).password("333").build();
    96.         User user3 = User.builder().name("wangwu3").userName("laowang3").
    97.                 email("444@163.com").age(20).password("333").build();
    98.         boolean isSuccess = userService.saveBatch(Arrays.asList(user2, user3));
    99.         System.out.println(isSuccess?"保存成功":"保存失败");
    100.     }
    101.     
    102.     /**
    103.      * @Description 根据id删除操作
    104.      */
    105.     @Test
    106.     public void test7(){
    107.         boolean isSuccess = userService.removeById(17l);
    108.         System.out.println(isSuccess?"保存成功":"保存失败");
    109.     }
    110.  
    111.     /**
    112.      * @Description 根据条件批量删除
    113.      */
    114.     @Test
    115.     public void test8(){
    116.         LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery(User.class);
    117.         wrapper.gt(User::getId,12)
    118.                 .gt(User::getAge,20);
    119.         boolean remove = userService.remove(wrapper);
    120.         System.out.println(remove);
    121.     }
    122.  
    123.     /**
    124.      * @Description 测试根据id更新数据
    125.      */
    126.     @Test
    127.     public void test9(){
    128.         //UPDATE tb_user SET password=?, t_name=? WHERE id=?
    129.         User user2 = User.builder().name("wangwu2").password("333").id(3l).build();
    130.         boolean success = userService.updateById(user2);
    131.         System.out.println(success);
    132.  
    133.     }
    134.  
    135.     /**
    136.      * @Description 测试根据条件批量更新
    137.      */
    138.     @Test
    139.     public void test10(){
    140.         LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate(User.class);
    141.         //UPDATE tb_user SET age=? WHERE (id IN (?,?,?))
    142.         wrapper.in(User::getId,Arrays.asList(1l,3l,5l)).set(User::getAge,40);
    143.         boolean update = userService.update(wrapper);
    144.         System.out.println(userService);
    145.  
    146.     }
    147. }

    逻辑删除

    逻辑删除：表里设置一个删除字段，0表示存在，1表示删除。

    后续删除变成更新，删除字段由0变成1，表示已删除。（但数据依然存在）

    1：配置文件

    1. # 设置mp运行时行为
    2. mybatis-plus:
    3.   configuration:
    4.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台输出sql
    5.   global-config:
    6.     db-config:
    7.       logic-delete-field: deleted # 约定全局删除字段
    8.       logic-delete-value: 1
    9.       logic-not-delete-value: 0

    2：添加一个字段表示逻辑删除

    1. /**
    2.  * 如果变的名称与实体类名称一致，该注解可省略
    3.  */
    4. @TableName("tb_user")
    5. public class User {
    6. 	//......
    7.     @TableLogic//指定逻辑删除字段
    8.     private Integer deleted;
    9. }

    3：表里添加删除字段

    后续执行删除，删除语句变为更新语句

    1. //根据id删除
    2. int count = userMapper.deleteById(15l);

    后续执行查询：

    底层自动在SQL语句追加删除字段为0.表示查询还存在的

    自动填充

    1：实体类设置Fill

    1. @TableName("tb_user")
    2. @Data
    3. @NoArgsConstructor
    4. @AllArgsConstructor
    5. @Builder
    6. public class User {
    7. 	//指定插入时自动填充的字段
    8.     @TableField(value = "create_time",fill = FieldFill.INSERT)//这里！！！
    9.     private Date createTime;
    10.   	//自定插入或者更新时自动填充的字段
    11.     @TableField(value = "update_time",fill = FieldFill.INSERT_UPDATE)
    12.     private Date updateTime;
    13. }

    2：配置填充规则

    1. @Component
    2. public class FillDataHandler implements MetaObjectHandler {
    3.  
    4.     /**
    5.      * 定义自动填充的方法
    6.      * @param metaObject
    7.      */
    8.     @Override
    9.     public void insertFill(MetaObject metaObject) {
    10.         //设置insert操作时的时间点
    11.         metaObject.setValue("createTime",new Date());
    12.         //设置update操作时的时间点
    13.         metaObject.setValue("updateTime",new Date());
    14.  
    15.     }
    16.  
    17.     /**
    18.      * 定义更新时填充的方法
    19.      * @param metaObject
    20.      */
    21.     @Override
    22.     public void updateFill(MetaObject metaObject) {
    23.         //设置update操作时的时间点
    24.         metaObject.setValue("updateTime",new Date());
    25.     }
    26. }

    乐观锁

    1：配置Bean

    1.   /**
    2.      * 注册插件
    3.      * @return
    4.      */
    5.     @Bean
    6.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
    7.         //构建mp的插件注册器bean，通过该bean可批量注册多个插件
    8.         MybatisPlusInterceptor plusInterceptor = new MybatisPlusInterceptor();
    9.         //配置乐观锁拦截器
    10.         OptimisticLockerInnerInterceptor optimisticLockerInnerInterceptor = new OptimisticLockerInnerInterceptor();
    11.         //注册
    12.         plusInterceptor.addInnerInterceptor(optimisticLockerInnerInterceptor);
    13.         return plusInterceptor;
    14.     }

    2：表里添加version字段

    3：实体类添加version字段，并加version注解

    1. @TableName("tb_user")public class User {  
    2.     @Version   
    3.     private Integer version;
    4. }

    1.     /**
    2.      * @Description 测试乐观锁
    3.      */
    4.     @Test
    5.     public void testOp(){
    6.         //这点要保证update中要设置之前的version
    7.         User user = userMapper.selectById(5l);
    8.         System.out.println(user);
    9.         user.setName("zws777");
    10.         userMapper.updateById(user);
    11.     }

    原理：

    每次修改version+1，执行更新，将version作为条件

    分页查询备注

  • 相关阅读:
    matplotlib.collections、(二)
    C++实现轻量级RPC分布式网络通信框架
    【第四部分 | JavaScript 基础】2：运算、控制流程、数组
    Java多线程篇(12)——ForkJoinPool
    算法Day16 | 104.二叉树的最大深度，559.n叉树的最大深度， 111.二叉树的最小深度，222.完全二叉树的节点个数
    .NET 服务 ServiceController
    【校招VIP】java专业课之分页、分段
    数据分析框架1.0 从黄金思维圈到万能三步走
    基于讯飞星火大语言模型开发的智能插件：小策问答
    【单片机】51单片机存储使用总结
  • 原文地址：https://blog.csdn.net/weixin_50914566/article/details/132814154