• Mybatis-Plus复习

    目录

    一.简介

    1.简介

    2.特性

    3.文档参考地址

    二.环境配置

    1.依赖

    2.配置application

    3.实体类

    4.Mapper接口

    三.基本CRUD

    1.BaseMapper

    1.增

    2.删

    3.改

    4.查

    2.IService

    1.测试

    2.注意

    四.常用注解

    1.@TableName("user")

    2.@TableId

    3.@TableField

    4. @TableLogic

    五.条件构造器和常用接口

    1.wrapper(包装)介绍

     2.QueryWrapper和UpdateWrapper

    1.特点

    2.测试

    3.修改 和条件的优先级

    4.查询部分字段

    5. 子查询

    6.动态sql（复杂版）

    7.动态sql简化版

    8.lambda用法

    六.插件

    1.分页插件

    1.配置

    2.使用

    3.根据自定义条件进行分页

    2.乐观锁插件

    1.不用锁

    2.配置乐观锁

    3.用了乐观锁

    4.优化

    七.MybatisX插件

    1.MyBatisX插件用法：

    2.第一个用法生成mapper和service以及实体类模板

     3.第二个用法快捷生成sql

     参考

    一.简介

    1.简介

    MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为 简化开发、提高效率而生。

    2.特性

    1.无侵入：只做增强不做改变，引入它不会对现有工程产生影响，损耗小：

    2.启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：

    3.内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，

    4.有强大的条件构造器，满足各类使用需求 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，

    5.支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由 配置，完美解决主键问题 支持

    6.ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强 大的 CRUD 操作

    7. 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，

    8.内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等 同于普通 List 查询 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、 Postgre、SQLServer 等多种数据库

    9.内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出 慢查询

    10.内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防 误操作

    3.文档参考地址

    官方地址: http://mp.baomidou.com
    代码发布地址: Github: https://github.com/baomidou/mybatis-plus Gitee: https://gitee.com/baomidou/mybatis-plus
    文档发布地址: https://baomidou.com/pages/24112f 

    二.环境配置

    1.依赖

    1. <dependency>        
    2. <groupId>com.baomidougroupId>        
    3. <artifactId>mybatis-plus-boot-starterartifactId>        
    4. <version>3.5.1version>    
    5. dependency>

    2.配置application

    1. # 应用名称
    2. spring.application.name=mybatisplus
    3. #默认的数据源
    4. spring.datasource.type=com.zaxxer.hikari.HikariDataSource
    5. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    6. spring.datasource.url= jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC
    7. spring.datasource.username=root
    8. spring.datasource.password=123456
    9. #显示Sql语句
    10. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
    11. #mybatis-plus.mapper-locations=classpath*:mapper/**/*.xml  默认的配置
    12. #设置实体类所对应表的同一前缀 
    13. #mybatis-plus.global-config.db-config.table-prefix=t_
    14. #mybatis-plus.global-config.db-config.table-underline=
    15. #统一设置主键生成策略
    16. #mybatis-plus.global-config.db-config.id-type=auto
    17. #别名
    18. mybatis-plus.type-aliases-package=top.remained.pojo
    19.  
    20.  
    21.

    3.实体类

    注：

    mybatisPlus 自动配置了驼峰命名 user_name =userName

    mybatisPlus  默认id就是主键

    你主键设置的是递增，如果不在配置文件中主键生成策略，默认仍是雪花算法生成的id

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class User {
    5.  
    6.     private Long id;
    7.     private String name;
    8.     private Integer age;
    9.     private String email;
    10.     public User(String name, Integer age, String email) {
    11.         this.name = name;
    12.         this.age = age;
    13.         this.email = email;
    14.     }
    15. }

    4.Mapper接口

    1. @Mapper
    2. public interface UserMapper  extends BaseMapper {
    3.  
    4. }

    三.基本CRUD

    1.BaseMapper

     Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能

    1. /*
    2.  * Copyright (c) 2011-2022, baomidou (jobob@qq.com).
    3.  *
    4.  * Licensed under the Apache License, Version 2.0 (the "License");
    5.  * you may not use this file except in compliance with the License.
    6.  * You may obtain a copy of the License at
    7.  *
    8.  *     http://www.apache.org/licenses/LICENSE-2.0
    9.  *
    10.  * Unless required by applicable law or agreed to in writing, software
    11.  * distributed under the License is distributed on an "AS IS" BASIS,
    12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13.  * See the License for the specific language governing permissions and
    14.  * limitations under the License.
    15.  */
    16. package com.baomidou.mybatisplus.core.mapper;
    17.  
    18. import com.baomidou.mybatisplus.core.conditions.Wrapper;
    19. import com.baomidou.mybatisplus.core.metadata.IPage;
    20. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
    21. import com.baomidou.mybatisplus.core.toolkit.Constants;
    22. import com.baomidou.mybatisplus.core.toolkit.ExceptionUtils;
    23. import org.apache.ibatis.annotations.Param;
    24.  
    25. import java.io.Serializable;
    26. import java.util.Collection;
    27. import java.util.List;
    28. import java.util.Map;
    29.  
    30. /*
    32.                :`
    33.                     .:,
    34.                      :::,,.
    35.              ::      `::::::
    36.              ::`    `,:,` .:`
    37.              `:: `::::::::.:`      `:';,`
    38.               ::::,     .:::`   `@++++++++:
    39.                ``        :::`  @+++++++++++#
    40.                          :::, #++++++++++++++`
    41.                  ,:      `::::::;'##++++++++++
    42.                  .@#@;`   ::::::::::::::::::::;
    43.                   #@####@, :::::::::::::::+#;::.
    44.                   @@######+@:::::::::::::.  #@:;
    45.            ,      @@########':::::::::::: .#''':`
    46.            ;##@@@+:##########@::::::::::: @#;.,:.
    47.             #@@@######++++#####'::::::::: .##+,:#`
    48.             @@@@@#####+++++'#####+::::::::` ,`::@#:`
    49.             `@@@@#####++++++'#####+#':::::::::::@.
    50.              @@@@######+++++''#######+##';::::;':,`
    51.               @@@@#####+++++'''#######++++++++++`
    52.                #@@#####++++++''########++++++++'
    53.                `#@######+++++''+########+++++++;
    54.                 `@@#####+++++''##########++++++,
    55.                  @@######+++++'##########+++++#`
    56.                 @@@@#####+++++############++++;
    57.               ;#@@@@@####++++##############+++,
    58.              @@@@@@@@@@@###@###############++'
    59.            @#@@@@@@@@@@@@###################+:
    60.         `@#@@@@@@@@@@@@@@###################'`
    61.       :@#@@@@@@@@@@@@@@@@@##################,
    62.       ,@@@@@@@@@@@@@@@@@@@@################;
    63.        ,#@@@@@@@@@@@@@@@@@@@##############+`
    64.         .#@@@@@@@@@@@@@@@@@@#############@,
    65.           @@@@@@@@@@@@@@@@@@@###########@,
    66.            :#@@@@@@@@@@@@@@@@##########@,
    67.             `##@@@@@@@@@@@@@@@########+,
    68.               `+@@@@@@@@@@@@@@@#####@:`
    69.                 `:@@@@@@@@@@@@@@##@;.
    70.                    `,'@@@@##@@@+;,`
    71.                         ``...``
    73.  _ _     /_ _ _/_. ____  /    _
    74. / / //_//_//_|/ /_\  /_///_/_\      Talk is cheap. Show me the code.
    75.      _/             /
    76.  */
    77.  
    78. /**
    79.  * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
    80.  * 
      这个 Mapper 支持 id 泛型
    81.  *
    82.  * @author hubin
    83.  * @since 2016-01-23
    84.  */
    85. public interface BaseMapper extends Mapper {
    86.  
    87.     /**
    88.      * 插入一条记录
    89.      *
    90.      * @param entity 实体对象
    91.      */
    92.     int insert(T entity);
    93.  
    94.     /**
    95.      * 根据 ID 删除
    96.      *
    97.      * @param id 主键ID
    98.      */
    99.     int deleteById(Serializable id);
    100.  
    101.     /**
    102.      * 根据实体(ID)删除
    103.      *
    104.      * @param entity 实体对象
    105.      * @since 3.4.4
    106.      */
    107.     int deleteById(T entity);
    108.  
    109.     /**
    110.      * 根据 columnMap 条件，删除记录
    111.      *
    112.      * @param columnMap 表字段 map 对象
    113.      */
    114.     int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
    115.  
    116.     /**
    117.      * 根据 entity 条件，删除记录
    118.      *
    119.      * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
    120.      */
    121.     int delete(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    122.  
    123.     /**
    124.      * 删除（根据ID或实体 批量删除）
    125.      *
    126.      * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
    127.      */
    128.     int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);
    129.  
    130.     /**
    131.      * 根据 ID 修改
    132.      *
    133.      * @param entity 实体对象
    134.      */
    135.     int updateById(@Param(Constants.ENTITY) T entity);
    136.  
    137.     /**
    138.      * 根据 whereEntity 条件，更新记录
    139.      *
    140.      * @param entity        实体对象 (set 条件值,可以为 null)
    141.      * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
    142.      */
    143.     int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper);
    144.  
    145.     /**
    146.      * 根据 ID 查询
    147.      *
    148.      * @param id 主键ID
    149.      */
    150.     T selectById(Serializable id);
    151.  
    152.     /**
    153.      * 查询（根据ID 批量查询）
    154.      *
    155.      * @param idList 主键ID列表(不能为 null 以及 empty)
    156.      */
    157.     List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);
    158.  
    159.     /**
    160.      * 查询（根据 columnMap 条件）
    161.      *
    162.      * @param columnMap 表字段 map 对象
    163.      */
    164.     List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
    165.  
    166.     /**
    167.      * 根据 entity 条件，查询一条记录
    168.      * 
      查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常
    169.      *
    170.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    171.      */
    172.     default T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper) {
    173.         List ts = this.selectList(queryWrapper);
    174.         if (CollectionUtils.isNotEmpty(ts)) {
    175.             if (ts.size() != 1) {
    176.                 throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
    177.             }
    178.             return ts.get(0);
    179.         }
    180.         return null;
    181.     }
    182.  
    183.     /**
    184.      * 根据 Wrapper 条件，判断是否存在记录
    185.      *
    186.      * @param queryWrapper 实体对象封装操作类
    187.      * @return
    188.      */
    189.     default boolean exists(Wrapper queryWrapper) {
    190.         Long count = this.selectCount(queryWrapper);
    191.         return null != count && count > 0;
    192.     }
    193.  
    194.     /**
    195.      * 根据 Wrapper 条件，查询总记录数
    196.      *
    197.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    198.      */
    199.     Long selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    200.  
    201.     /**
    202.      * 根据 entity 条件，查询全部记录
    203.      *
    204.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    205.      */
    206.     List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    207.  
    208.     /**
    209.      * 根据 Wrapper 条件，查询全部记录
    210.      *
    211.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    212.      */
    213.     List> selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    214.  
    215.     /**
    216.      * 根据 Wrapper 条件，查询全部记录
    217.      * 
      注意： 只返回第一个字段的值
    218.      *
    219.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    220.      */
    221.     List selectObjs(@Param(Constants.WRAPPER) Wrapper queryWrapper);
    222.  
    223.     /**
    224.      * 根据 entity 条件，查询全部记录（并翻页）
    225.      *
    226.      * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
    227.      * @param queryWrapper 实体对象封装操作类（可以为 null）
    228.      */
    229.     
      extends IPage> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
    230.  
    231.     /**
    232.      * 根据 Wrapper 条件，查询全部记录（并翻页）
    233.      *
    234.      * @param page         分页查询条件
    235.      * @param queryWrapper 实体对象封装操作类
    236.      */
    237.     
      extends IPage>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
    238. }
      239.  

      1.增
       

      1. //可以对ioc容器自动装配
      2. @SpringBootTest
      3. public class MybatisPlusTest {
      4.     @Autowired
      5.     private UserMapper userMapper;
      6.  
      7.     @Test
      8.     public void insert1(){
      9. //        INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
      10.         User user = new User("zz", 20, "123.com");
      11.         int result = userMapper.insert(user);
      12.         System.out.println(result);
      13. //        虽然是自增id,但是使用的是雪花算法的id
      14. //        1564895601187151874id
      15.         System.out.println(user.getId()+"id");
      16.  
      17.     }
      18.  
      19.     }
       

      2.删
       

      注：这里写1L是因为定义的为long型
       

      1.     @Test
      2.     public void del(){
      3. //        通过id删除 DELETE FROM user WHERE id=?
      4. //        int i = userMapper.deleteById(20);
      5.         1
      6. //        System.out.println(i);
      7. //        Map map = new HashMap ();
      8.         map里面存放的是条件 DELETE FROM user WHERE age = ?
      9. //        map.put("age",20);
      10.         因为年龄为20的 2个
      11. //        int i1 = userMapper.deleteByMap(map);
      12. //        System.out.println(i1);
      13. //        DELETE FROM user WHERE id IN ( ? , ? )
      14.         List list = Arrays.asList(1L, 2L);
      15. //      批量删除
      16.         userMapper.deleteBatchIds(list);
      17.  
      18.     }
       

      3.改
       

      1.     @Test
      2.     public void update(){
      3. //        UPDATE user SET name=?, age=?, email=? WHERE id=?
      4. //   必须对象里存放Id  要不然白给 因为没Id 所以不更改
      5.         User user =new User("zz",18,"456.com");
      6.         userMapper.updateById(user);
      7.         User user1 = new User();
      8.         user1.setAge(16);
      9.         user1.setId(3L);
      10. //         UPDATE user SET age=? WHERE id=?  只改对象里有的数据，没有的字段原值不变
      11.         userMapper.updateById(user1);
      12.     }
       

      4.查
       

      1.     @Test
      2.     public void sel(){
      3. //        通过id查询 SELECT id,name,age,email FROM user WHERE id=?
      4.         userMapper.selectById(3L);
      5. //        通过map集合中的条件查询 SELECT id,name,age,email FROM user WHERE age = ?
      6.         Map map = new HashMap ();
      7. //        条件为 age=16
      8.         map.put("age",16);
      9. //
      10.         userMapper.selectByMap(map);
      11. //        批量查询 SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
      12.         List list = Arrays.asList(3L,4L,5L);
      13.         userMapper.selectBatchIds(list);
      14.         //        通过条件查询一个list集合，若没有条件 则可以设置为null 即查询所有
      15.        userMapper.selectList(null);
      16. //       调用自己写的 select * from user where id=?
      17.         userMapper.selectMapById(3L);
      18.     }
       

      2.IService
       

      顶级 Service
       

      1. /*
      2.  * Copyright (c) 2011-2022, baomidou (jobob@qq.com).
      3.  *
      4.  * Licensed under the Apache License, Version 2.0 (the "License");
      5.  * you may not use this file except in compliance with the License.
      6.  * You may obtain a copy of the License at
      7.  *
      8.  *     http://www.apache.org/licenses/LICENSE-2.0
      9.  *
      10.  * Unless required by applicable law or agreed to in writing, software
      11.  * distributed under the License is distributed on an "AS IS" BASIS,
      12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      13.  * See the License for the specific language governing permissions and
      14.  * limitations under the License.
      15.  */
      16. package com.baomidou.mybatisplus.extension.service;
      17.  
      18. import com.baomidou.mybatisplus.core.conditions.Wrapper;
      19. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
      20. import com.baomidou.mybatisplus.core.metadata.IPage;
      21. import com.baomidou.mybatisplus.core.toolkit.Assert;
      22. import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
      23. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
      24. import com.baomidou.mybatisplus.extension.conditions.query.ChainQuery;
      25. import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
      26. import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
      27. import com.baomidou.mybatisplus.extension.conditions.update.ChainUpdate;
      28. import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
      29. import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
      30. import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper;
      31. import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper;
      32. import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers;
      33. import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
      34. import org.springframework.transaction.annotation.Transactional;
      35.  
      36. import java.io.Serializable;
      37. import java.util.Collection;
      38. import java.util.List;
      39. import java.util.Map;
      40. import java.util.Objects;
      41. import java.util.function.Function;
      42. import java.util.stream.Collectors;
      43.  
      44. /**
      45.  * 顶级 Service
      46.  *
      47.  * @author hubin
      48.  * @since 2018-06-23
      49.  */
      50. public interface IService {
      51.  
      52.     /**
      53.      * 默认批次提交数量
      54.      */
      55.     int DEFAULT_BATCH_SIZE = 1000;
      56.  
      57.     /**
      58.      * 插入一条记录（选择字段，策略插入）
      59.      *
      60.      * @param entity 实体对象
      61.      */
      62.     default boolean save(T entity) {
      63.         return SqlHelper.retBool(getBaseMapper().insert(entity));
      64.     }
      65.  
      66.     /**
      67.      * 插入（批量）
      68.      *
      69.      * @param entityList 实体对象集合
      70.      */
      71.     @Transactional(rollbackFor = Exception.class)
      72.     default boolean saveBatch(Collection entityList) {
      73.         return saveBatch(entityList, DEFAULT_BATCH_SIZE);
      74.     }
      75.  
      76.     /**
      77.      * 插入（批量）
      78.      *
      79.      * @param entityList 实体对象集合
      80.      * @param batchSize  插入批次数量
      81.      */
      82.     boolean saveBatch(Collection entityList, int batchSize);
      83.  
      84.     /**
      85.      * 批量修改插入
      86.      *
      87.      * @param entityList 实体对象集合
      88.      */
      89.     @Transactional(rollbackFor = Exception.class)
      90.     default boolean saveOrUpdateBatch(Collection entityList) {
      91.         return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
      92.     }
      93.  
      94.     /**
      95.      * 批量修改插入
      96.      *
      97.      * @param entityList 实体对象集合
      98.      * @param batchSize  每次的数量
      99.      */
      100.     boolean saveOrUpdateBatch(Collection entityList, int batchSize);
      101.  
      102.     /**
      103.      * 根据 ID 删除
      104.      *
      105.      * @param id 主键ID
      106.      */
      107.     default boolean removeById(Serializable id) {
      108.         return SqlHelper.retBool(getBaseMapper().deleteById(id));
      109.     }
      110.  
      111.     /**
      112.      * 根据 ID 删除
      113.      *
      114.      * @param id      主键(类型必须与实体类型字段保持一致)
      115.      * @param useFill 是否启用填充(为true的情况,会将入参转换实体进行delete删除)
      116.      * @return 删除结果
      117.      * @since 3.5.0
      118.      */
      119.     default boolean removeById(Serializable id, boolean useFill) {
      120.         throw new UnsupportedOperationException("不支持的方法!");
      121.     }
      122.  
      123.     /**
      124.      * 根据实体(ID)删除
      125.      *
      126.      * @param entity 实体
      127.      * @since 3.4.4
      128.      */
      129.     default boolean removeById(T entity) {
      130.         return SqlHelper.retBool(getBaseMapper().deleteById(entity));
      131.     }
      132.  
      133.     /**
      134.      * 根据 columnMap 条件，删除记录
      135.      *
      136.      * @param columnMap 表字段 map 对象
      137.      */
      138.     default boolean removeByMap(Map columnMap) {
      139.         Assert.notEmpty(columnMap, "error: columnMap must not be empty");
      140.         return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
      141.     }
      142.  
      143.     /**
      144.      * 根据 entity 条件，删除记录
      145.      *
      146.      * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      147.      */
      148.     default boolean remove(Wrapper queryWrapper) {
      149.         return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
      150.     }
      151.  
      152.     /**
      153.      * 删除（根据ID 批量删除）
      154.      *
      155.      * @param list 主键ID或实体列表
      156.      */
      157.     default boolean removeByIds(Collection list) {
      158.         if (CollectionUtils.isEmpty(list)) {
      159.             return false;
      160.         }
      161.         return SqlHelper.retBool(getBaseMapper().deleteBatchIds(list));
      162.     }
      163.  
      164.     /**
      165.      * 批量删除
      166.      *
      167.      * @param list    主键ID或实体列表
      168.      * @param useFill 是否填充(为true的情况,会将入参转换实体进行delete删除)
      169.      * @return 删除结果
      170.      * @since 3.5.0
      171.      */
      172.     @Transactional(rollbackFor = Exception.class)
      173.     default boolean removeByIds(Collection list, boolean useFill) {
      174.         if (CollectionUtils.isEmpty(list)) {
      175.             return false;
      176.         }
      177.         if (useFill) {
      178.             return removeBatchByIds(list, true);
      179.         }
      180.         return SqlHelper.retBool(getBaseMapper().deleteBatchIds(list));
      181.     }
      182.  
      183.     /**
      184.      * 批量删除(jdbc批量提交)
      185.      *
      186.      * @param list 主键ID或实体列表(主键ID类型必须与实体类型字段保持一致)
      187.      * @return 删除结果
      188.      * @since 3.5.0
      189.      */
      190.     @Transactional(rollbackFor = Exception.class)
      191.     default boolean removeBatchByIds(Collection list) {
      192.         return removeBatchByIds(list, DEFAULT_BATCH_SIZE);
      193.     }
      194.  
      195.     /**
      196.      * 批量删除(jdbc批量提交)
      197.      *
      198.      * @param list    主键ID或实体列表(主键ID类型必须与实体类型字段保持一致)
      199.      * @param useFill 是否启用填充(为true的情况,会将入参转换实体进行delete删除)
      200.      * @return 删除结果
      201.      * @since 3.5.0
      202.      */
      203.     @Transactional(rollbackFor = Exception.class)
      204.     default boolean removeBatchByIds(Collection list, boolean useFill) {
      205.         return removeBatchByIds(list, DEFAULT_BATCH_SIZE, useFill);
      206.     }
      207.  
      208.     /**
      209.      * 批量删除(jdbc批量提交)
      210.      *
      211.      * @param list      主键ID或实体列表
      212.      * @param batchSize 批次大小
      213.      * @return 删除结果
      214.      * @since 3.5.0
      215.      */
      216.     default boolean removeBatchByIds(Collection list, int batchSize) {
      217.         throw new UnsupportedOperationException("不支持的方法!");
      218.     }
      219.  
      220.     /**
      221.      * 批量删除(jdbc批量提交)
      222.      *
      223.      * @param list      主键ID或实体列表
      224.      * @param batchSize 批次大小
      225.      * @param useFill   是否启用填充(为true的情况,会将入参转换实体进行delete删除)
      226.      * @return 删除结果
      227.      * @since 3.5.0
      228.      */
      229.     default boolean removeBatchByIds(Collection list, int batchSize, boolean useFill) {
      230.         throw new UnsupportedOperationException("不支持的方法!");
      231.     }
      232.  
      233.     /**
      234.      * 根据 ID 选择修改
      235.      *
      236.      * @param entity 实体对象
      237.      */
      238.     default boolean updateById(T entity) {
      239.         return SqlHelper.retBool(getBaseMapper().updateById(entity));
      240.     }
      241.  
      242.     /**
      243.      * 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
      244.      *
      245.      * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
      246.      */
      247.     default boolean update(Wrapper updateWrapper) {
      248.         return update(null, updateWrapper);
      249.     }
      250.  
      251.     /**
      252.      * 根据 whereEntity 条件，更新记录
      253.      *
      254.      * @param entity        实体对象
      255.      * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
      256.      */
      257.     default boolean update(T entity, Wrapper updateWrapper) {
      258.         return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
      259.     }
      260.  
      261.     /**
      262.      * 根据ID 批量更新
      263.      *
      264.      * @param entityList 实体对象集合
      265.      */
      266.     @Transactional(rollbackFor = Exception.class)
      267.     default boolean updateBatchById(Collection entityList) {
      268.         return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
      269.     }
      270.  
      271.     /**
      272.      * 根据ID 批量更新
      273.      *
      274.      * @param entityList 实体对象集合
      275.      * @param batchSize  更新批次数量
      276.      */
      277.     boolean updateBatchById(Collection entityList, int batchSize);
      278.  
      279.     /**
      280.      * TableId 注解存在更新记录，否插入一条记录
      281.      *
      282.      * @param entity 实体对象
      283.      */
      284.     boolean saveOrUpdate(T entity);
      285.  
      286.     /**
      287.      * 根据 ID 查询
      288.      *
      289.      * @param id 主键ID
      290.      */
      291.     default T getById(Serializable id) {
      292.         return getBaseMapper().selectById(id);
      293.     }
      294.  
      295.     /**
      296.      * 查询（根据ID 批量查询）
      297.      *
      298.      * @param idList 主键ID列表
      299.      */
      300.     default List listByIds(Collection idList) {
      301.         return getBaseMapper().selectBatchIds(idList);
      302.     }
      303.  
      304.     /**
      305.      * 查询（根据 columnMap 条件）
      306.      *
      307.      * @param columnMap 表字段 map 对象
      308.      */
      309.     default List listByMap(Map columnMap) {
      310.         return getBaseMapper().selectByMap(columnMap);
      311.     }
      312.  
      313.     /**
      314.      * 根据 Wrapper，查询一条记录 
      315.      * 
        结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
      316.      *
      317.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      318.      */
      319.     default T getOne(Wrapper queryWrapper) {
      320.         return getOne(queryWrapper, true);
      321.     }
      322.  
      323.     /**
      324.      * 根据 Wrapper，查询一条记录
      325.      *
      326.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      327.      * @param throwEx      有多个 result 是否抛出异常
      328.      */
      329.     T getOne(Wrapper queryWrapper, boolean throwEx);
      330.  
      331.     /**
      332.      * 根据 Wrapper，查询一条记录
      333.      *
      334.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      335.      */
      336.     Map getMap(Wrapper queryWrapper);
      337.  
      338.     /**
      339.      * 根据 Wrapper，查询一条记录
      340.      *
      341.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      342.      * @param mapper       转换函数
      343.      */
      344.      V getObj(Wrapper queryWrapper, Functionsuper Object, V> mapper);
      345.  
      346.     /**
      347.      * 查询总记录数
      348.      *
      349.      * @see Wrappers#emptyWrapper()
      350.      */
      351.     default long count() {
      352.         return count(Wrappers.emptyWrapper());
      353.     }
      354.  
      355.     /**
      356.      * 根据 Wrapper 条件，查询总记录数
      357.      *
      358.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      359.      */
      360.     default long count(Wrapper queryWrapper) {
      361.         return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
      362.     }
      363.  
      364.     /**
      365.      * 查询列表
      366.      *
      367.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      368.      */
      369.     default List list(Wrapper queryWrapper) {
      370.         return getBaseMapper().selectList(queryWrapper);
      371.     }
      372.  
      373.     /**
      374.      * 查询所有
      375.      *
      376.      * @see Wrappers#emptyWrapper()
      377.      */
      378.     default List list() {
      379.         return list(Wrappers.emptyWrapper());
      380.     }
      381.  
      382.     /**
      383.      * 翻页查询
      384.      *
      385.      * @param page         翻页对象
      386.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      387.      */
      388.     default extends IPage> E page(E page, Wrapper queryWrapper) {
      389.         return getBaseMapper().selectPage(page, queryWrapper);
      390.     }
      391.  
      392.     /**
      393.      * 无条件翻页查询
      394.      *
      395.      * @param page 翻页对象
      396.      * @see Wrappers#emptyWrapper()
      397.      */
      398.     default extends IPage> E page(E page) {
      399.         return page(page, Wrappers.emptyWrapper());
      400.     }
      401.  
      402.     /**
      403.      * 查询列表
      404.      *
      405.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      406.      */
      407.     default List> listMaps(Wrapper queryWrapper) {
      408.         return getBaseMapper().selectMaps(queryWrapper);
      409.     }
      410.  
      411.     /**
      412.      * 查询所有列表
      413.      *
      414.      * @see Wrappers#emptyWrapper()
      415.      */
      416.     default List> listMaps() {
      417.         return listMaps(Wrappers.emptyWrapper());
      418.     }
      419.  
      420.     /**
      421.      * 查询全部记录
      422.      */
      423.     default List listObjs() {
      424.         return listObjs(Function.identity());
      425.     }
      426.  
      427.     /**
      428.      * 查询全部记录
      429.      *
      430.      * @param mapper 转换函数
      431.      */
      432.     default  List listObjs(Functionsuper Object, V> mapper) {
      433.         return listObjs(Wrappers.emptyWrapper(), mapper);
      434.     }
      435.  
      436.     /**
      437.      * 根据 Wrapper 条件，查询全部记录
      438.      *
      439.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      440.      */
      441.     default List listObjs(Wrapper queryWrapper) {
      442.         return listObjs(queryWrapper, Function.identity());
      443.     }
      444.  
      445.     /**
      446.      * 根据 Wrapper 条件，查询全部记录
      447.      *
      448.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      449.      * @param mapper       转换函数
      450.      */
      451.     default  List listObjs(Wrapper queryWrapper, Functionsuper Object, V> mapper) {
      452.         return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
      453.     }
      454.  
      455.     /**
      456.      * 翻页查询
      457.      *
      458.      * @param page         翻页对象
      459.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
      460.      */
      461.     default extends IPage>> E pageMaps(E page, Wrapper queryWrapper) {
      462.         return getBaseMapper().selectMapsPage(page, queryWrapper);
      463.     }
      464.  
      465.     /**
      466.      * 无条件翻页查询
      467.      *
      468.      * @param page 翻页对象
      469.      * @see Wrappers#emptyWrapper()
      470.      */
      471.     default extends IPage>> E pageMaps(E page) {
      472.         return pageMaps(page, Wrappers.emptyWrapper());
      473.     }
      474.  
      475.     /**
      476.      * 获取对应 entity 的 BaseMapper
      477.      *
      478.      * @return BaseMapper
      479.      */
      480.     BaseMapper getBaseMapper();
      481.  
      482.     /**
      483.      * 获取 entity 的 class
      484.      *
      485.      * @return {@link Class}
      486.      */
      487.     Class getEntityClass();
      488.  
      489.     /**
      490.      * 以下的方法使用介绍:
      491.      *
      492.      * 一. 名称介绍
      493.      * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
      494.      * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
      495.      * 二. 支持介绍
      496.      *
      497.      * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
      498.      * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
      499.      *
      500.      * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
      501.      * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
      502.      * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
      503.      *
      504.      */
      505.  
      506.     /**
      507.      * 链式查询 普通
      508.      *
      509.      * @return QueryWrapper 的包装类
      510.      */
      511.     default QueryChainWrapper query() {
      512.         return ChainWrappers.queryChain(getBaseMapper());
      513.     }
      514.  
      515.     /**
      516.      * 链式查询 lambda 式
      517.      * 
        注意：不支持 Kotlin 
      518.      *
      519.      * @return LambdaQueryWrapper 的包装类
      520.      */
      521.     default LambdaQueryChainWrapper lambdaQuery() {
      522.         return ChainWrappers.lambdaQueryChain(getBaseMapper());
      523.     }
      524.  
      525.     /**
      526.      * 链式查询 lambda 式
      527.      * kotlin 使用
      528.      *
      529.      * @return KtQueryWrapper 的包装类
      530.      */
      531.     default KtQueryChainWrapper ktQuery() {
      532.         return ChainWrappers.ktQueryChain(getBaseMapper(), getEntityClass());
      533.     }
      534.  
      535.     /**
      536.      * 链式查询 lambda 式
      537.      * kotlin 使用
      538.      *
      539.      * @return KtQueryWrapper 的包装类
      540.      */
      541.     default KtUpdateChainWrapper ktUpdate() {
      542.         return ChainWrappers.ktUpdateChain(getBaseMapper(), getEntityClass());
      543.     }
      544.  
      545.     /**
      546.      * 链式更改 普通
      547.      *
      548.      * @return UpdateWrapper 的包装类
      549.      */
      550.     default UpdateChainWrapper update() {
      551.         return ChainWrappers.updateChain(getBaseMapper());
      552.     }
      553.  
      554.     /**
      555.      * 链式更改 lambda 式
      556.      * 
        注意：不支持 Kotlin 
      557.      *
      558.      * @return LambdaUpdateWrapper 的包装类
      559.      */
      560.     default LambdaUpdateChainWrapper lambdaUpdate() {
      561.         return ChainWrappers.lambdaUpdateChain(getBaseMapper());
      562.     }
      563.  
      564.     /**
      565.      * 
      566.      * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
      567.      * 此次修改主要是减少了此项业务代码的代码量（存在性验证之后的saveOrUpdate操作）
      568.      * 
      569.      *
      570.      * @param entity 实体对象
      571.      */
      572.     default boolean saveOrUpdate(T entity, Wrapper updateWrapper) {
      573.         return update(entity, updateWrapper) || saveOrUpdate(entity);
      574.     }
      575. }
        576.  

        自己的接口应该定义为
         

        1. public interface UserService extends IService {
        2. }
         

        其实现类写成
         

        1. @Service
        2. public class UserServiceImpl  extends ServiceImpl implements UserService  {
        3.     // 第一个要操作的Mapper接口 第二个要操作的类型
        4. }
         

        1.测试
         

        1. @SpringBootTest
        2. public class MybatisPlusServiceTest {
        3.     @Autowired
        4.     UserService userService;
        5.     @Test
        6.     public void count(){
        7. //        总记录数版本3.3 SELECT COUNT( 1 ) FROM user
        8. //        版本3.5SELECT COUNT( * ) FROM user
        9.         long count = userService.count();
        10.         System.out.println(count);
        11.     }
        12.     @Test
        13.     public void insert(){
        14. //        mapper里面并没有批量添加 原因：sql语句长
        15. //        save是保存  saveOrUpdate既有修改又有添加
        16. //        区分：看实体类中有无id有id就是修改 没id就是添加
        17.         List list  = new ArrayList<>();
        18.         for (int i = 0; i <10 ; i++) {
        19.             User user = new User();
        20.             user.setAge(16+i);
        21.             user.setName("gg"+i);
        22.             list.add(user);
        23.         }
        24. //        INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
        25. //        为什么不是批量添加sql 它是基于BaseMapper实现的  它是基于单个循环添加
        26.         boolean b = userService.saveBatch(list);
        27.  
        28.     }
        29. }
         

        2.注意
         

        insert变为save
         

        saveOrUpdate 既有修改又有添加
         

        区分：看实体类中有无id有id就是修改 没id就是添加
         

         

        四.常用注解
         

        1.@TableName("user")
         

        实体类所对应的数据库表名 "user"
         

        1. /*
        2.  * Copyright (c) 2011-2022, baomidou (jobob@qq.com).
        3.  *
        4.  * Licensed under the Apache License, Version 2.0 (the "License");
        5.  * you may not use this file except in compliance with the License.
        6.  * You may obtain a copy of the License at
        7.  *
        8.  *     http://www.apache.org/licenses/LICENSE-2.0
        9.  *
        10.  * Unless required by applicable law or agreed to in writing, software
        11.  * distributed under the License is distributed on an "AS IS" BASIS,
        12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        13.  * See the License for the specific language governing permissions and
        14.  * limitations under the License.
        15.  */
        16. package com.baomidou.mybatisplus.annotation;
        17.  
        18. import java.lang.annotation.*;
        19.  
        20. /**
        21.  * 数据库表相关
        22.  *
        23.  * @author hubin, hanchunlin
        24.  * @since 2016-01-23
        25.  */
        26. @Documented
        27. @Retention(RetentionPolicy.RUNTIME)
        28. @Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
        29. public @interface TableName {
        30.  
        31.     /**
        32.      * 实体对应的表名
        33.      */
        34.     String value() default "";
        35.  
        36.     /**
        37.      * schema
        38.      * 
        39.      * 配置此值将覆盖全局配置的 schema
        40.      *
        41.      * @since 3.1.1
        42.      */
        43.     String schema() default "";
        44.  
        45.     /**
        46.      * 是否保持使用全局的 tablePrefix 的值
        47.      * 
           只生效于 既设置了全局的 tablePrefix 也设置了上面 {@link #value()} 的值 
        48.      * 
        49.  如果是 false , 全局的 tablePrefix 不生效 
        50.      *
        51.      * @since 3.1.1
        52.      */
        53.     boolean keepGlobalPrefix() default false;
        54.  
        55.     /**
        56.      * 实体映射结果集,
        57.      * 只生效于 mp 自动注入的 method
        58.      */
        59.     String resultMap() default "";
        60.  
        61.     /**
        62.      * 是否自动构建 resultMap 并使用,
        63.      * 只生效于 mp 自动注入的 method,
        64.      * 如果设置 resultMap 则不会进行 resultMap 的自动构建并注入,
        65.      * 只适合个别字段 设置了 typeHandler 或 jdbcType 的情况
        66.      *
        67.      * @since 3.1.2
        68.      */
        69.     boolean autoResultMap() default false;
        70.  
        71.     /**
        72.      * 需要排除的属性名
        73.      *
        74.      * @since 3.3.1
        75.      */
        76.     String[] excludeProperty() default {};
        77. }
         

        注：如果每个表有前缀可以在配置文件中 统一配置
         

        #设置实体类所对应表的同一前缀
#mybatis-plus.global-config.db-config.table-prefix=t_

         

        2.@TableId
         

        将属性所对应的字段指定为主键 value=数据库中的字段
         

        不指定type默认id生成是雪花算法 并不是递增
         

        如果自己主动设置id 主动设置的优先
         

        1. public @interface TableId {
        2.  
        3.     /**
        4.      * 字段名（该值可无）
        5.      */
        6.     String value() default "";
        7.  
        8.     /**
        9.      * 主键类型
        10.      * {@link IdType}
        11.      */
        12.     IdType type() default IdType.NONE;
        13. }
         

        类型可以为
         

        1. import lombok.Getter;
        2.  
        3. /**
        4.  * 生成ID类型枚举类
        5.  *
        6.  * @author hubin
        7.  * @since 2015-11-10
        8.  */
        9. @Getter
        10. public enum IdType {
        11.     /**
        12.      * 数据库ID自增
        13.      * 
          该类型请确保数据库设置了 ID自增 否则无效
        14.      */
        15.     AUTO(0),
        16.     /**
        17.      * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
        18.      */
        19.     NONE(1),
        20.     /**
        21.      * 用户输入ID
        22.      * 
          该类型可以通过自己注册自动填充插件进行填充
        23.      */
        24.     INPUT(2),
        25.  
        26.     /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
        27.     /**
        28.      * 分配ID (主键类型为number或string）,
        29.      * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
        30.      *
        31.      * @since 3.3.0
        32.      */
        33.     ASSIGN_ID(3),
        34.     /**
        35.      * 分配UUID (主键类型为 string)
        36.      * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
        37.      */
        38.     ASSIGN_UUID(4);
        39.  
        40.     private final int key;
        41.  
        42.     IdType(int key) {
        43.         this.key = key;
        44.     }
        45. }
         

        雪花算法（粗略）
         

        不可能只有一张表 储存的数量太多 因此进行表的拆分   
核心优点 保证拆分时不同表的主键的不重复性 主键有序性（后添加的id>之前添加的ID）
         

        也可以在全局配置中统一配置
         

        1. #统一设置主键生成策略
        2. mybatis-plus.global-config.db-config.id-type=auto
         

        3.@TableField
         

        注：mybatisplus自动配置了驼峰        
         

        普通字段对应的数据中的列名
         

        1. public @interface TableField {
        2.  
        3.     /**
        4.      * 数据库字段值
        5.      * 
        6.      * 不需要配置该值的情况:
        7.      * 
        8.  当 {@link com.baomidou.mybatisplus.core.MybatisConfiguration#mapUnderscoreToCamelCase} 为 true 时,
        9.      * (mp下默认是true,mybatis默认是false), 数据库字段值.replace("_","").toUpperCase() == 实体属性名.toUpperCase() 
        10.      * 
        11.  当 {@link com.baomidou.mybatisplus.core.MybatisConfiguration#mapUnderscoreToCamelCase} 为 false 时,
        12.      * 数据库字段值.toUpperCase() == 实体属性名.toUpperCase() 
        13.      */
        14.     String value() default "";
        15.  
        16.     /**
        17.      * 是否为数据库表字段
        18.      * 
        19.      * 默认 true 存在，false 不存在
        20.      */
        21.     boolean exist() default true;
        22.  
        23.     /**
        24.      * 字段 where 实体查询比较条件
        25.      * 
        26.      * 默认 {@link SqlCondition#EQUAL}
        27.      */
        28.     String condition() default "";
        29.  
        30.     /**
        31.      * 字段 update set 部分注入, 该注解优于 el 注解使用
        32.      * 
        33.      * 例1：@TableField(.. , update="%s+1") 其中 %s 会填充为字段
        34.      * 输出 SQL 为：update 表 set 字段=字段+1 where ...
        35.      * 
        36.      * 例2：@TableField(.. , update="now()") 使用数据库时间
        37.      * 输出 SQL 为：update 表 set 字段=now() where ...
        38.      */
        39.     String update() default "";
        40.  
        41.     /**
        42.      * 字段验证策略之 insert: 当insert操作时，该字段拼接insert语句时的策略
        43.      * 
        44.      * IGNORED: 直接拼接 insert into table_a(column) values (#{columnProperty});
        45.      * NOT_NULL: insert into table_a(column) values (#{columnProperty})
        46.      * NOT_EMPTY: insert into table_a(column) values (#{columnProperty})
        47.      * NOT_EMPTY 如果针对的是非 CharSequence 类型的字段则效果等于 NOT_NULL
        48.      *
        49.      * @since 3.1.2
        50.      */
        51.     FieldStrategy insertStrategy() default FieldStrategy.DEFAULT;
        52.  
        53.     /**
        54.      * 字段验证策略之 update: 当更新操作时，该字段拼接set语句时的策略
        55.      * 
        56.      * IGNORED: 直接拼接 update table_a set column=#{columnProperty}, 属性为null/空string都会被set进去
        57.      * NOT_NULL: update table_a set column=#{columnProperty}
        58.      * NOT_EMPTY: update table_a set column=#{columnProperty}
        59.      * NOT_EMPTY 如果针对的是非 CharSequence 类型的字段则效果等于 NOT_NULL
        60.      *
        61.      * @since 3.1.2
        62.      */
        63.     FieldStrategy updateStrategy() default FieldStrategy.DEFAULT;
        64.  
        65.     /**
        66.      * 字段验证策略之 where: 表示该字段在拼接where条件时的策略
        67.      * 
        68.      * IGNORED: 直接拼接 column=#{columnProperty}
        69.      * NOT_NULL: column=#{columnProperty}
        70.      * NOT_EMPTY: column=#{columnProperty}
        71.      * NOT_EMPTY 如果针对的是非 CharSequence 类型的字段则效果等于 NOT_NULL
        72.      *
        73.      * @since 3.1.2
        74.      */
        75.     FieldStrategy whereStrategy() default FieldStrategy.DEFAULT;
        76.  
        77.     /**
        78.      * 字段自动填充策略
        79.      * 
        80.      * 在对应模式下将会忽略 insertStrategy 或 updateStrategy 的配置,等于断言该字段必有值
        81.      */
        82.     FieldFill fill() default FieldFill.DEFAULT;
        83.  
        84.     /**
        85.      * 是否进行 select 查询
        86.      * 
        87.      * 大字段可设置为 false 不加入 select 查询范围
        88.      */
        89.     boolean select() default true;
        90.  
        91.     /**
        92.      * 是否保持使用全局的 columnFormat 的值
        93.      * 
        94.      * 只生效于 既设置了全局的 columnFormat 也设置了上面 {@link #value()} 的值
        95.      * 如果是 false , 全局的 columnFormat 不生效
        96.      *
        97.      * @since 3.1.1
        98.      */
        99.     boolean keepGlobalFormat() default false;
        100.  
        101.     /**
        102.      * {@link ResultMapping#property} and {@link ParameterMapping#property}
        103.      *
        104.      * @since 3.4.4
        105.      */
        106.     String property() default "";
        107.  
        108.     /**
        109.      * JDBC类型 (该默认值不代表会按照该值生效),
        110.      * 只生效于 mp 自动注入的 method,
        111.      * 建议配合 {@link TableName#autoResultMap()} 一起使用
        112.      * 
        113.      * {@link ResultMapping#jdbcType} and {@link ParameterMapping#jdbcType}
        114.      *
        115.      * @since 3.1.2
        116.      */
        117.     JdbcType jdbcType() default JdbcType.UNDEFINED;
        118.  
        119.     /**
        120.      * 类型处理器 (该默认值不代表会按照该值生效),
        121.      * 只生效于 mp 自动注入的 method,
        122.      * 建议配合 {@link TableName#autoResultMap()} 一起使用
        123.      * 
        124.      * {@link ResultMapping#typeHandler} and {@link ParameterMapping#typeHandler}
        125.      *
        126.      * @since 3.1.2
        127.      */
        128.     Classextends TypeHandler> typeHandler() default UnknownTypeHandler.class;
        129.  
        130.     /**
        131.      * 只在使用了 {@link #typeHandler()} 时判断是否辅助追加 javaType
        132.      * 
        133.      * 一般情况下不推荐使用
        134.      * {@link ParameterMapping#javaType}
        135.      *
        136.      * @since 3.4.0 @2020-07-23
        137.      */
        138.     boolean javaType() default false;
        139.  
        140.     /**
        141.      * 指定小数点后保留的位数,
        142.      * 只生效于 mp 自动注入的 method,
        143.      * 建议配合 {@link TableName#autoResultMap()} 一起使用
        144.      * 
        145.      * {@link ParameterMapping#numericScale}
        146.      *
        147.      * @since 3.1.2
        148.      */
        149.     String numericScale() default "";
        150. }
         

         

        4. @TableLogic
         

        1. public @interface TableLogic {
        2.  
        3.     /**
        4.      * 默认逻辑未删除值（该值可无、会自动获取全局配置）
        5.      */
        6.     String value() default "";
        7.  
        8.     /**
        9.      * 默认逻辑删除值（该值可无、会自动获取全局配置）
        10.      */
        11.     String delval() default "";
        12. }
         

        逻辑删除的字段 数据库中也要添加    删除变为修改，只不过你查不出来 因为默认查询时会有where id_del=0
         

        五.条件构造器和常用接口
         

        1.wrapper(包装)介绍
         

         

         
         

         Wrapper ： 条件构造抽象类，最顶端父类
         

        AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
         

        QueryWrapper ： 查询条件封装
         

        UpdateWrapper ： Update 条件封装
         

        AbstractLambdaWrapper ： 使用Lambda 语法
         

        LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
         

        LambdaUpdateWrapper ： Lambda 更新封装Wrappe
         

         2.QueryWrapper和UpdateWrapper
         

        1.特点
         

        1.对象封装操作类
         

        2.用于组装查询条件
         

        3.调每一个方法返回值都是用的QueryWrapper(链式结构)
         

        4.删除和查询都是用QueryWrapper
         

        5. 默认条件之间拼接and
         

        6.lambda条件表达式优先执行
         

        2.测试
         

        1.     @Autowired
        2.     UserMapper userMapper;
        3.  
        4.     @Test
        5.     public void t1(){
        6.  
        7.         QueryWrapper wrapper = new QueryWrapper<>();
        8. //        ge>= le<=
        9. //        第一个是字段名    调每一个方法返回值都是用的QueryWrapper
        10. //        所以是链式结构
        11.         //        用户名包含a，年龄在20-30之间，邮箱不为空
        12.         QueryWrapper w = wrapper.like("name", "a")
        13.                 .between("age", 20, 30)
        14.                 .isNotNull("email");
        15. //SELECT id,name,age,email FROM user 
        16. //WHERE (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
        17. //        %a%(String), 20(Integer), 30(Integer)
        18.          userMapper.selectList(w);
        19.  
        20.     }
        21.     @Test
        22.     public void t2(){
        23.  
        24.         QueryWrapper wrapper = new QueryWrapper<>();
        25. //        查询用户信息 按照年龄降序排， 年龄相同id升序
        26. //        SELECT id,name,age,email FROM user ORDER BY age DESC,id ASC
        27.         wrapper.orderByDesc("age")
        28.                 .orderByAsc("id");
        29.         userMapper.selectList(wrapper);
        30.     }
        31. //    删除和查询都是用QueryWrapper
        32.     @Test
        33.     public void del(){
        34.         QueryWrapper wrapper = new QueryWrapper<>();
        35. //        DELETE FROM user WHERE (age IS NULL AND email IS NULL)
        36.         QueryWrapper w = wrapper.isNull("age").isNull("email");
        37.         userMapper.delete(w);
        38.     }
         

        3.修改 和条件的优先级
         

        1.   @Test
        2.     public void update(){
        3. //        2个参数 第一个为修改为的实体类 第二个是修改条件
        4.         QueryWrapper wrapper = new QueryWrapper<>();
        5. //         UPDATE user SET name=?, age=?, email=? WHERE (name LIKE ? OR age BETWEEN ? AND ?)
        6.         User user = new User("mm",21,"789.com");
        7.       wrapper.like("name", "a").or().between("age", 20, 30);
        8.         userMapper.update(user,wrapper);
        9.         //        1个参数  即第一个设置为null 第二个即是条件也是要修改的内容
        10. //        UPDATE user SET name=? WHERE (name LIKE ?)
        11.         UpdateWrapper wrapper1 = new UpdateWrapper<>();
        12.         wrapper1.set("name","hh").like("name","a");
        13.         userMapper.update(null,wrapper1);
        14.  
        15.  
        16.     }
        17.     @Test
        18.     public void grade(){
        19.         //        默认条件之间拼接and
        20. //        用户名包含a 且（年龄大于20或邮箱为null）
        21. //        lambda条件表达式优先执行
        22.         UpdateWrapper wrapper = new UpdateWrapper<>();
        23. //        UPDATE user SET name=?, age=?, email=? 
        24. //        WHERE (name LIKE ? AND (age > ? OR email IS NULL))
        25. //
        26.         wrapper.like("name","a")
        27.                 .and(i->i.gt("age",20).or().isNull("email"));
        28.         userMapper.update(new User("mm",23,"147.com"),wrapper);
        29.  
        30.     }
         

        4.查询部分字段
         

        1.     @Test
        2.     public void partColumn(){
        3. //        查询部分字段
        4.         QueryWrapper wrapper = new QueryWrapper<>();
        5. //        SELECT name,age FROM user
        6.         wrapper.select("name","age");
        7.         userMapper.selectList(wrapper);
        8.     }
         

        5. 子查询
         

        1.     @Test
        2.     public void sonSelect(){
        3. //        子查询    id <=100
        4.         QueryWrapper wrapper = new QueryWrapper<>();
        5. //        第一个参数 字段名 第二个 参数 条件
        6. //        SELECT id,name,age,email FROM user 
        7. //        WHERE (age IN (select id from user where id<=100))
        8.         wrapper.inSql("age","select id from user where id<=100");
        9.         userMapper.selectList(wrapper);
        10.  
        11.     }
         

        6.动态sql（复杂版）
         

        1.     @Test
        2.     public void judge(){
        3. //        动态sql
        4.  
        5.         String name="";
        6.         Integer ageBegin = 20;
        7.         Integer ageEnd = 40;
        8.         QueryWrapper wrapper = new QueryWrapper<>();
        9. //        SELECT id,name,age,email FROM user WHERE (age >= ? AND age <= ?)
        10.         if (StringUtils.isNotBlank(name)){
        11. //            isNotBlank 判断是否不为空 不为null 不为空白符
        12.             wrapper.like("name",name);
        13.         }
        14.         if (ageBegin !=null){
        15.             wrapper.ge("age",20);
        16.         }
        17.         if (ageEnd !=null){
        18.             wrapper.le("age",ageEnd);
        19.         }
        20.         userMapper.selectList(wrapper);
        21.     }
         

        7.动态sql简化版
         

        通过条件判断的condition
         

        1.     @Test
        2.     public void simple(){
        3. //        通过条件判断的condition condition 为true执行 反之不执行该条件
        4.         String name="";
        5.         Integer ageBegin = null;
        6.         Integer ageEnd = 40;
        7.         QueryWrapper wrapper = new QueryWrapper<>();
        8. //         SELECT id,name,age,email FROM user WHERE (age <= ?)
        9. //        StringUtils 封装了很多关于String的判断方法
        10.         wrapper.like(StringUtils.isNotBlank(name),"name",name)
        11.                 .ge(ageBegin != null,"age",ageBegin)
        12.                 .le(ageEnd != null,"age",ageEnd);
        13.         userMapper.selectList(wrapper);
        14.     }
         

        8.lambda用法
         

        1.     @Test
        2.     public void lambda(){
        3.         String name="";
        4.         Integer ageBegin = 20;
        5.         Integer ageEnd = 40;
        6.         LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
        7. //        好处 本来是数据库中的字段 现在通过lambda表达式变为实体类中的属性 防止字段写错
        8.         lambdaQueryWrapper.like(StringUtils.isNotBlank(name),User::getName,name)
        9.                 .ge(ageBegin != null,User::getAge,ageBegin)
        10.                 .le(ageEnd != null,User::getAge,ageEnd);
        11.     }
         

        六.插件
         

        1.分页插件
         

        MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能
         

        注：实现原理就是先查询所有数据然后拦截第一页的数据进行显示
         

        1.配置
         

        1. @Configuration
        2. public class MybatisPlusConfig {
        3. //    配置分页插件
        4.     @Bean
        5.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
        6.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        7. //        数据库之间的分页不相同 DbType.MYSQL
        8.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        9.  
        10.         return interceptor;
        11.     }
        12. }
         

        2.使用
         

        1.     @Autowired
        2.     private UserMapper userMapper;
        3.     @Autowired
        4.     private ProductMapper productMapper;
        5.     @Test
        6.     public void t1(){
        7.         Page page = new Page<>(1,3);
        8. //        SELECT id,name,age,email FROM user LIMIT ?
        9. //        只有一个参数，因为是第一页
        10.         userMapper.selectPage(page,null);
        11.         System.out.println(page);
        12.     }
         

        3.根据自定义条件进行分页
         

        虽然Sql语句不需要Page，但是如果想用MybatisPlus提供的分页
​​​​​​​1.参数中就必须有Page page, 且放在第一个参数
2.返回值必须是page

         

        1.在Mapper接口里
         

        1. @Mapper
        2. public interface UserMapper  extends BaseMapper {
        3.  
        4. //    自定义分页插件 通过年龄查出用户信息并分页
        5. //    虽然Sql语句不需要Page，但是如果想用MybatisPlus提供的分页
        6. //    1.参数中就必须有Page page, 且放在第一个参数
        7. //    2.返回值必须是page
        8.     Page mySelectPage(@Param("page") Page page, 
        9.                     @Param("age") Integer age);
        10. }
         

        2.在xml文件中直接sql的筛选条件
         

        1. mapper
        2.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        4. <mapper namespace="top.remained.mapper.UserMapper">
        5.  
        6.         <select id="mySelectPage" resultType="User">
        7.             select  id,name,age,email from user where age > #{age}
        8.         select>
        9.  
        10. mapper>
         

        3.使用
         

        1.     @Test
        2.     public void t2(){
        3. //      SELECT COUNT(*) AS total FROM user WHERE age > ?
        4. //      select id,name,age,email from user where age > ? LIMIT ?,?
        5.         Page page = new Page(2,3);
        6.         userMapper.mySelectPage(page,18);
        7.  
        8.     }
         

        2.乐观锁插件
         

        乐观锁：
         

        每次修改之后会核对一下之前的版本号，如果相同修改之后保存，反之进行回滚。
         

        1.不用锁
         

        1.    @Test
        2.     public void te1(){
        3. //       不用锁 出现问题
        4. //        查询价格
        5.         Product product = productMapper.selectById(1);
        6.         System.out.println(product.getPrice() + "：小李查询");
        7. //        100：小李查询
        8.         Product product1 = productMapper.selectById(1);
        9. //        100：小王查询
        10.         System.out.println(product1.getPrice() + "：小王查询");
        11. //        小李增加50
        12.         product.setPrice(product.getPrice()+50);
        13. //        150
        14.         productMapper.updateById(product);
        15. //        小王-30
        16.         product1.setPrice(product1.getPrice() -30);
        17. //        70
        18.         productMapper.updateById(product1);
        19. //        查询改变后的
        20.         System.out.println(productMapper.selectById(1).getPrice()+":最后的");
        21. //                70
        22.  
        23.     }
         

        2.配置乐观锁
         

        1.标识乐观锁字段号
         

         

        2. 配置乐观锁插件
         

        1. @Configuration
        2. public class MybatisPlusConfig {
        3. //    配置分页插件
        4.     @Bean
        5.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
        6.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        7. //        数据库之间的分页不相同
        8.         interceptor.addInnerInterceptor
        9. (new PaginationInnerInterceptor(DbType.MYSQL));
        10. //        添加乐观锁机制
        11.         interceptor.addInnerInterceptor
        12. (new OptimisticLockerInnerInterceptor());
        13.         return interceptor;
        14.     }
        15. }
         

        3.用了乐观锁
         

        1. @Test
        2.     public void te2(){
        3.         Product product = productMapper.selectById(1);
        4.         System.out.println(product.getPrice() + "：小李查询");
        5. //        100：小李查询
        6.         Product product1 = productMapper.selectById(1);
        7. //        100：小王查询
        8.         System.out.println(product1.getPrice() + "：小王查询");
        9. //        小李增加50
        10.         product.setPrice(product.getPrice()+50);
        11. //        150
        12.         productMapper.updateById(product);
        13. //        UPDATE t_product SET name=?, price=?, 
        14. //        version=? WHERE id=? AND version=?
        15. //        小王-30
        16.         product1.setPrice(product1.getPrice() -30);
        17. //        70
        18.         productMapper.updateById(product1);
        19. //        查询改变后的
        20.         System.out.println(productMapper.selectById(1)
        21.             .getPrice()+":最后的");
        22. //                150
        23. //  最后version为1
        24.     }
         

        4.优化
         

        小王之所以不成功 版本号不一致
         

        解决：如果获取更行后的返回值=0 重新查询 重新更改
         

        1.     @Test
        2.     public void te3(){
        3.         Product product = productMapper.selectById(1);
        4.         Product product1 = productMapper.selectById(1);
        5.         product.setPrice(product.getPrice()+50);
        6.         productMapper.updateById(product);
        7.         product1.setPrice(product1.getPrice() -30);
        8.         int i = productMapper.updateById(product1);
        9.         if (i == 0) {
        10.             product1 = productMapper.selectById(1);
        11.             product1.setPrice(product1.getPrice() -30);
        12.             productMapper.updateById(product1);
        13.  
        14.         }
        15.         System.out.println(productMapper.selectById(1).
        16.         getPrice()+":最后的");
        17. //        120 版本号改变2次
        18.     }
         

        七.MybatisX插件
         

        1.MyBatisX插件用法：
         

        https://baomidou.com/pages/ba5b24/
         

         

        2.第一个用法生成mapper和service以及实体类模板
         

        环境配置
         

        idea连接上数据库
         

         

        1.选中生成的表 
         

         

        2.生成实体类的配置
         

         

        3.生成service和mapper的配置
         

         

         
         

        4.
         

         3.第二个用法快捷生成sql
         

         

         

         
         

         参考
         

        https://baomidou.com/pages/ba5b24/
         

         
        
                
                    
                

                
      576. 

                    相关阅读:
        
                    
233062C++&QTday5                            
        
基于C++的中国行政区域图染色与信息查询 课程论文+任务书+代码                            
        
树状数组的扩展应用                            
        
java云端小区物业智能管理系统计算机毕业设计MyBatis+系统+LW文档+源码+调试部署                            
        
（附源码）计算机毕业设计SSM基于的冠状病毒疫情防控资讯交流推荐网站                            
        
多物种组织载玻片——ProSci 胰腺组织解决方案                            
        
05-jenkins与SonarQube代码审查集成                            
        
pytest学习-pytorch单元测试                            
        
Linux Learnning                            
        
MQ学习之史上最全RabbitMQ（强烈建议收藏）                            
        
                            
                
        577. 
                
      577. 
                    原文地址：https://blog.csdn.net/qq_46058550/article/details/126637764
                
        578.