Mybatis-Plus的基本使用

Mybatis-Plus

Mybatis-Plus的基本使用

1. 先导入Mybatis-Plus相关的依赖包

   <!--Mybatis-Plus-->
   		<dependency>
   			<groupId>com.baomidou</groupId>
   			<artifactId>mybatis-plus-boot-starter</artifactId>
   			<version>3.3.1</version>
   		</dependency>
   

2. 创建UserMapper接口，继承BaseMapper

   @Repository
   public interface UserMapper extends BaseMapper<User> {}
   

3. 现在这样就可以使用增删改查的方法了

       @Autowired
       private UserMapper userMapper;
   
       @Test
       public void testAdd(){
           User u = new User();
           u.setName("狗子");
           u.setAge(14);
           u.setEmail("123@qq.com");
           System.out.println( userMapper.insert(u));
       }
   
       @Test
       void updateTest(){
           User user = new User();
           user.setName("狗蛋");
           user.setEmail("123321@qqq.com");
           user.setAge(14);
           user.setId(1);
           userMapper.updateById(user);
       }
   
       @Test
       void contextLoads() {
           List<User> user = userMapper.selectList(null);
           System.out.println(user);
       }
   

ID自动生成策略

1. 首先在我们的实体类上添加注解

   @TableField(fill = FieldFill.INSERT)
       private Date createTiem;
       @TableField(fill = FieldFill.INSERT_UPDATE)
       private Date updateTiem;
   

2. 创建注解实现类

   @Component
   public class MyMetaObjectHandler implements MetaObjectHandler {
       @Override
       public void insertFill(MetaObject metaObject) {
           //当第一次创建时执行的代码
           //参数1：实体类中的名字
           //参数2：需要传进去的参数
           //参数3：方法传入的对象
           this.setFieldValByName("createTiem",new Date(),metaObject);
           this.setFieldValByName("updateTiem",new Date(),metaObject);
       }
   
       @Override
       public void updateFill(MetaObject metaObject) {
           //当修改时执行的代码
           this.setFieldValByName("updateTiem",new Date(),metaObject);
       }
   
   

3. 当对这个对象进行增加和修改的时候会自动填入值设置好的值。

   @Test
       public void testAdd(){
           User u = new User();
           u.setName("狗子");
           u.setAge(14);
           u.setEmail("123@qq.com");
           System.out.println( userMapper.insert(u));
       }
   
       @Test
       void updateTest(){
           User user = new User();
           user.setName("狗蛋");
           user.setEmail("123321@qqq.com");
           user.setAge(14);
           user.setId(1);
           userMapper.updateById(user);
       }
   

MP-乐观锁

mp乐观锁的实现，主要是使用version，就是在数据库中添加一个字段version，这个字段一般使用int类型，再你每次修改删除的时候，都会和version进行一个对比，如果一样就执行成功，如果不同就不行。

version一般在这个对象创建时进行添加，可以使用我们的@TableField(fill = FieldFill.INSERT)这个注解。

乐观锁实现步骤

1. 创建一个MybatisPlusConfig类

   //导入乐观锁插件
   @Bean
       public OptimisticLockerInterceptor optimisticLockerInterceptor(){
           return new OptimisticLockerInterceptor();
       }
   

2. 在属性上添加注解

   @Version
   @TableField(fill = FieldFill.INSERT)
   private int version;
   

3. 在我们之前创建的MyMetaObjectHandler中设置好version的值

    @Override
       public void insertFill(MetaObject metaObject) {
           //当第一次创建时执行的代码
           this.setFieldValByName("createTiem",new Date(),metaObject);
           this.setFieldValByName("updateTiem",new Date(),metaObject);
          //设置version字段的值 this.setFieldValByName("version",1,metaObject);
       }
   

4. 测试

   @Test
       public void testAdd(){
           User u = new User();
           u.setName("狗子");
           u.setAge(14);
           u.setEmail("123@qq.com");
           //创建的时候会自动添加version值
           System.out.println( userMapper.insert(u));
       }
   

多条件查询，查询多个id

 @Test
    void testFindByIds(){
        //根据多个ID查询多个值
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        System.out.println(users);
    }

    @Test
    void testFind2(){
        //根据id和姓名进行查询，需要使用Map
        HashMap<String,Object> map = new HashMap<String, Object>();
        map.put("name","柯南");
        map.put("id",1);
        List<User> users = userMapper.selectByMap(map);
        System.out.println(users);
    }

分页查询

1. 创建PaginationInterceptor对象

   //导入分页插件
       @Bean
       public PaginationInterceptor paginationInterceptor(){
           return new PaginationInterceptor();
       }
   

2. 测试

   @Test
       void testFenYe(){
           //分页查询，需要先导入Mybatis-puls的插件创建一个Bean
           Page<User> page = new Page<User>(1,3);
           Page<User> userPage = userMapper.selectPage(page,null);
           long pages = userPage.getPages();//返回总页数
           long current = userPage.getCurrent();//当前是第几页
           List<User> records = userPage.getRecords();//查询数据集合
           long total = userPage.getTotal();//一共多少条数据
           boolean hasNext = userPage.hasNext();//判断是否有下一页
           boolean hasPrevious = userPage.hasPrevious();//判断是否有上一页
           
           System.out.println("总页数："+pages);
           System.out.println("当前是第几页："+current);
           System.out.println("查询数据集合："+records);
           System.out.println("一共多少条数据："+total);
           System.out.println("是否有下一页："+hasNext);
           System.out.println("是否有上一页："+hasPrevious);
       }
   

删除

1. 根据id删除

   @Test
       void testDeleteById(){
           int i = userMapper.deleteById(4);
           System.out.println(i);
       }
   

2. 批量删除

    @Test
       void testDeleteByIDs(){
           int i = userMapper.deleteBatchIds(Arrays.asList(4, 5, 6));
           System.out.println(i);
    }
   

3. 简单条件删除

   也和条件查询一样，使用Map<String,Object>即可

   @Test
       void testDeleteByMap(){
           HashMap<String,Object> map = new HashMap<String, Object>();
           map.put("name","张三");
           map.put("id",123);
           int i = userMapper.deleteByMap(map);
           System.out.println(i);
       }
   

4. 逻辑删除

   • 什么是逻辑删除

     • 并不是真的删除，而是查询的时候不能查到。

   • 如何实现逻辑删除

     • 在表中添加字段，作为逻辑删除的标记，每次删除修改标记，0代表没删除，1的代表删除。

   • 实现步骤

     1. 给实体类添加字段deleted，并且添加上注解

        @TableLogic //逻辑删除注解
        @TableField(fill = FieldFill.INSERT)
        private int deleted;
        

     2. 在MyMetaObjectHandler类中配置逻辑删除的默认值

            @Override
            public void insertFill(MetaObject metaObject) {
                //当第一次创建时执行的代码
                this.setFieldValByName("createTiem",new Date(),metaObject);
                this.setFieldValByName("updateTiem",new Date(),metaObject);
                this.setFieldValByName("version",1,metaObject);
                //逻辑删除
                this.setFieldValByName("deleted",0,metaObject);
            }
        

     3. 测试

            @Test
            void testDeleteById(){
                int i = userMapper.deleteById(1);
                System.out.println(i);
            }
        

     4. 结果我们的删除语句变成了update修改语句
        

     5. 配置完逻辑删除后查询所有：
        

​

多条件编辑器

• wapper对象

  • Wrapper ： 条件构造抽象类，最顶端父类

    AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件

    ​ QueryWrapper ： 查询条件封装

    ​ UpdateWrapper ： Update 条件封装

    AbstractLambdaWrapper ： 使用Lambda 语法

    ​ LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper

• *查询方式*	*说明*
  *setSqlSelect*	设置 SELECT 查询字段
  *where*	WHERE 语句，拼接 + WHERE 条件
  *and*	AND 语句，拼接 + AND 字段=值
  *andNew*	AND 语句，拼接 + AND (字段=值)
  *or*	OR 语句，拼接 + OR 字段=值
  *orNew*	OR 语句，拼接 + OR (字段=值)
  *eq*	等于=
  *allEq*	基于 map 内容等于=
  *ne*	不等于<>
  *gt*	大于>
  *ge*	大于等于>=
  *lt*	小于<
  *le*	小于等于<=
  *like*	模糊查询 LIKE
  *notLike*	模糊查询 NOT LIKE
  *in*	IN 查询
  *notIn*	NOT IN 查询
  *isNull*	NULL 值查询
  *isNotNull*	IS NOT NULL
  *groupBy*	分组 GROUP BY
  *having*	HAVING 关键词
  *orderBy*	排序 ORDER BY
  *orderAsc*	ASC 排序 ORDER BY
  *orderDesc*	DESC 排序 ORDER BY
  *exists*	EXISTS 条件语句
  *notExists*	NOT EXISTS 条件语句
  *between*	BETWEEN 条件语句
  *notBetween*	NOT BETWEEN 条件语句
  *addFilter*	自由拼接 SQL
  *last*	拼接在最后，例如：last(“LIMIT 1”)

 @Test
    void testQuery(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        //查询名字是嘎子，age>=14,email 不为空
        queryWrapper.eq("name","嘎子")
                .ge("age",14)
                .isNotNull("email");
        List<User> users = userMapper.selectList(queryWrapper);
        System.out.println(users);

        //也可以将wapper对象传入delete中
        int delete = userMapper.delete(queryWrapper);
        if (delete>0){
            System.out.println("删除成功");
        }
    }