如果你还没阅读上一篇文章《MyBatis-Plus快速入门（一）》，建议先去阅读一下。本文是接着上一篇文章的内容来进行讲述的。

乐观锁

什么是乐观锁？什么又是悲观锁？

乐观锁：非常乐观，无论什么操作都不加锁。乐观锁的通常实现方式是在表中增加一个乐观锁字段（version）即可。当要更新一条记录时，希望这条记录没有被别人更新，一旦记录抢先被别人更新，那么当前更新就会失败。

悲观锁：非常悲观，无论什么操作都加锁。我们一旦加锁，那它就一定是悲观锁。

乐观锁的实现方式

乐观锁的实现方式如下：

• 取出记录时，获取当前version。
• 更新时，在条件中会带上这个version。
• 执行更新时，set version=newVersion where version=oldVersion，其中oldVersion就是我们一开始获取的version。
• 如果version不对，就会更新失败。

 //乐观锁失败
 @Test
 void testOptimisticLocker2(){
     //线程一查询原来的数据
     User user = userMapper.selectById(1L);
     //线程一修改当前数据
     user.setName("Jack2");
     //线程二抢先更新了
     User user2 = userMapper.selectById(1L);
     user2.setName("Jack3 ");
     userMapper.updateById(user2);
     //线程一执行修改
     userMapper.updateById(user);
 }

MP中如何配置乐观锁

1、在数据库表中添加version字段，将@Version注解添加到字段上。

@Version
private Integer version;

2、添加乐观锁插件。

@Configuration
public class MPConfig {
?
    //乐观锁插件 本质是一个拦截器
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

3、测试后发现更新SQL中自动带上了版本号。

查询策略

MP为我们提供了单条记录、多条记录、指定数量、分页等多种查询方法，测试方法如下：

//查询（使用的最多 ，单个，多个，指定数量，分页查询）
@Test
void  testSelectById(){
    User user=userMapper.selectById(1L);
    System.out.println(user);
}
@Test
void  testSelectByIds(){
    //批量查询
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}
?
@Test
void  testSelectByCount(){
    //查询数据量
    Integer count= userMapper.selectCount(null);
    System.out.println(count);
}
?
@Test
void  testSelectByMap(){
    //简单条件查询
    Map<String,Object> map=new HashMap<>();
    map.put("name","wunian");
    map.put("age",3);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

分页查询

MP的分页插件支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库。

测试代码如下：

//分页查询 limit(sql) MP内置了分页插件，导入即可
@Test
void  testPage(){
    //1、先查询总数
    //2、本质还是limit 0,10(默认的)
    //参数（当前页，每个页面的大小）
    Page<User> page=new Page<>(2,5);
    IPage<User> users = userMapper.selectPage(page, null);
    System.out.println(page.getTotal());//总数
    System.out.println(page.hasNext());//是否有下一页
    System.out.println(page.hasPrevious());//是否有上一页
    page.getRecords().forEach(System.out::println);//遍历数据
    System.out.println(page.getSize());//获取当前页的记录数
}

删除策略

MP提供了删除单条记录和多条记录的方法。测试代码如下：

//删除（单个，多个）
@Test
void testDeleteById(){
    userMapper.deleteById(1251036873686134785L);
}
?
@Test
void testDeleteByIds(){
    userMapper.deleteBatchIds(Arrays.asList(1251036873686134785L,1251045724569370626L));
}
?
//简单的条件删除
@Test
void testDeletMap(){
    Map<String,Object> map=new HashMap<>();
    map.put("name","wunian");
    map.put("age",3);
    userMapper.deleteByMap(map);
}

逻辑删除

先来了解下逻辑删除和物理删除的概念：

• 逻辑删除：并不是真的从数据库中删除了，只是加了一个条件判断而已。
• 物理删除：直接从数据库中删除了。

业务场景：管理员在后台可以看到被删除的记录，使用逻辑删除可以保证项目的安全性和健壮性。

使用方法：

1、在数据库中添加逻辑删除字段deleted

2、在实体类字段中添加逻辑删除注解@TableLogic

@TableLogic //逻辑删除字段
 private Integer deleted;

3、在配置类中添加处理逻辑删除的插件。

//逻辑删除插件
@Bean
public ISqlInjector sqlInjector() {
    return new LogicSqlInjector();
}

4、在配置文件中配置逻辑删除。

#配置逻辑删除 删除：1 不删除：0
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5、只要配置了逻辑删除，以后的查询都会带上逻辑删除字段，这样能够保证程序效率和结果正常。

6、查询被删除的数据，请单独手写SQL。

SELECT * FROM user WHERE deleted=1

性能分析

MP提供了性能分析插件，它能在开发中帮助我们排除慢SQL。

如果要使用性能分析插件，只需要在配置类中配置即可。

//SQL执行效率插件
@Bean
@Profile({"dev","test"})// 设置 dev test 环境开启
public PerformanceInterceptor performanceInterceptor() {
    PerformanceInterceptor interceptor=new PerformanceInterceptor();
    //允许执行的sql的最长时间，默认的单位是毫秒
    //超过这个时间sql会报错
    interceptor.setMaxTime(100);
    //格式化sql代码
    interceptor.setFormat(true);
    return interceptor;
}

正常开发时可以在控制台查看到SQL的执行效率。

如果SQL的执行时间，超过了我们设置的最长时间范围，控制台就会报错。

一般解决慢SQL的方法无非就是优化SQL语句，建立索引，分库分表这些。

条件构造器

我们平时编写SQL，一般使用的最多的就是一些查询条件，MP为我们提供了条件构造器来动态构造SQL语句。

测试代码如下：

@SpringBootTest
public class WrapperTest {
?
    @Autowired
    private UserMapper userMapper;
?
    //条件查询器
    @Test
    void testWrapper(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //链式编程，可以构造多个条件，会自动拼接SQL
        wrapper
                .isNotNull("name")
                .ge("age",28); //大于等于
                //.eq("age",100)
        userMapper.delete(wrapper);
    }
?
    //边界查询
    @Test
    void testWrapper2(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,28);
        userMapper.selectCount(wrapper);
    }
?
    //精准匹配
    @Test
    void testWrapper3(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        Map<String,Object> map=new HashMap<>();
        map.put("name","Jack");
        map.put("age",20);
        wrapper.allEq(map);
        userMapper.selectList(wrapper);
    }
?
    //模糊查询
    @Test
    void testWrapper4(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name","j")   //like '%j%'
                .likeRight("email","t"); // like 't%'
        userMapper.selectMaps(wrapper);
    }
    //子查询（in）
    @Test
    void testWrapper5(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //wrapper.in("id",1,2,3,4);
        //子查询
        wrapper.inSql("id","select id from user where id<3");
        userMapper.selectObjs(wrapper);
    }
?
    // and or
    @Test
    void testWrapper6(){
        User user=new User();
        user.setAge(100);
        user.setName("Jack");
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //在一些新的框架中，链式编程，lambda表达式，函数式接口用的非常多
        updateWrapper
                .like("name","k")
                .or(i->i.eq("name","wunian").ne("age",0));
        userMapper.update(user,updateWrapper);
    }
?
    //排序
    @Test
    void testWrapper7(){
        QueryWrapper<User> wrapper=new QueryWrapper();
        wrapper.orderByAsc("id");
        userMapper.selectList(wrapper);
    }
?
    //多表查询解决方案 last(不建议使用)
    //一般大公司会设计冗余字段，很少用到多表查询
    //如果要多表查询，没有简便办法，自己扩展即可
    @Test
    void testWrapper8(){
        QueryWrapper<User> wrapper=new QueryWrapper();
        wrapper.last("limit 1");
        userMapper.selectList(wrapper);
    }
}

注意：last方法只能调用一次，多次调用以最后一次为准，并且有SQL注入的风险，请谨慎使用。