• 【MyBatis-Plus】的基本使用(SpringBoot)

    1、什么是 MyBatis-Plus

    Mybatis-Plus：为简化开发而生

            MyBatis-Plus（简称 MP）是一个基于 MyBatis 的增强工具，它对 Mybatis 的基础功能进行了增强，但未做任何改变。使得我们可以可以在 Mybatis 开发的项目上直接进行升级为 Mybatis-plus，正如它对自己的定位，它能够帮助我们进一步简化开发过程，提高开发效率。

            Mybatis-Plus 其实可以看作是对 Mybatis 的再一次封装，升级之后，对于单 表的 CRUD 操作，调用 Mybatis-Plus 所提供的 API 就能够轻松实现，此外还提供了各种查询方式、分页等行为。最最重要的，开发人员还不用去编写 XML，这就大大降低了开发难度

    2、快速使用

    1、导入依赖

    1.         <dependency>
    2.             <groupId>mysqlgroupId>
    3.             <artifactId>mysql-connector-javaartifactId>
    4.         dependency>
    5.  
    6.         <dependency>
    7.             <groupId>com.baomidougroupId>
    8.             <artifactId>mybatis-plus-boot-starterartifactId>
    9.             <version>3.4.3.4version>
    10.         dependency>
    11.  
    12.         <dependency>
    13.             <groupId>com.baomidougroupId>
    14.             <artifactId>mybatis-plusartifactId>
    15.             <version>3.5.1version>
    16.         dependency>
    17.  
    18.         <dependency>
    19.             <groupId>com.baomidougroupId>
    20.             <artifactId>mybatis-plus-annotationartifactId>
    21.             <version>3.5.1version>
    22.         dependency>

    2、 配置数据库参数

    1. spring.datasource.password=*******
    2. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    3. spring.datasource.username=root
    4. spring.datasource.url=jdbc:mysql://localhost:3306/library?serverTimezone=UTC
    5. #mybatis的日志
    6. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
    7. #全局设置主键生成策略
    8. mybatis-plus.global-config.db-config.id-type=auto

    3、建一个数据库表

    4、文件目录

    5、实体类

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class Book {
    5.     @TableId
    6.     int bookId;
    7.     String bookName;
    8.     int bookCounts;
    9.     String detail;
    10.  
    11.     @TableField(fill= FieldFill.INSERT)
    12.     private Date createTime;
    13.  
    14.     @TableField(fill=FieldFill.INSERT_UPDATE)
    15.     private Date updateTime;
    16.  
    17.     @Version
    18.     @TableField(fill= FieldFill.INSERT)
    19.     private Integer version;
    20.  
    21. }

    6、做表映射

    1. @Repository
    2. public interface BookMapper extends BaseMapper {
    3. }

    7、 可以开始测试

     3、一般用法

    （1）.查找和更新操作

    1.  /**
    2.      * 插入用户表一条数据
    3.      */
    4.     @Test
    5.     public void testInsert(){
    6.         Book b1=new Book();
    7.         b1.setBookName("《xxxxxx》");
    8.         b1.setBookCounts(299);
    9.         b1.setDetail("学会使用常用的linux指令");
    10.         int result=bookMapper.insert(b1);
    11.         System.out.println(result);
    12.  
    13.     }
    14. /**
    15.      * 根据多个id查询
    16.      */
    17.     @Test
    18.     public void testSelectBatchIds(){
    19.         List books=bookMapper.selectBatchIds(Arrays.asList(1,2,3));
    20.         books.forEach(System.out::println);
    21.     }
    22.  
    23.     /**
    24.      * 简单的条件查询，通过map封装查询条件
    25.      */
    26.     @Test
    27.     public void testSelectMap(){
    28.         HashMap map=new HashMap<>();
    29.         map.put("book_name","《爱迪生的伟大发明》");
    30. //        map.put("detail","睡前小故事");
    31.         List books=bookMapper.selectByMap(map);
    32.         books.forEach(System.out::println);
    33.     }
    34.  
    35.  
    36.     /**
    37.      * 通过id修改用户信息
    38.      */
    39.     @Test
    40.     public void testUpdateById(){
    41.         Book b=new Book();
    42.         b.setBookId(15);
    43.         b.setBookName("《Linux私房菜》");
    44.         b.setDetail("好好学习指令 这是3.0版本");
    45.         b.setBookCounts(100);
    46.         int res=bookMapper.updateById(b);
    47.         System.out.println(res);
    48.     }

    (2) . 乐观锁使用

            1. 编写配置类，加入官方给的拦截器功能 ，分页也是这个 一同加上了，表中的version字段要记得写上。

    1.     /**
    2.      * 乐观锁插件
    3.      * 分页插件
    4.      */
    5.     @Bean
    6.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
    7.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    8.         //配置乐观锁
    9.         interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    10.         //配置分页
    11.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    12.         return interceptor;
    13.     }
    1.     /**
    2.      * 测试乐观锁插入
    3.      */
    4.     @Test
    5.     public void testOptimisticLocker(){
    6.         Book b1=new Book();
    7.         b1.setBookName("《深技大入场券》");
    8.         b1.setBookCounts(33);
    9.         b1.setDetail("我来了，神技大");
    10.         int result=bookMapper.insert(b1);
    11.         System.out.println(result);
    12.  
    13.     }
    14.  
    15.     /**
    16.      * 测试乐观锁更新
    17.      */
    18.     @Test
    19.     public void testUpdateByIdOptimisticLocker(){
    20.         //必须查询才能更新
    21.         Book b=bookMapper.selectById(16);
    22.         b.setBookId(16);
    23.         b.setBookName("《深技大入场券》");
    24.         b.setDetail("我来了，神技大 一定要上");
    25.         b.setBookCounts(999);
    26.         int res=bookMapper.updateById(b);
    27.         System.out.println(res);
    28.  
    29.     }

    (3). 删除操作

    1.     /**
    2.      * 根据id删除
    3.      */
    4.     @Test
    5.     public void testDeleteById(){
    6.         int id=bookMapper.deleteById(17);
    7.         System.out.println(id);
    8.     }
    9.  
    10.     /**
    11.      * 批量删除数据
    12.      */
    13.     @Test
    14.     public void testDeleteBatchByIds(){
    15.         int result=bookMapper.deleteBatchIds(Arrays.asList(18,19));
    16.         System.out.println(result);
    17.     }
    18.     /**
    19.      * 条件删除
    20.      */
    21.     @Test
    22.     public void testDeleteByMap(){
    23.         //DELETE FROM book WHERE book_counts = ?
    24.         HashMap map=new HashMap<>();
    25.         map.put("book_counts",299);
    26.         int result=bookMapper.deleteByMap(map);
    27.     }

    （4）分页查询

    1.     /**
    2.      * 分页查询
    3.      */
    4.     @Test
    5.     public void testSelectPage(){
    6.         //current 目前的
    7.         Page page=new Page<>(1,5);
    8.         bookMapper.selectPage(page, Wrappers.lambdaQuery().ge(Book::getBookId,2));
    9.         List record=page.getRecords();
    10.         record.forEach(System.out::println);
    11.  
    12.         //常用方法
    13. //        boolean hasNext=page.hasNext();
    14. //        boolean hasPrevious=page.hasPrevious();
    15. //        System.out.println(hasNext+" "+hasPrevious);
    16.     }

    4. 复杂查询

    Mybatis-Plus提供了两个常用类处理复杂查询操作，QueryWrapper和UpdateWrapper

    1.  /**
    2.      * 复杂查询的
    3.      * ge gt le lt isNull isNotNull的用法
    4.      */
    5.     @Test
    6.     public void testQueryWrapper1(){
    7.         QueryWrapper query=new QueryWrapper<>();
    8.         //SELECT COUNT(*) AS total FROM book WHERE (book_counts >= ? AND book_name IS NOT NULL)
    9.         query.ge("book_counts",60).isNotNull("book_name");
    10.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    11.         // WHERE (book_counts >= ? AND book_name IS NOT NULL) LIMIT ?
    12.         Page page=new Page<>(1,5);
    13.         bookMapper.selectPage(page,query);
    14.         page.getRecords().forEach(System.out::println);
    15.     }
    16.  
    17.  
    18.     /**
    19.      *
    20.      * 复杂查询的
    21.      *   eq ne的用法
    22.      */
    23.     @Test
    24.     public void testQueryWrapper2(){
    25.         QueryWrapper queryWrapper=new QueryWrapper<>();
    26.         queryWrapper.eq("book_id",13);
    27.         Book book=bookMapper.selectOne(queryWrapper);
    28.         System.out.println(book);
    29.     }
    30.  
    31.     /**
    32.      *
    33.      * 复杂查询的
    34.      *   between notBetween的用法
    35.      */
    36.     @Test
    37.     public void testQueryWrapper3(){
    38.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    39.         // WHERE (book_counts BETWEEN ? AND ?)
    40.         QueryWrapper queryWrapper=new QueryWrapper<>();
    41.         queryWrapper.between("book_counts",20,60);
    42.         List book=bookMapper.selectList(queryWrapper);
    43.         book.forEach(System.out::println);
    44.     }
    45.  
    46.     /**
    47.      *
    48.      * 复杂查询的
    49.      *   allEq的用法
    50.      */
    51.     @Test
    52.     public void testQueryWrapper4(){
    53.         HashMap map=new HashMap();
    54.         map.put("book_name","《1003夜》");
    55.         map.put("detail","睡前小故事");
    56.         QueryWrapper queryWrapper=new QueryWrapper<>();
    57.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    58.         // WHERE (detail = ? AND book_name = ?)
    59.         queryWrapper.allEq(map);
    60.         List l=bookMapper.selectList(queryWrapper);
    61.         l.forEach(System.out::println);
    62.     }
    63.  
    64.     /**
    65.      *
    66.      * 复杂查询的
    67.      *   like notLike likeLeft likeRight
    68.      */
    69.     @Test
    70.     public void testQueryWrapper5(){
    71.         QueryWrapper queryWrapper=new QueryWrapper<>();
    72.         queryWrapper.like("book_name","ql")
    73.                 .notLike("book_name","no");
    74.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    75.         // WHERE (book_name LIKE ? AND book_name NOT LIKE ?)
    76.         List> list=bookMapper.selectMaps(queryWrapper);
    77.         System.out.println(list);
    78.  
    79.     }
    80.  
    81.     /**
    82.      *
    83.      * 复杂查询的
    84.      *   in notIn inSql notInSql exist notExists
    85.      */
    86.     @Test
    87.     public void testQueryWrapper6(){
    88.         QueryWrapper queryWrapper=new QueryWrapper<>();
    89.         queryWrapper.inSql("book_id","select book_id from Book where book_id<10");
    90.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    91.         //      WHERE (book_id IN (select book_id from Book where book_id<10))
    92.         List bookIds=bookMapper.selectObjs(queryWrapper);
    93.         System.out.println(bookIds);
    94.     }
    95.  
    96.     /**
    97.      *
    98.      * 复杂查询的
    99.      *   or and
    100.      */
    101.     @Test
    102.     public void testQueryWrapper7(){
    103.         UpdateWrapper updateWrapper=new UpdateWrapper<>();
    104.         Book book=new Book();
    105.         book.setBookId(15);
    106.         book.setBookName("《Linux私房菜》");
    107.         book.setBookCounts(81);
    108.  
    109. //        UPDATE book SET book_name=?, book_counts=?, update_time=?
    110. //              WHERE (book_name LIKE ? OR book_counts LIKE ?)
    111.         updateWrapper.like("book_name","《Linux私房菜》").or().like("book_counts",15);
    112.         int result=bookMapper.update(book,updateWrapper);
    113.         System.out.println(result);
    114.  
    115.     }
    116.  
    117.     /**
    118.      *
    119.      * 复杂查询的
    120.      *   嵌套or  嵌套and
    121.      */
    122.     @Test
    123.     public void testQueryWrapper8(){
    124.         UpdateWrapper updateWrapper=new UpdateWrapper<>();
    125.         Book book=new Book();
    126.         book.setBookId(13);
    127.         book.setBookName("《Mysql高级进阶》");
    128.         book.setBookCounts(88);
    129.         //UPDATE book SET book_name=?, book_counts=?, update_time=?
    130.         //          WHERE (book_name LIKE ? OR (detail = ? AND book_counts <> ?))
    131.         //使用了lambda表达式，or中的表达式后面的条件会加上括号
    132.         updateWrapper.like("book_name","xxx")
    133.                 .or(i->i.eq("detail","xxxxxx").ne("book_counts",999));
    134.  
    135. //        UPDATE book SET book_name=?, book_counts=?, update_time=?
    136. //                  WHERE (book_name LIKE ? OR detail = ? AND book_counts <> ?)
    137. //        updateWrapper.like("book_name","xxx")
    138. //                .or().eq("detail","xxxxxx").ne("book_counts",999);
    139.         int result=bookMapper.update(book,updateWrapper);
    140.         System.out.println(result);
    141.     }
    142.  
    143.  
    144.     /**
    145.      *
    146.      * 复杂查询的
    147.      *   9.orderBy orderByDesc orderByAsc
    148.      */
    149.     @Test
    150.     public void testQueryWrapper9(){
    151.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    152.         //              ORDER BY book_id ASC
    153.  
    154. //        orderBy(执行条件,'是否正序',排序的列)
    155.         QueryWrapper queryWrapper=new QueryWrapper<>();
    156.         queryWrapper.orderBy(true,true,"book_id");
    157.         List books=bookMapper.selectList(queryWrapper);
    158.         System.out.println(books);
    159.     }
    160.  
    161.     /**
    162.      *
    163.      * 复杂查询的
    164.      *   10.last
    165.      *   只能调用一次，多次调用以最后一次为准 有sql注入的风险
    166.      */
    167.     @Test
    168.     public void testQueryWrapper10(){
    169.         QueryWrapper queryWrapper=new QueryWrapper<>();
    170.         //SELECT book_id,book_name,book_counts,detail,create_time,update_time,version FROM book
    171.         //          limit 1
    172.         queryWrapper.last("limit 1");
    173.         Book book=bookMapper.selectOne(queryWrapper);
    174.         System.out.println(book);
    175.     }
    176.  
    177.     /**
    178.      *
    179.      * 复杂查询的
    180.      *   11. 指点呀查询的列
    181.      */
    182.     @Test
    183.     public void testQueryWrapper11(){
    184.         QueryWrapper queryWrapper=new QueryWrapper<>();
    185.         //SELECT book_id,book_name FROM book
    186.         queryWrapper.select("book_id","book_name");
    187.         List list=bookMapper.selectList(queryWrapper);
    188.         list.forEach(System.out::println);
    189.  
    190.     }
    191.  
    192.     /**
    193.      *
    194.      * 复杂查询的
    195.      *   12. set setSql
    196.      */
    197.     @Test
    198.     public void testQueryWrapper12(){
    199.         UpdateWrapper updateWrapper=new UpdateWrapper<>();
    200.         Book book=new Book();
    201.         book.setDetail("xxxx");
    202.         //UPDATE book SET book_counts=?, detail=?, update_time=?, book_name=?,book_counts=?
    203.         //          WHERE (book_name LIKE ? OR book_id BETWEEN ? AND ?)
    204.         updateWrapper.like("book_name","《xxxxxxxxx》")
    205.                 .or()
    206.                 .between("book_id",1,20)
    207.                 .set("book_name","《Redis入门学习》")
    208. //                .setSql("detail='学好努力做缓存'")
    209.                 .set("book_counts",50);
    210.         int result=bookMapper.update(book,updateWrapper);
    211.         System.out.println(result);
    212.         System.out.println(book);
    213.  
    214.     }
      215.  

      
                
                    
                

                
    215. 

                    相关阅读:
      
                    
Win11壁纸变黑怎么办？Win11壁纸变黑了的解决方法                            
      
golang 必会之  pprof 监控系列(5) —— cpu 占用率 统计原理                            
      
PostgreSQL 16数据库的yum、编译、docker三种方式安装——筑梦之路                            
      
安卓应用的MD5、SHA1值和公钥可以这样知道                            
      
Redis缓存以及存在的问题--缓存穿透、缓存雪崩、缓存击穿及解决方法                            
      
XPath的使用                            
      
网络分析笔记01：pcapng格式的整体解包                            
      
istio系列：第四章-Ingress网关配置                            
      
等保到底在“保”什么？                            
      
关于promethus+grafana的监控exporter访问/为errorpage404（notfound）重写exporter                            
      
                          
                
      216. 
                
    216. 
                    原文地址：https://blog.csdn.net/m0_56233309/article/details/126877683
                
      217.