MyBatis-Plus 一、(基础应用)

        MyBatis-Plus（简称 MP）是一个 MyBatis (opens new window)的加强工具，在 MyBatis 的基础上只做加强不做改变，为简化开发、提高效率而生。
        mybatis 、mybatis-plus 二者区别：
        MyBatis:
   

• 全部SQL语句全部自己写
  
• 手动剖析实体关系映射转换为MyBatis内部对象注入容器
  
• 不支持Lambda情势调用
  

          Mybatis Plus:
   

• 强盛的条件构造器,满足各类使用需求
  
• 内置的Mapper,通用的Service,少量配置即可实现单表大部分CRUD操纵
  
• 支持Lambda情势调用
  
• 提供了基本的CRUD功能,连SQL语句都不需要编写
  
• 自动剖析实体关系映射转换为MyBatis内部对象注入容器
  

          

一、什么是MybatisPlus 

MybatisPlus可以节流大量时间，全部的CRUD代码都可以自动化完成
MyBatis-Plus是一个MyBatis的加强工具，在 MyBatis 的基础上只做加强不做改变，为简化开发、提高效率而生。
特性：

• 无侵入：只做加强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  
• 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操纵
  
• 强盛的 CRUD 操纵：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操纵，更有强盛的条件构造器，满足各类使用需求
  
• 支持 Lambda 情势调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  
• 支持主键自动天生：支持多达 4 种主键策略（内含分布式唯一 ID 天生器 - Sequence），可自由配置，完美解决主键题目
  
• 支持 ActiveRecord 模式：支持 ActiveRecord 情势调用，实体类只需继承 Model 类即可举行强盛的 CRUD 操纵
  
• 支持自定义全局通用操纵：支持全局通用方法注入（ Write once, use anywhere ）
  
• 内置代码天生器：采用代码大概 Maven 插件可快速天生 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
  
• 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操纵，配置好插件之后，写分页等同于普通 List 查询
  
• 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  
• 内置性能分析插件：可输出 SQL 语句以及其执行时间，发起开发测试时启用该功能，能快速揪出慢查询
  
• 内置全局拦截插件：提供全表 delete 、 update 操纵智能分析阻断，也可自定义拦截规则，预防误操纵
  

二、快速入门

        1、准备数据库：

1. DROP TABLE IF EXISTS `user`;
2. CREATE TABLE `user`  (
3.   `id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键id',
4.   `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '姓名',
5.   `job` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '工作',
6.   `salary` double NULL DEFAULT NULL COMMENT '工资',
7.   `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
8.   `update_time` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
9.   `deleted` bigint(0) NULL DEFAULT 0 COMMENT '是否删除',
10.   PRIMARY KEY (`id`) USING BTREE
11. ) ENGINE = InnoDB AUTO_INCREMENT = 191 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
13. -- ----------------------------
14. -- Records of user
15. -- ----------------------------
16. INSERT INTO `user` VALUES (1, '张三', '随便', 2000, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
17. INSERT INTO `user` VALUES (2, '李四', '程序员', 2800, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
18. INSERT INTO `user` VALUES (3, '王五', '程序员鼓励师', 2700, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
19. INSERT INTO `user` VALUES (4, '王二', '部门总监', 4200, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
20. INSERT INTO `user` VALUES (5, '麻子', '程序员', 3000, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
21. INSERT INTO `user` VALUES (6, '最帅三太子', '程序员', 3500, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
22. INSERT INTO `user` VALUES (7, '苍老师', '程序员', 3700, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
23. INSERT INTO `user` VALUES (8, '波多野结衣', 'CEO', 5000, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);
24. INSERT INTO `user` VALUES (9, '测试3', '测试工作3', 500, '2024-08-19 17:15:34', '2024-08-19 17:15:34', 0);

复制代码

        2、创建项目 略
        3、引入依赖：

1.     <dependencies>
2.         <dependency>
3.             <groupId>org.springframework.boot</groupId>
4.             <artifactId>spring-boot-starter-web</artifactId>
5.             <version>2.6.14</version>
6.         </dependency>
8.         <dependency>
9.             <groupId>org.projectlombok</groupId><!---->
10.             <artifactId>lombok</artifactId>
11.             <optional>true</optional>
12.             <version>1.18.22</version>
13.         </dependency>
14.         <!-- mysql驱动 -->
15.         <dependency>
16.             <groupId>mysql</groupId>
17.             <artifactId>mysql-connector-java</artifactId>
18.             <version>8.0.21</version>
19.         </dependency>
21.         <!-- mybatis plus-->
22.         <dependency>
23.             <groupId>com.baomidou</groupId>
24.             <artifactId>mybatis-plus-boot-starter</artifactId>
25.             <version>3.5.1</version>
26.         </dependency>
28.     </dependencies>

复制代码

         4、添加配置：

1. spring:
2.   datasource:
3.     url: jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
4.     driver-class-name: com.mysql.cj.jdbc.Driver
5.     username: root
6.     password: 123456
7.     transaction-isolation: 2 #具体定义可在Transactional->Isolation属性查看
8.     #hikari数据库连接池
9.     hikari:
10.       pool-name: Retail_HikariCP
11.       minimum-idle: 1 #最小空闲连接数量
12.       idle-timeout: 180000 #空闲连接存活最大时间，默认600000（10分钟）
13.       maximum-pool-size: 10 #连接池最大连接数，默认是10
14.       auto-commit: true  #此属性控制从池返回的连接的默认自动提交行为,默认值：true
15.       max-lifetime: 1800000 #此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
16.       connection-timeout: 30000 #数据库连接超时时间,默认30秒，即30000

复制代码

     在spring boot启动类中添加@MapperScan注解，扫描Dao文件夹：   

1. @SpringBootApplication
2. @MapperScan("com.test.demo.dao")
3. public class TESTApplication {
4.    
5.     public static void main(String[] args) {
6.         SpringApplication.run(TESTApplication.class,args);
7.     }
9. }

复制代码

        5、编码：

1. @Getter
2. @Setter
3. @ToString(callSuper = true)
4. @Accessors(chain = true)
5. @TableName("user")
6. public class User {
8.     private static final long serialVersionUID = 1L;
11.     @TableId(value = "id", type = IdType.ASSIGN_ID)
12.     private Integer id;
14.     private String name;
16.     private String type;
18.     private String job;
20.     private Double salary;
21.    
22.     private LocalDateTime createTime;
23.    
24.     private LocalDateTime updateTime;
25.    
26.     private Long deleted;
27.    
28.    
29. }

复制代码

        编写Mapper包下的Dao接口 

2. //再对应的mapper上面实现基本的接口 BaseMapper
3. @Mapper
4. public interface UserDao extends BaseMapper<User> {
6.     //所有的CRUD都已经完成
7.     //不需要像以前一样配置一大堆文件：pojo-dao（连接mybatis，配置mapper.xml文件）==>service-controller
9. }

复制代码

  注意：
  要在主启动类上去扫描mapper包下的全部接口：@MapperScan("com.test.demo.dao")
          6、简朴使用 

1. @RestController
2. @RequestMapping("/user")
3. public class UserController {
4.    
5.     @Autowired
6.     private UserDao userDao;
8.     @GetMapping("/get/{id}")
9.     public User findAll(@PathVariable("id") int id ){
10.         return userDao.selectById(id);
11.     }
13. }

复制代码

        

三、增删改查

        上面说我们dao接口继承了BaseMapper之后，基本的crud方法就可以直接使用了，就像举例中的 userDao.selectById(id) 方法一样，我们在 userDao 中并没有写 selectById() 方法，但是继承了BaseMapper之后就可以直接用了。这是由于BaseMapper已经帮我们写好了基本的crud方法，可以简朴看一下源码：

1. public interface BaseMapper<T> extends Mapper<T> {
2.     int insert(T entity);
4.     int deleteById(Serializable id);
6.     int deleteById(T entity);
8.     int deleteByMap(@Param("cm") Map<String, Object> columnMap);
10.     int delete(@Param("ew") Wrapper<T> queryWrapper);
12.     int deleteBatchIds(@Param("coll") Collection<?> idList);
14.     int updateById(@Param("et") T entity);
16.     int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);
18.     T selectById(Serializable id);
20.     List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
22.     List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
24.     default T selectOne(@Param("ew") Wrapper<T> queryWrapper) {
25.         List<T> ts = this.selectList(queryWrapper);
26.         if (CollectionUtils.isNotEmpty(ts)) {
27.             if (ts.size() != 1) {
28.                 throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records", new Object[0]);
29.             } else {
30.                 return ts.get(0);
31.             }
32.         } else {
33.             return null;
34.         }
35.     }
37.     default boolean exists(Wrapper<T> queryWrapper) {
38.         Long count = this.selectCount(queryWrapper);
39.         return null != count && count > 0L;
40.     }
42.     Long selectCount(@Param("ew") Wrapper<T> queryWrapper);
44.     List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
46.     List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
48.     List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);
50.     <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);
52.     <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param("ew") Wrapper<T> queryWrapper);
53. }

复制代码

        上面的全部方法其实都比较轻易明白，insert、delect、update、select开头的方法分别对应着增删改查，page方法代表着分页查询。
        上面的方法涵盖了单表查询的基本方法，以是如果不是复杂sql的，我们直接直接使用现成的方法举行查询。下面对各个方法做一个简朴演示。
         以下面几个简朴的增删改查方法为例：

1.     int insert(T entity);
3.     int deleteById(Serializable id);
5.     int updateById(@Param("et") T entity);
7.     T selectById(Serializable id);

复制代码

        这几个方法是最基本的增删改查的方法:
        1、insert 

1.         User user = new User();
2.         user.setName("测试1");
3.         user.setJob("测试工作");
4.         userDao.insert(user);

复制代码

        说到增加，就得提一下主键的天生策略，在mybatis中主键的天生策略需要共同标签大概注解中的属性来设置。在mybatisplus中主键的天生策略可以通过 @TableId() 注解来设置。这个注解是直接加载主键字段上面的。例如User类中：

1.     @TableId(value = "id", type = IdType.ASSIGN_ID)
2.     private Long id;

复制代码

        上面这个设置代表的是，id字段对应数据库字段为id,且为主键。 type = IdType.ASSIGN_ID 代表 基于雪花算法的策略天生数据id。我们执行两次保存操纵后，会发现数据自动填充了id:
        

         type 也可以设置为 IdType.AUTO ，代表：使用数据库的自增策略，注意：该类型需确保数据库设置了自增id，否则无效。
        加上这个注解之后，不需要再加任何配置，就可以天生主键id，这对于我们操纵来说变得非常方便。至于此中的原理会放在反面说。
        另有一个注解顺便提一下：@TableId ，这个注解主要是解决属性所对应字段不一致的情况，好比说当user实体类中的name 属性命名的是 userName ,但是数据库中命名的是 name 如许不一致，查询就无法映射到对应字段，可以加上这个注解代表这两个字段是同一个：

1.     @TableField("name")
2.     private String userName;

复制代码

         2、delect

        根据主键id 删除对应数据。

1. userDao.deleteById(1825476600460238849L);

复制代码

         3、update

        根据主键id修改某条数据。

1.         User user = new User();
2.         user.setUserName("测试2");
3.         user.setJob("测试工作2");
4.         user.setId(1825476862067429378L);
5.         userDao.updateById(user);

复制代码

        4、select

        根据主键id查询某条数据。

1.         User user = userDao.selectById(id);

复制代码

        以上就是最简朴的增删改查的用法，对于单表查询其实非常的方便。也就是这个其实帮我们提前写好了很多简朴的sql操纵，也是常用的sql操纵。而且不光是 dao层 ，在service层也封装了很多操纵，让我们在service层也可以非常方便举行处置惩罚。

        四、service 层增删改查

        如果想要在service层实现增删改查，就需要我们service继承 ServiceImpl 接口，其实也就是继承 Iservice 接口，Iservice 接口中含有方法如下：

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

复制代码

        Iservice 中方法非常多，也就说如果我们的servcie 层接口实现了 Iservice，那这些方法便是都已经默认帮我们实现了，以是我们在service层也就可以非常方便的举行增删改查的操纵了。简朴讲讲增删改查的操纵：
        首先根据service层的规范先举行定义service接口，再用serviceImpl去实现service，如下：
        1、定义service接口 并继承 IService：

1. public interface IUserService extends IService<User> {
2.       
3. }

复制代码

        2、定义service实现类，并继承ServiceImpl 。

1. @Service
2. public class UserService extends ServiceImpl<UserDao, User> implements IUserService {
3.    
4. }

复制代码

        此时我们就可以使用上面所提供的方法了：
        1、save

1.         User user = new User();
2.         user.setUserName("测试2");
3.         user.setJob("测试工作2");
4.         userService.save(user);

复制代码

        2、remove

1.         userService.removeById(user.getId());

复制代码

      3、update

1.         User user = new User();
2.         user.setUserName("测试3");
3.         user.setJob("测试工作3");
4.         user.setId(1825476862067429378L);
5.         userService.updateById(user);

复制代码

        4、get

1.         User user = userService.getById(user.getId());

复制代码

        上面就是根据主键id举行的增删改查最基础的方法。
        由于IService提供了很多方法，有很多其实应用场景很小，以是下一篇会简朴讲讲 其他方法的应用。


五、条件构造器

        BaseMapper 与 Iservice 提供的方法一般只能满足基本的sql语句，如果需要执行复杂的带条件的sql，mybatisplus支持原生的mabatis中的功能，以是如果举行复杂sql,例如多条件动态sql大概多表查询，我们依然可以使用 使用@Servcie、@Update 等注解大概在mapper.xml文件中使用标签书写sql。
        但是其实MybatisPlus中也为我们提供了条件构造器，来执行复杂的多条件动态查询等方法。
        例如通用service常用方法：

• 新增：
  
  
  
  • default boolean save(T entity)：新增纪录
    
  • boolean saveBatch(Collection<T> entityList)：批量插入
    
  • saveBatch(Collection<T> entityList, int batchSize)：一次性批量插入batchSize条纪录
    
  
  
• 删除：
  
  
  
  • boolean removeById(Serializable id)：根据id删除
    
  • boolean removeByMap(Map<String, Object> columnMap)：根据条件删除
    
  • boolean remove(Wrapper<T> queryWrapper)：使用Wrapper封装条件删除
    
  • boolean removeByIds(Collection<? extends Serializable> idList)：删除一批
    
  
  
• 修改：
  
  
  
  • boolean updateById(T entity)：修改
    
  • boolean update(Wrapper<T> updateWrapper)：根据Wrapper修改
    
  • boolean update(T entity, Wrapper<T> updateWrapper)：使用Wrapper查询出结果，修改为entity
    
  • boolean updateBatchById(Collection<T> entityList)：批量修改
    
  • updateBatchById(Collection<T> entityList, int batchSize)：一次性批量修改batchSize条纪录
    
  • boolean saveOrUpdate(T entity)：如果id存在则修改，如果id不存在则新增
    
  
  
• 查询：
  
  
  
  • T getById(Serializable id)：根据id查询
    
  • List<T> listByIds(Collection<? extends Serializable> idList)：根据一批id查询多条纪录
    
  • List<T> listByMap(Map<String, Object> columnMap)：根据条件查询多条纪录
    
  • T getOne(Wrapper<T> queryWrapper)：根据Wrapper查询一条纪录，如果查询到多条则抛出非常
    
  • T getOne(Wrapper<T> queryWrapper, boolean throwEx)：根据Wrapper查询一条纪录，通过throwEx决定是否抛出非常
    
  • int count()：查询总纪录数
    
  • int count(Wrapper<T> queryWrapper)：根据条件查询总纪录数
    
  
  
• 分页：
  
  
  
  • <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper)：带条件分页查询，当前页数据为T类型
    
  • <E extends IPage<T>> E page(E page)：无条件分页
    
  • List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper)：带条件分页查询，当前页数据为HashMap类型
    
  • List<Map<String, Object>> listMaps()：无条件分页
    
  
  

        在有一些方法中的参数类型是 Wrapper<T> queryWrapper ，这个就是条件构造器，例如 
   T getOne(Wrapper<T> queryWrapper)：根据Wrapper查询一条纪录，如果查询到多条则抛出非常
          例如上面这个方法，使用如下所示：

1.         QueryWrapper<User> wrapper = new QueryWrapper<>();
2.         wrapper.eq("name","张三");
3.         User user = userService.getOne(wrapper);

复制代码

        代表的意思就是查询 name 字段便是张三的数据，而且这条数据必须唯一。
        eq()这个就是Wrapper接口中提供的相干函数，映射在sql语句中的方法是 = ，代表相称。
        除了eq()还提供了其他很多相干映射函数：  

  1、QueryWrapper

  QueryWrapper用于构建查询条件，可以通过链式调用的方式组装各种查询条件。
        QueryWrapper的基本用法：

1. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. public class QueryWrapperExample {
5.     public static void main(String[] args) {
6.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
7.         
8.         // 等值条件
9.         queryWrapper.eq("name", "John");
11.         // 不等值条件
12.         queryWrapper.ne("age", 25);
14.         // 大于条件
15.         queryWrapper.gt("create_time", "2022-01-01");
17.         // 小于等于条件
18.         queryWrapper.le("update_time", "2023-01-01");
20.         // 模糊查询
21.         queryWrapper.like("email", "@gmail.com");
23.         // 排序
24.         queryWrapper.orderByAsc("age");
26.         // 使用Lambda表达式
27.         queryWrapper.lambda().eq(User::getName, "Alice");
29.         // 打印SQL语句
30.         System.out.println("SQL: " + queryWrapper.getSqlSelect());
31.     }
32. }

复制代码

  Lambda表达式的高级用法:
  QueryWrapper支持Lambda表达式，可以进一步简化代码，提高可读性。

1. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
3. public class LambdaQueryWrapperExample {
5.     public static void main(String[] args) {
6.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
8.         // Lambda表达式
9.         queryWrapper.lambda().eq(User::getName, "John")
10.                              .ne(User::getAge, 25)
11.                              .like(User::getEmail, "@gmail.com");
13.         // 打印SQL语句
14.         System.out.println("SQL: " + queryWrapper.getSqlSelect());
15.     }
16. }

复制代码

如果要使用Lambda表达式的用法，我们也可以直接使用 LambdaQueryWrapper。
        2、LambdaQueryWrapper

        可以把LambdaQueryWrapper看作是实现了Lambda语法的 QueryWrapper，使用方式跟QueryWrapper 一样，只不外可以不用 lambda() 就可以直接使用lambda语法。

1.         LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
2.         wrapper.eq(User::getName,"张三");
3.         User user = userService.getOne(wrapper);

复制代码

        3、UpdateWrapper

  UpdateWrapper用于构建更新条件，与QueryWrapper类似，也支持链式调用和Lambda表达式。
        注意：在调用更新方法的时间会用到这个。
        基本用法：

1. import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
3. public class UpdateWrapperExample {
5.     public static void main(String[] args)
7.  {
8.         UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
10.         // 等值条件
11.         updateWrapper.eq("name", "John");
13.         // 不等值条件
14.         updateWrapper.ne("age", 25);
16.         // 大于条件
17.         updateWrapper.gt("create_time", "2022-01-01");
19.         // 小于等于条件
20.         updateWrapper.le("update_time", "2023-01-01");
22.         // 模糊查询
23.         updateWrapper.like("email", "@gmail.com");
25.         // 使用Lambda表达式
26.         updateWrapper.lambda().set(User::getName, "Alice").eq(User::getAge, 30);
28.         // 打印SQL语句
29.         System.out.println("SQL: " + updateWrapper.getSqlSet());
30.     }
31. }

复制代码

        UpdateWrapper的基本用法与QueryWrapper类似，可以通过链式调用添加等值、不等值、范围、模糊等更新条件。
         Lambda表达式的高级用法：

1. import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
3. public class LambdaUpdateWrapperExample {
5.     public static void main(String[] args) {
6.         UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
8.         // Lambda表达式
9.         updateWrapper.lambda().set(User::getName, "Alice")
10.                              .eq(User::getAge, 30)
11.                              .like(User::getEmail, "@gmail.com");
13.         // 打印SQL语句
14.         System.out.println("SQL: " + updateWrapper.getSqlSet());
15.     }
16. }

复制代码

        通过lambda方法，我们可以使用实体类的属性名，使得代码更加简便和可读。
        4、 LambdaUpdateWrapper

        与LambdaQueryWrapper 一样，用法与UpdateWrapper 也都一样，只是默认实现了Lambda语法。
        条件构造器的详细用法放下下一篇单独写。



六、分页查询

         mybatisplus有自己的内置分页插件，用起来非常方便，不像mybatis还需要引入第三方依赖。
        使用步骤非常简朴，只要两步即可：
        1、配置拦截器组件

1. /**
2. * 注册插件
3. */
4. @Bean
5. public MybatisPlusInterceptor paginationInterceptor() {
6. ​
7.    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
8.    // 添加分页插件
9.    PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor();
10.    // 设置请求的页面大于最大页后操作，true调回到首页，false继续请求。默认false
11.    pageInterceptor.setOverflow(false);
12.    // 单页分页条数限制，默认无限制
13.    pageInterceptor.setMaxLimit(500L);
14.    // 设置数据库类型
15.    pageInterceptor.setDbType(DbType.MYSQL);
16. ​
17.    interceptor.addInnerInterceptor(pageInterceptor);
18.    return interceptor;
19. }

复制代码

        2、直接使用

1.     // 两个参数：current的值默认是1，从1开始，不是0。size是每一页的条数。
2.     // 意思是查询 第一页，每页10条数据
3.     Page<User> page = new Page<>(1, 10);
4.     userMapper.selectPage(page);
5.     page.getRecords().forEach(System.out::println);

复制代码

        返回结果 第一页 10条数据成功：

         测试第二页 只有一条数据：

七、mybatisplus常用注解


        @TableName

        @TableName注解用于指定实体类对应的数据库表名。使用该注解可以省去手动编写SQL语句的繁琐过程。
        实例：表名为 db_user，对应的实体类 User

1. @TableName(value = "db_user")
2. public class User {
3.     // 实体类字段
4. }

复制代码

        @TableField

         @TableField是MyBatis-Plus中的注解之一，用于在实体类中指定字段与数据库表中字段的映射关系。通过@TableField注解，可以将实体类中的字段与数据库表中的字段举行映射，从而简化数据访问层的开发。
        @TableField注解提供了多个属性，常用的属性包括：

• value：指定数据库表字段的名称。用于映射非主键字段，还可以解决关键字报错
  
• exist：指定该字段是否为数据库表字段，默以为true。是否忽略该字段
  
• fill：指定字段填充策略，如插入时自动填充、更新时自动填充等。自动填充，将对象存入数据库的时间，由 MyBatis Plus 自动给某些字段赋值，例如：create_time、update_time
  
• select：指定该字段是否到场查询，默以为true。是否查询该字段
  
• update： 预处置惩罚set字段自定义注入
  
• condition：指定该字段在查询条件中的匹配方式，如LIKE、EQUAL等。
  

        示例：

1. @Data
2. @TableName(value = "student")
3. public class Student {
4.     @TableId
5.     private Long id;
7.     // 当该字段名称与数据库名字不一致
8.     @TableField(value = "name")
9.     private String name;
11.     // 不查询该字段
12.     @TableField(select = false)
13.     private Integer age;
15.     // 当数据库中没有该字段，就忽略
16.     @TableField(exist = false)
17.     private String gender;
19.     // 执行的sql语句就变成`关键字`，这样sql就不会报错了
20.     @TableField(value = "`desc`")
21.     private string desc
23.     // 第一次添加填充
24.     @TableField(fill = FieldFill.INSERT)
25.     private Date createTime;
27.     // 第一次添加的时候填充，但之后每次更新也会进行填充
28.     @TableField(fill = FieldFill.INSERT_UPDATE)
29.     private Date updateTime;
31. }

复制代码

        自动填充演示：
        1、第一步像上面一样先添加注解，@TableField(fill = FieldFill.INSERT) 代表当数据第一次添加时更新，@TableField(fill = FieldFill.INSERT_UPDATE) 代表数据添加大概更新时都更新该字段。
        2、创建自动填充处置惩罚器

1. // 加入注解才能生效
2. @Component
3. public class MyMetaObjectHandler implements MetaObjectHandler {
4.    
5.     @Override
6.     public void insertFill(MetaObject metaObject) {
7.         this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
8.         this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
10.     }
12.     @Override
13.     public void updateFill(MetaObject metaObject) {
14.         this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
15.     }
17.    
18. }

复制代码

        3、测试就忽略了，可以自己试一下当调用update和save的方法时就会自动填充大概更新该字段。

        condition 预处置惩罚演示：

1.     /**
2.      * 角色名称
3.      */
4.     @TableField(condition = SqlCondition.LIKE)
5.     private String name;
6.     输出 SQL 为：select 表 where name LIKE CONCAT('%',值,'%')

复制代码

        意思是说当我们将实体类的这个字段加上这个注解时，在使用该实体类作为条件 构建条件构造器时，会自动为我们拼接一个模糊查询的条件。
        例如：

1.         User user = new User();
2.         user.setName("张三");
4.         LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>(user);
5.         System.out.println(userService.list(wrapper));

复制代码

 
         update 预处置惩罚set字段:
         好比我们使用mybatisplus自带的insert()方法向数据库插入数据时，假设我们给age字段赋值为1，但是我们在age字段上的@TableField注解里面加了update="%s+1"，那么真真插入到数据库的值就是age=2,而不是age+1了）

1. 例如：@TableField(.. , update="%s+1") 其中 %s 会填充为字段
2. 输出 SQL 为：update 表 set 字段=字段+1 where ...

复制代码

        如果给某个字段上@TableField注解里面写update=“now()”，那么末了我们使用mybatisplus自带的insert()方法向数据库插入数据时，这个字段插入到数据库中的值就为当前时间，看下面代码的sql语句即可明白

1. 例如：@TableField(.. , update="now()") 使用数据库时间
2. 输出 SQL 为：update 表 set 字段=now() where ...

复制代码

        @TableId

        作用：用于标记实体类属性对应的数据库主键。
        @TableId是MyBatis-Plus中的注解之一，用于在实体类中指定主键与数据库表中主键的映射关系。通过@TableId注解，可以将实体类中的主键与数据库表中的主键举行映射，从而简化数据访问层的开发。
        使用@TableId注解时，可以指定主键的属性，例如主键的类型、是否为自增、是否为全局唯一标识符等
        试例：

1. public class User {
2.   
3.   @TableId(value = "id", type = IdType.ASSIGN_ID)
4.   private Long id;
5.   
6.   // 省略getter和setter方法
7. }

复制代码

   value 映射主键字段名 ，type 设置主键类型，主键的天生策略。type有五个常用属性：
   

  （1）NONE，默认的，数据库主键id自增，使用雪花算法实现，实体类中的主键应设置为long类型，克制天生的主键id长度过长而溢出
（2）input，如果开发者手动赋值，则存入该值，如果开发者没有手动赋值，则数据库通过自增方式给主键赋值
（3）AUTO默认就是数据库自增，开发者无需赋值，如果开发者手动赋值，数据库也不会存入该值
（4）ASSIGN_ID，通过雪花算法自动天生id，天生主键非自增
（5）ASSIGN_UUID，主键类型必须为String类型，雪花算法自动天生
要求数据库字段类型，实体类型必须为String

• 在某些情况下，我们想提前获取这个ID，调用com.baomidou.mybatisplus.core.toolkit.IdWorker.getId()方法即可
  

        @TableLogic

        映射逻辑删除，并不是真正的删除

1、数据表添加 deleted 字段，默认是0
2、实体类添加注解

1. package com.md.entity;
3. import com.baomidou.mybatisplus.annotation.*;
4. import com.md.enums.StatusEnum;
5. import lombok.Data;
6. import java.util.Date;
8. @Data
9. @TableName(value = "student")
10. public class Student {
11.     @TableId
12.     private Long id;
13.     @TableField(value = "name")
14.     private String name;
15.     @TableField(select = false)
16.     private Integer age;
17.     @TableField(exist = false)
18.     private String gender;
19.     @TableField(fill = FieldFill.INSERT)
20.     private Date createTime;
21.     @TableField(fill = FieldFill.INSERT_UPDATE)
22.     private Date updateTime;
23.     @Version
24.     private Integer version;
25.     private StatusEnum status;
27.     @TableLogic
28.     private Integer deleted;
29. }

复制代码

3、主配置文件中添加配置

1. # 没有删除为0，删除了为1
2. mybatis-plus:
3.   global-config:
4.     db-config:
5.       logic-not-delete-value: 0
6.       logic-delete-value: 1

复制代码

        删除的时间不是真正的删除数据库表中的数据，而是改变delete字段的值，当然了查询的时间也是查询delete=0，这都是框架自动实现的

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。