MybatisPlus

基本操作

1. pom引入相关依赖：

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

1. 增删改查：

@SpringBootTest
class MabatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;

    //查找
    @Test
    public void findAll()
    {
        //查所有
//        List<User> users = userMapper.selectList(null);
//        System.out.println(users);

        //查一条
        System.out.println( userMapper.selectById(13L));

        //查多条
//        System.out.println(userMapper.selectBatchIds(Arrays.asList(1,2,3)));

        //根据条件查询, map里面条件是 && 的关系
//        HashMap<String, Object> map = new HashMap<>();
//        map.put("name","julian");
//        map.put("age",1000);
//        List<User> user = userMapper.selectByMap(map);
//        System.out.println(user);

    }

    //添加
    @Test
    public void addUser()
    {
        User user = new User();
        user.setAge(11);
        user.setEmail("990850239@xx.com");
        user.setName("kerr444455");
        int insert = userMapper.insert(user);
        System.out.println("insert: "+insert);
    }


    //修改操作
    @Test
    public void updateUser()
    {
        User user = new User();
        user.setId(13L);
        user.setAge(5);
        System.out.println(userMapper.updateById(user));
    }

    @Test
    public void deleteUser()
    {
    	//1. 删除一条
//        System.out.println(userMapper.deleteById(12L));
        //2. 删除多条
        //System.out.println(userMapper.deleteBatchIds(Arrays.asList(11L,10L)));


        //3. 根据条件删除, map里面条件是 && 的关系
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","julian");
        map.put("age",1000);
        System.out.println(userMapper.deleteByMap(map));
    }

}

---

自动填充

1. 数据库增加两个字段：create_time update_time
2. 实体类增加两个成员变量，并使用注解：

    @TableField(fill= FieldFill.INSERT)
    private Date createTime;

    @TableField(fill=FieldFill.INSERT_UPDATE)
    private Date updateTime;

3. 自定义类实现MetaObjectHandler接口，并重写insertFill 和 updateFill方法，注意这里需要加上@Componet交个spring管理：

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    //使用mp添加操作时候，这个方法执行
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime",new Date(), metaObject);
        this.setFieldValByName("updateTime",new Date(), metaObject);
    }

    //使用mp修改操作后，这个方法执行
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(), metaObject);
    }
}

4. 测试添加、删除操作，数据库自动填充create_time 和 update_time 这两个字段，无需要手动set。

---

乐观锁

介绍：

当程序中可能出现并发的情况时，需要做并发控制，否则会造成读问题（脏读、幻读、不可重复读）和写问题（丢失跟新）。

（1）脏读：
（2）幻读：
（3）不可重复读：
（4）丢失跟新问题：并发查询和跟新同一数据，导致最后数据不正确

解决方案：

• 悲观锁：在读的时候对该数据进行加锁以防止并发（实质就是串行），具有强烈的独占和排他特性。
• 乐观锁：在数据进行提交更新的时候，会对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。MybatisPlus是通过添加version字段来实现。

操作：

1. 数据库中加上version的字段
2. 实体类中加version的成员变量，并且加上@version的注解
3. 配置乐观锁插件

@Configuration
@MapperScan("com.julian.mabatis_plus.mapper")
public class MpConfig {

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

4. 测试乐观锁，版本号会+1：

    @Test
    public void testOptimisticLocker()
    {
        User user = userMapper.selectById(14L);//先查再修改
        user.setAge(1000);
        System.out.println(userMapper.updateById(user));
    }

---

分页

1. 配置分页插件：

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

2. 创建分页page对象
3. 调用mp的分页方法，查询结果最后封装在page对象里面
4. 测试相关分页数据

  @Test
    public void testPage()
    {
        //1. 创建page对象，传入两个参数（当前页，每页显示条数）
        Page<User> page = new Page<>(2,3);

        //2. 调用mp的分页方法，查询结果最后封装在page对象里面
        userMapper.selectPage(page,null);

        //3. 通过page对象获取分页数据
        System.out.println(page.getCurrent()); // 当前页
        System.out.println(page.getRecords()); //每页数据list集合
        System.out.println(page.getSize()); //每页显示的记录条数
        System.out.println(page.getTotal()); //总记录数
        System.out.println(page.getPages()); //总页数

        System.out.println(page.hasNext()); //如果有下一页，为true
        System.out.println(page.hasPrevious()); //如果有上一页，为true
    }

---

逻辑删除

1. 数据库中添加is_delete字段，用来标记逻辑意义上是否删除
2. 在实体类中添加isDelete成员变量，并加上注解@TableLogic
3. 配置逻辑删除的插件：

    @Bean
    public ISqlInjector sqlInjector()
    {
        return new LogicSqlInjector();
    }

4. 在application.properties配置delete的值所代表的意义，默认0是没有删除，1是已删除，可不配置选默认：

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5. 测试正常的删除操作，这时由物理删除变成逻辑删除，从数据库中看被删除的数据依然存在，但是delete字段变成1，这时再执行查询操作得不到相关数据信息

---

性能分析插件

用来分析每条SQL语句的执行时间，有助于发现问题。

1. 配置插件：

    @Bean
    @Profile({"dev","test"})//当前插件只对 dev和test环境起作用（dev test prod）
    public PerformanceInterceptor performanceInterceptor()
    {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//设置100ms，超时的sql语句不执行
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }

2. application.properties配置文件中设置环境

# 环境配置dev  test   prod
spring.profiles.active=dev

3. 测试，输入log会显示当前sql语句的执行时间，如果超过设置的时间则执行不成功：
   

超时报错：

---

MybatisPlus实现复杂条件查询

通过QueryWrapper类实现复杂查询：

    @Test
    public void testQuery()
    {
        //创建QueryWrapper对象
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        //通过QueryWrapper内置的方法设置复杂条件

//        //1. ge >=     gt >   le <=   lt <
//        wrapper.ge("age",10);
//        System.out.println(userMapper.selectList(wrapper));
//
//
//        //2. eq  =   ne !=
//        wrapper.ne("name","julian");
//        System.out.println(userMapper.selectList(wrapper));


        //3. between, 包含两端
//        wrapper.between("age",5,60);
//        System.out.println(userMapper.selectList(wrapper));

        //4. like 模糊查询
//        wrapper.like("name","永");
//        System.out.println(userMapper.selectList(wrapper));



        //5. orderByDesc:降序    orderByAsc：升序
//        wrapper.orderByDesc("id");
//        System.out.println(userMapper.selectList(wrapper));


        //6. last 在后面拼接1条sql语句
//          wrapper.orderByAsc("id");
//          wrapper.last("limit 1");
//          System.out.println(userMapper.selectList(wrapper));


        // 7. 指定查询列
//        wrapper.orderByAsc("id");
//        wrapper.select("id","name");
//        wrapper.last("limit 1");
//        System.out.println(userMapper.selectList(wrapper));
    }