mybatis-plus(2)

乐观锁

乐观锁 : 故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，再次更新值测试
悲观锁：故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！
乐观锁实现方式：
取出记录时，获取当前 version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion 如果version不对，就更新失败
乐观锁：1、先查询，获得版本号 version = 1

-- A
update user set name = "haha", version = version + 1 where id = 2 and version = 1
--	B 线程抢先完成，这个时候 version = 2，会导致 A 修改失败！ 
update user set name = "haha", version = version + 1 where id = 2 and version = 1

1、给数据库中增加version字段！

2、我们实体类加对应的字段

@Version //乐观锁Version注解
private Integer version;

3、注册组件

//	扫描我们的 mapper 文件夹
@MapperScan("com.example.mapper") 
@EnableTransactionManagement
 @Configuration // 配置类
public class MyBatisPlusConfig {
//	注册乐观锁插件
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() { return new OptimisticLockerInterceptor();
}
}

4、测试一下！

//	测试乐观锁成功！
    @Test
    public void testOptimisticLocker(){
//	1、查询用户信息
        User user = userMapper.selectById(1L);
//	2、修改用户信息
        user.setName("haha");
        user.setEmail("1425265937@qq.com");
//	3、执行更新操作
        userMapper.updateById(user);
    }
    }

@Test

public void testOptimisticLocker2(){
//	线程 1
User user = userMapper.selectById(1L);
user.setName("haha");
user.setEmail("1425265937@qq.com");
//	模拟另外一个线程执行了插队操作
User user2 = userMapper.selectById(1L);
user2.setName("haha");
user2.setEmail("1425265937@qq.com");
userMapper.updateById(user2);
//	自旋锁来多次尝试提交！
userMapper.updateById(user); // 如果没有乐观锁就会覆盖插队线程的值！
}

查询操作

    @Test
    public void testSelectById(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
//	测试批量查询！
    @Test
    public void testSelectByBatchId(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }
//	按条件查询之一使用map操作
    @Test
    public void testSelectByBatchIds(){
        HashMap<String, Object> map = new HashMap<>();
//	自定义要查询
        map.put("name","haha");
        map.put("age",20);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

1、原始的 limit 进行分页

2、pageHelper 第三方插件

3、MP 其实也内置了分页插件！
1、配置拦截器组件即可

// 分页插件

@Bean
public PaginationInterceptor paginationInterceptor() { 
return new PaginationInterceptor();
}

2、直接使用Page对象即可！

// 测试分页查询

@Test

public void testPage(){
//	参数一：当前页
//	参数二：页面大小
//	使用了分页插件之后，所有的分页操作也变得简单的！
Page<User> page = new Page<>(2,5); 
userMapper.selectPage(page,null);
page.getRecords().forEach(System.out::println); 
System.out.println(page.getTotal());
}

删除操作

//	测试删除
    @Test
    public void testDeleteById(){
        userMapper.deleteById(1302941161404551171L);
    }
//	通过id批量删除
    @Test
    public void testDeleteBatchId(){
        userMapper.deleteBatchIds(Arrays.asList(1302941161404551169L,1302941161404551170L));
    }
//	通过map删除
    @Test
    public void testDeleteMap() {
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "haha");
        userMapper.deleteByMap(map);
    }

逻辑删除
物理删除 ：从数据库中直接移除
逻辑删除 ：再数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1
管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！

测试一下：

1、在数据表中增加一个 deleted 字段

2、实体类中增加属性

@TableLogic //逻辑删除

private Integer deleted;

3、配置！

// 逻辑删除组件！

@Bean

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

配置逻辑删除

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

性能分析插件

我们在平时的开发中，会遇到一些慢sql。测试！ druid,

作用：性能分析拦截器，用于输出每条 SQL 语句及其执行时间

MP也提供性能分析插件，如果超过这个时间就停止运行！

1、导入插件

    @Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启，保证我们的效率
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100); // ms设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true); // 是否格式化代码 
        return performanceInterceptor;
    }

记住，要在SpringBoot中配置环境为dev或者 test 环境！
2、测试使用！

@Test
void contextLoads() {
//	参数是一个 Wrapper ，条件构造器，这里我们先不用 null
//	查询全部用户
List<User> users = userMapper.selectList(null);
 users.forEach(System.out::println);
}

条件查询器

1、测试一，记住查看输出的SQL进行分析

@Test
void contextLoads() {
//	查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12 
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
wrapper.isNotNull("name").isNotNull("email").ge("age",12); 
userMapper.selectList(wrapper).forEach(System.out::println); 
}

2、测试二，记住查看输出的SQL进行分析

@Test
void test2(){
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
wrapper.eq("name","haha");
User user = userMapper.selectOne(wrapper); // 查询一个数据，出现多个结果使用List或者 Map
System.out.println(user);
}

3、测试三，记住查看输出的SQL进行分析

@Test
void test3(){
//	查询年龄在 20 ~ 30 岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>();
 wrapper.between("age",20,30); // 区间
Integer count = userMapper.selectCount(wrapper);// 查询结果数 
System.out.println(count);

}

4、测试四，记住查看输出的SQL进行分析
// 模糊查询

@Test
void test4(){
//	查询年龄在 20 ~ 30 岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>();
//	左和右 t% 
wrapper
.notLike("name","e")
.likeRight("email","t");
List<Map<String, Object>> maps = userMapper.selectMaps(wrapper); 
maps.forEach(System.out::println);
}

5、测试五

// 模糊查询

@Test
void test5(){
QueryWrapper<User> wrapper = new QueryWrapper<>();
//	id 在子查询中查出来
wrapper.inSql("id","select id from user where id<3");
List<Object> objects = userMapper.selectObjs(wrapper);
 objects.forEach(System.out::println);
}

6、测试六

//测试六

@Test
void test6(){
QueryWrapper<User> wrapper = new QueryWrapper<>();
//	通过id进行排序
wrapper.orderByAsc("id");
List<User> users = userMapper.selectList(wrapper); 
users.forEach(System.out::println);
}