• Mybatis-plus使用教程

    注意点：我们在主启动类上需要扫描我们持久层文件下的所以接口

    @MapperScan("com.kuang.mapper")

    配置日志

    mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

    CRUD扩展

    1.插入测试

    1. //测试插入
    2.     @Test
    3.     public void testInsert(){
    4.        User user= new User();
    5.        user.setName("直接起飞");
    6.        user.setAge(78);
    7.        user.setEmail("23672367@qq.com");
    8.        int result=userMapper.insert(user);
    9.        System.out.println(result);
    10.  
    11.     }

     

    数据库插入的id：全局唯一id

    主键生成策略

    默认ID_WORKER全局唯一id

    分布式系统唯一id生成：https://blog.csdn.net/qq_37469055/article/details/118061067

    雪花算法：

    雪花算法就是使用64位long类型的数据存储id，最高位一位存储0或者1,0代表整数，1代表负数，一般都是0，所以最高位不变，41位存储毫秒级时间戳，10位存储机器码（包括5位datacenterId和5位workerId），12存储序列号。这样最大2的10次方的机器，也就是1024台机器，最多每毫秒每台机器产生2的12次方也就是4096个id。

    主键自增

    我们需要配置主键自增：

    1.实体类字段上 @TableId(type = IdType.AUTO)

    2.数据库字段一定要是自增的！

    3.再测试

    其余源码解释

    public enum IdType {
    AUTO(0),  //数据库id自增
    NONE(1),  //未设置主键
    INPUT(2), //手动输入
    ID_WORKER(3), //默认全局唯一id
    UUID(4),  //全局唯一id uuid
    ID_WORKER_STR(5); //ID_WORKER 字符串表示法
}

     2.更新操作

    1.  //更新操作
    2.     @Test
    3.     public void testUpdata() {
    4.         User user = new User();
    5.         //通过条件自动拼接动态sql
    6.         user.setId(6L);
    7.         user.setName("高原起飞");
    8.         //注意：updateById 但是参数是一个对象！
    9.         int result = userMapper.updateById(user);
    10.         System.out.println(result);
    11.     }

    1.  //更新操作
    2.     @Test
    3.     public void testUpdata() {
    4.         User user = new User();
    5.         //通过条件自动拼接动态sql
    6.         user.setId(6L);
    7.         user.setAge(18);
    8.         user.setName("高原起飞");
    9.         //注意：updateById 但是参数是一个对象！
    10.         int result = userMapper.updateById(user);
    11.         System.out.println(result);
    12.     }

    所有的sql都是自动帮你动态配置！

    3.自动填充

    创建时间，修改时间！这些操作都是自动化完成的，我们不希望手动更新！

    阿里巴巴开发手册：所有的表都应该配置有gmt_create，gmt_modified几乎所有的表都要配置上，且需要自动化。

    方式一：数据库级别

    1.在表中设置字段，create_time,update_time

     2.更新实体类

    1.   private Date createTime;
    2.   private Date updateTime;

    3.重新测试插入实体类信息

     方式二：代码级别

    1.数据库设置

    2.实体类属性设置

    1.     @TableField(fill = FieldFill.INSERT)
    2.     private Date createTime;
    3.     @TableField(fill = FieldFill.INSERT_UPDATE)
    4.     private Date updateTime;

    3.继承提供的类实现其方法

    1.  
    2. @Slf4j
    3. @Component //一定不要忘记把处理器加到IOC容器中
    4. public class MyMetaObjectHandler implements MetaObjectHandler {
    5.     //插入时的填充策略
    6.     @Override
    7.     public void insertFill(MetaObject metaObject) {
    8.         log.info("start insert fill......");
    9.         //setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
    10.         //                     填充的字段名           填充的值         meatObject
    11.         this.setFieldValByName("creatTime",new Date(),metaObject);
    12.         this.setFieldValByName("updateTime",new Date(),metaObject);
    13.     }
    14.  
    15.     //更改时的填充策略
    16.     @Override
    17.     public void updateFill(MetaObject metaObject) {
    18.         log.info("start update fill......");
    19.         this.setFieldValByName("updateTime",new Date(),metaObject);
    20.     }
    21. }

    4.进行测试

    插入数据测试

     修改数据测试

    5.结果查看：注意时间

     

    4.乐观锁

    乐观锁：顾名思义，它总是认为不会出现问题，无论干什么都不去上锁！如果出现了问题，再次更新值测试！

    悲观锁：顾名思义，它总是认为总是出现问题，无论干什么都上锁！再去操作！

    乐观锁实现方式：

    • 取出记录时，获取当前version
    • 更新时，带上这个version
    • 执行更新时， set version = newVersion where version = oldVersion
    • 如果version不对，就更新失败

    1.给数据库添加version字段，默认为1

    2.需要实体类加上对应的字段

    1.  //乐观锁字段
    2.     @Version
    3.     private Integer version;

    3.注册组件

    1.  
    2. import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
    3. import org.mybatis.spring.annotation.MapperScan;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.transaction.annotation.EnableTransactionManagement;
    7.  
    8. @EnableTransactionManagement //自动事务管理
    9. //使用配置类后，扫描持久层工作可以放到这里来，不在启动类上进行扫描
    10. @MapperScan("com.kuang.mapper")
    11. @Configuration //配置类
    12. public class MybatisPlusConfig {
    13.  
    14.     //注册乐观锁插件
    15.     @Bean
    16.     public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    17.         return new OptimisticLockerInterceptor();
    18.     }
    19.  
    20. }

    4.测试一下

    1.  // 测试乐观锁成功
    2.     @Test
    3.     public void testVersionSuccess(){
    4.         // 1. 查询用户信息
    5.         User user = userMapper.selectById(1L);
    6.         // 2. 修改用户信息
    7.         user.setName("嘎嘎");
    8.         user.setAge(24);
    9.         // 3. 执行更新操作
    10.         userMapper.updateById(user);
    11.     }
    12.  
    13.     // 测试乐观锁失败!多线程下
    14.     @Test
    15.     public void testVersionFall(){
    16.         // 线程1
    17.         User user1 = userMapper.selectById(1L);
    18.         user1.setName("嘎嘎111");
    19.         user1.setAge(14);
    20.  
    21.         // 线程2
    22.         User user2 = userMapper.selectById(1L);
    23.         user2.setName("嘎嘎222");
    24.         user2.setAge(24);
    25.         userMapper.updateById(user2);
    26.         
    27.         //因为user2的抢先执行使得user1中保存的version与user2执行后的不同，user1无法修改       
    28.         //自旋锁来多次尝试提交！
    29.         userMapper.updateById(user1); //如果没有乐观锁就会覆盖插队线程的值
    30.     }

    5.测试结果

    成功的结果

     失败的结果

     查询操作

    1.    // 测试查询
    2.     @Test
    3.     public void testSelectById(){
    4.         User user = userMapper.selectById(1);
    5.         System.out.println(user);
    6.     }
    7.  
    8.     // 批量查询
    9.     @Test
    10.     public void testSelectByBatchIds(){
    11.         List users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    12.         users.forEach(System.out::println);
    13.     }
    14.  
    15.     // 按照条件查询之一使用 map
    16.     @Test
    17.     public void testSelectByMap(){
    18.         HashMap map = new HashMap<>();
    19.         // 自定义要查询
    20.         map.put("name","Tom");
    21.         map.put("age","28");
    22.         List users = userMapper.selectByMap(map);
    23.         users.forEach(System.out::println);
    24.     }

    分页查询

    分页网站频繁使用

    1. 原始使用limit进行分页
    2. pageHelper第三方插件
    3. MybatisPlus内置了分页插件

    分页查询操作方法

    1.配置拦截器

    1. // 分页插件
    2. @Bean
    3. public PaginationInterceptor paginationInterceptor() {
    4.     return new PaginationInterceptor();
    5. }

    2.直接使用Page对象即可

    1. // 测试分页查询
    2. @Test
    3. public void testPage(){
    4.     // 参数一: 当前页
    5.     // 参数二： 页面大小
    6.     // 使用了分页插件之后，所有的分页操作变得简单了
    7.     Page page = new Page<>(1,5);
    8.     userMapper.selectPage(page, null);
    9.  
    10.     page.getRecords().forEach(System.out::println);
    11.     //内置许多方法，如下是得到总记录的条数
    12.     System.out.println(page.getTotal());
    13. }

    删除操作

    1. // 测试删除
    2. @Test
    3. public void testdelete(){
    4.     userMapper.deleteById(6L);
    5. }
    6.  
    7. // 测试批量删除
    8. @Test
    9. public void testdeleteBatchId(){
    10.     userMapper.deleteBatchIds(Arrays.asList(1287326823914405893L,1287326823914405894L));
    11. }
    12.  
    13. //通过map删除
    14. @Test
    15. public void testDeleteByMap(){
    16.     HashMap map = new HashMap<>();
    17.     map.put("name","KUANG");
    18.     userMapper.deleteByMap(map);
    19. }

    逻辑删除

    物理删除：从数据库中直接移除

    逻辑删除：在数据库中没有被移除，而是通过一个变量让他生效！deleted=0 --> deleted=1

    测试：

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

    2. 实体类中增加属性

    1. @TableLogic // 逻辑删除
    2. private Integer deleted;

        3.配置 

    1. // 逻辑删除组件
    2. public ISqlInjector sqlInjector(){
    3.     return new LogicSqlInjector();
    4. }
    1. # 配置逻辑删除
    2. mybatis-plus.global-config.db-config.logic-delete-value=1
    3. mybatis-plus.global-config.db-config.logic-not-delete-value=0

    4.测试删除

    5.测试查询

    以上所有的CRUD操作及其扩展操作，我们必须精通掌握！会大大提高工作效率！

    四、性能分析插件

    我们在平时的开发中，会遇到一些慢sql。解决方案：测试，druid监控…

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

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

    1.导入插件

    1. // SQL执行效率插件
    2. @Bean
    3. @Profile({"dev","test"})
    4. public PerformanceInterceptor performanceInterceptor(){
    5.     PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    6.     performanceInterceptor.setMaxTime(100); //ms 设置sql执行的最大时间，如果超过了则不执行
    7.     performanceInterceptor.setFormat(true); // 是否格式化
    8.     return performanceInterceptor;
    9. }

    记住，要在SpringBoot中配置环境为dev或者test环境！

    2.测试使用

    1. // 测试查询
    2. @Test
    3. public void testSelectById(){
    4.     User user = userMapper.selectById(3);
    5.     System.out.println(user);
    6. }

     只要超出时间就会抛出异常

    使用性能分析插件可以提高效率，新版本MP已经移除该拆件了，可以使用druid

     五、条件构造器

  • 相关阅读:
    JVM调优之排查进程CPU占用过高
    mysql数据文件
    java开发工具IntelliJ IDEA使用教程：检查项目状态
    【Spring Boot 源码研究 】- 自动化装配条件化配置Conditional剖析
    对象创建(一)
    行业解密：为什么跨境电商行业都在做社交媒体营销？
    论文阅读：攻击者的《银河系漫游指南》：开展对互联网资源供应商的路径外攻击以劫持互联网资源 the Hijackers‘ Guide To The Galaxy
    软件架构师
    前端打包工具
    Flowable 设置流程变量的四种方式
  • 原文地址：https://blog.csdn.net/weixin_57197500/article/details/127950734