谷粒学院——Day01【项目介绍和MyBatisPlus】

绝地灬酷狼 2023-09-27 12:26 126阅读 0赞

## 一、项目介绍 ##

### 1. 项目背景 ###

在线教育顾名思义，是以网络为介质的教学方式，通过网络，学员与教师即使相隔万里也可以开展教学活动；此外，借助网络课件，学员还可以随时随地进行学习，真正打破了时间和空间的限制，对于工作繁忙，学习时间不固定的职场人而言网络远程教育是最方便不过的学习方式。

### 2. 项目采用的商业模式 ###

**B2C模式**（Business To Customer 会员模式）：**此项目采用B2C**  
![在这里插入图片描述][098e82e2f79340209755d5a7dc6fc695.png]  
  
**B2B2C模式：**（商家到商家到用户）  
![在这里插入图片描述][de0aa5cf30524d8cb858537fe923646a.png]  
  
其他的各种商业模式点击此处跳转进行学习：[http://t.csdn.cn/Y8AkZ][http_t.csdn.cn_Y8AkZ]

### 3. 项目功能模块（B2C模式） ###

![在这里插入图片描述][c75825344e154b1fa101c8f4f843dbd1.png]  
  
![在这里插入图片描述][c911d19d79dd4a45bf67148ec2b276ae.png]

### 4. 项目中使用的技术 ###

![在这里插入图片描述][25147b181d2949128b14920c68023c0b.png]  
  
![在这里插入图片描述][aa62d0200a29448a98e32da4f7559bf2.png]  
  
![在这里插入图片描述][f82b6ade6fed43d89c91292d60c931aa.png]

## 二、在线教育项目简介 ##

### 1. 功能简介 ###

谷粒学院，是一个 `B2C` 模式的职业技能在线教育系统，分为前台用户系统和后台运营平台。

### 2. 系统模块 ###

![请添加图片描述][27e69ce0a65441fc8c1d1599c702a44c.png]

### 3. 系统架构 ###

**架构设计需要考虑的几个方面：**

*  **性能：** 主要考虑访问频率，每个用户每天的访问次数。项目初始阶段用户的访问量并不大，如果考虑做运营推广，可能会迎来服务器访问量骤增，因此要考虑**分布式部署，引入缓存**。
 *  **可扩展性：** 统功能会随着用户量的增加以及多变的互联网用户需求不断地扩展，因此考虑到系统的可扩展性的要求需要**使用微服务架构，引入消息中间件**。
 *  **高可用：** 系统一旦宕机，将会带来不可挽回的损失，因此必须做负载均衡，甚至是异地多活这类复杂的方案。如果数据丢失，修复将会非常麻烦，只能靠人工逐条修复，这个很难接受，因此需要考虑存储高可靠。我们需要考虑多种异常情况：机器故障、机房故障，针对机器故障，我们需要设计 MySQL 同机房主备方案；针对机房故障，我们需要设计 MySQL 跨机房同步方案。
 *  **安全性：** 系统的信息有一定的隐私性，例如用户的个人身份信息，不包含强隐私（例如玉照、情感）的信息，因此使用账号密码管理、数据库访问权限控制即可。
 *  **成本：** 视频类网站的主要成本在于服务器成本、流量成本、存储成本、流媒体研发成本，中小型公司可以考虑使用云服务器和云服务。  
    ![请添加图片描述][886f2fd5bd864f06a325b039dfc0c0b1.png]

## 三、MyBatisPlus简介 ##

### 1. 简介 ###

官网：[http://mp.baomidou.com/][http_mp.baomidou.com]  
参考教程：[http://mp.baomidou.com/guide/][http_mp.baomidou.com_guide]

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

### 2. 特征 ###

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

## 四、MyBatisPlus入门 ##

### 一、创建并初始化数据库 ###

#### 1. 创建数据库 ####

`mybatis_plus`

#### 2. 创建 User 表 ####

`User` 表结构如下：

<table> 
 <thead> 
  <tr> 
   <th>id</th> 
   <th>name</th> 
   <th>age</th> 
   <th>email</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Jone</td> 
   <td>18</td> 
   <td>test1@baomidou.com</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Jake</td> 
   <td>20</td> 
   <td>test2@baomidou.com</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>Tom</td> 
   <td>28</td> 
   <td>test3@baomidou.com</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Sandy</td> 
   <td>21</td> 
   <td>test4@baomidou.com</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Billie</td> 
   <td>24</td> 
   <td>test5@baomidou.com</td> 
  </tr> 
 </tbody> 
</table>

其对应数据库的 `sql` 语句如下：

DROP TABLE IF EXISTS USER;
    CREATE TABLE USER
    (
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
    );
    
    
    DELETE FROM USER;
    INSERT INTO USER (id, NAME, age, email) VALUES
    (1, 'Jone', 18, 'test1@baomidou.com'),
    (2, 'Jack', 20, 'test2@baomidou.com'),
    (3, 'Tom', 28, 'test3@baomidou.com'),
    (4, 'Sandy', 21, 'test4@baomidou.com'),
    (5, 'Billie', 24, 'test5@baomidou.com');

### 二、初始化工程 ###

在 `IEDA` 使用 `Spring Initializr` 快速初始化一个 `Spring Boot` 工程。

### 三、添加依赖 ###

#### 1. 引入依赖 ####

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.0.5</version>
    </dependency>
    
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

#### 2. IDEA 中安装 lombok 插件 ####

**IDEA2018版本：**  
![请添加图片描述][27844a13babb4a59a5adfa3173e318f2.png]  
  
**IDEA2019版本：**  
![请添加图片描述][ae6ee475354b48d8be5fa12198317024.png]

### 四、配置 ###

在 `application.properties` 配置文件中添加 `MySQL` 数据库的相关配置：

#mysql数据库连接
    spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&serverTimeZone=UTC
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

### 五、编写代码 ###

#### 1. 主类 ####

在 `SpringBoot` 启动类中添加 `@MapperScan` 注解，扫描 `Mapper` 文件夹。

**注意：** 扫描的包名根据实际情况修改。

@SpringBootApplication
    @MapperScan("com.atguigu.mpdemo1010.mapper")
    public class Mpdemo1010Application {
        public static void main(String[] args) {
            SpringApplication.run(Mpdemo1010Application.class, args);
        }
    }

#### 2. 实体 ####

创建 `entity` 实体包，在此包下创建 `User` 实体类：

@Data
    public class User {
    
        private Long id;
    
        private String name;
    
        private Integer age;
    
        private String email;
    }

查询编译结果：  
![请添加图片描述][a48beb093020469588812425a438cd41.jpeg]

#### 3. mapper ####

创建 `mapper` 包，在此包下创建 `UserMapper` 接口：

@Repository
    public interface UserMapper extends BaseMapper<User> {
    }

### 六、功能测试 ###

添加测试类，进行功能测试：

@SpringBootTest
    public class Mpdemo1010ApplicationTests {
    
        @Autowired
        private UserMapper userMapper;
    
        // 查询user表所有数据
        @Test
        public void testSelectList() {
    
            List<User> users = userMapper.selectList(null);
            users.forEach(System.out::println);
    
        }
        
    }

运行结果如下：  
![在这里插入图片描述][cb46680d54a447ffae36bae83ff8a0fc.png]  
  
通过以上几个简单的步骤，我们就实现了 `User` 表的 `CRUD` 功能，甚至连 `XML` 文件都不用编写！

### 七、配置日志 ###

查询 `sql` 输出日志

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

![在这里插入图片描述][3a64d00c70d9478088443b7753621082.png]

## 五、MyBatisPlus的CRUD 接口 ##

### 一、insert ###

#### 1. 插入操作 ####

@Test
        public void testInsert() {
            User user = new User();
            user.setName("lucy");
            user.setAge(19);
            user.setEmail("test5@baomidou.com");
    
            int insert = userMapper.insert(user);
            System.out.println(insert); // 影响的行数
            System.out.println(user);   // id 会自动填充
    
        }

运行结果如下：  
![在这里插入图片描述][4fee24fbc9234fc4be04a073d9cb2a54.png]  
**注意：** 数据库插入id值默认为：全局唯一id。  
![在这里插入图片描述][7db020ade9d247a59389e42fe0a5477a.png]

#### 2. 主键策略 ####

1.  `ID_WORKER`  
    `MyBatis-Plus` 默认的主键策略是：`ID_WORKER` 全局唯一ID  
    分布式系统唯一ID生成方案汇总：[https://www.cnblogs.com/haoxinyue/p/5208136.html][https_www.cnblogs.com_haoxinyue_p_5208136.html]
2.  **自增策略**

*  想要主键自增需要配置如下主键策略
    
     *  需要在创建**数据表**的时候设置**主键自增**
     *  实体字段中配置 `@TableId(type = IdType.AUTO)`

@Data
    public class User {
    
    
        @TableId(type = IdType.AUTO)
        private Long id;
    
        private String name;
    
        private Integer age;
    
        private String email;
    }

*  要想影响所有实体的配置，可以设置全局主键配置

#全局设置主键生成策略
    mybatis-plus.global-config.db-config.id-type=auto

*  其它主键策略：分析 IdType 源码可知

@Getter
    public enum IdType {
        /**
         * 数据库ID自增
         */
        AUTO(0),
        /**
         * 该类型为未设置主键类型
         */
        NONE(1),
        /**
         * 用户输入ID
         * 该类型可以通过自己注册自动填充插件进行填充
         */
        INPUT(2),
    
        /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
        /**
         * 全局唯一ID (idWorker)
         */
        ID_WORKER(3),
        /**
         * 全局唯一ID (UUID)
         */
        UUID(4),
        /**
         * 字符串全局唯一ID (idWorker 的字符串表示)
         */
        ID_WORKER_STR(5);
    
        private int key;
    
        IdType(int key) {
            this.key = key;
        }
    }

### 二、update ###

#### 1. 根据 id 更新操作 ####

**注意：** `update` 时生成的 `sql` 自动是动态 `sql`：`UPDATE user SET age=? WHERE id=?`。

@Test
        void testUpdate(){
            User user = new User();
            user.setId(1L);
            user.setAge(32);
            int result = userMapper.updateById(user);
    
            System.out.println(result);
        }

#### 2. 自动填充 ####

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的**创建时间**，**更新时间**等。  
我们可以使用 `MyBatis Plus` 的自动填充功能，完成这些字段的赋值工作：

1.  **在数据库表中添加自动填充字段**  
    在 `User` 表中添加 `datetime` 类型的新的字段 `create_time`、`update_time`
2.  **实体上添加注解**

1.  **实现元对象处理器接口**  
    **注意：** 不要忘记添加 `@Component` 注解

@Component
    public class MyMetaObjectHandler implements MetaObjectHandler {
    
        private static final Logger logger = LoggerFactory.getLogger(MyMetaObjectHandler.class);
    
    
    
        //使用mp实现添加操作，这个方法执行
        @Override
        public void insertFill(MetaObject metaObject) {
            logger.info("start insert fill...");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    
        //使用mp实现修改操作，这个方法执行
        @Override
        public void updateFill(MetaObject metaObject) {
            logger.info("start update fill...");
            this.setFieldValByName("updateTime", new Date(), metaObject);
    
        }
    }

1.  **功能测试**  
    ![在这里插入图片描述][b63fff1f433941a9aec816da1c742986.png]

#### 3. 乐观锁 ####

**主要使用场景：** 当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新。

**乐观锁实现方式：**

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

> 在提交数据时，比较当前版本号和数据库版本号是否一致，一致可提交，并将版本号 +1；不一致则提交失败。

![在这里插入图片描述][1f12f6448ed94002932ccdc7a45af918.png]

1.  **数据库中添加 version 字段**

ALTER TABLE `user` ADD COLUMN `version` INT

![在这里插入图片描述][5ab22fea179349ccad3abf2d061b5528.png]  
  
2. **实体类添加 version 字段**  
在 `User` 类中添加 `version` 字段并且添加 `@Version` 注解

@Data
    public class User {
    
        @TableId(type = IdType.AUTO)
        private Long id;
    
        private String name;
    
        private Integer age;
    
        private String email;
    
        @TableField(fill = FieldFill.INSERT)
        private Date createTime;
    
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date updateTime;
    
        @Version
        private Integer version; // 版本号
    }

1.  **元对象处理器接口添加 version 的 insert 默认值**

@Component
    public class MyMetaObjectHandler implements MetaObjectHandler {
    
        private static final Logger logger = LoggerFactory.getLogger(MyMetaObjectHandler.class);
        
        //使用mp实现添加操作，这个方法执行
        @Override
        public void insertFill(MetaObject metaObject) {
            logger.info("start insert fill...");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
            this.setFieldValByName("version",1, metaObject);
        }
    
        //使用mp实现修改操作，这个方法执行
        @Override
        public void updateFill(MetaObject metaObject) {
            logger.info("start update fill...");
            this.setFieldValByName("updateTime", new Date(), metaObject);
    
        }
    }

**特别说明：**

*  支持的数据类型只有 `int,Integer,long,Long,Date,Timestamp,LocalDateTime`。
 *  整数类型下 `newVersion = oldVersion + 1`。
 *  `newVersion` 会回写到 `entity` 中。
 *  仅支持 `updateById(id)` 与 `update(entity, wrapper)` 方法。
 *  在 `update(entity, wrapper)` 方法下, `wrapper` 不能复用。

1.  **在 MybatisPlusConfig 中注册 Bean**  
    创建 `config` 配置包，在此包下创建 `MybatisPlusConfig` 配置类：

1.  测试乐观锁可以修改 `成功`  
    测试后分析打印的 `sql` 语句，将 `version` 的数值进行 `+1` 操作。

/**
         * 测试乐观锁修改 成功
         */
        @Test
        public void testOptimisticLocker() {
            // 根据id查询数据
            User user = userMapper.selectById(1587437781200846849L);
            // 进行修改
            user.setAge(100);
            // 执行更新
            userMapper.updateById(user);
        }

![在这里插入图片描述][dd76193d1fda4f288b7c53276fd7ddba.png]

1.  测试乐观锁修改 `失败`

/**
         * 测试乐观锁修改失败
         */
        @Test
        public void testOptimisticLockerFail() {
            // 查询
            User user = userMapper.selectById(1587437781200846849L);
            // 修改数据
            user.setAge(100);
            // 模拟取出数据后，数据库中 version 实际数据比取出的值大，即已被其它线程修改并更新了 version
            user.setVersion(user.getVersion() - 1);
            // 执行更新
            userMapper.updateById(user);
        }

![在这里插入图片描述][26aa2e046e604befbdb69873bd616452.png]

### 三、select ###

#### 1. 根据id查询记录 ####

// 根据id查询
        @Test
        void testSelectById(){
            User user = userMapper.selectById(1L);
            System.out.println(user);
        }

![在这里插入图片描述][40d061c22854451da3a599b1fea314a1.png]

#### 2. 通过多个id批量查询 ####

// 多个id批量查询
        @Test
        public void testSelectDemo01() {
            List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
            users.forEach(System.out::println);
        }

![在这里插入图片描述][5a9550551e054e159deeeedece617b4f.png]

#### 3. 简单的条件查询 ####

// 简单的条件查询
        @Test
        public void testSelectByMap() {
            HashMap<String, Object> map = new HashMap<>();
            map.put("name", "Mary");
            map.put("age", 32);
            List<User> users = userMapper.selectByMap(map);
            users.forEach(System.out::println);
        }

![在这里插入图片描述][bba9fe6018a9488bbd88946bb211f8d2.png]  
  
**注意：** `map` 中的 `key` 对应的是数据库中的列名。例如数据库 `user_id`，实体类是 `userId` ，这时 `map` 的 `key` 需要填写`user_id`。

#### 4. 分页 ####

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

1.  **创建配置类**  
    在 `MybatisPlusConfig` 配置类中添加分页插件：

@EnableTransactionManagement
    @Configuration
    @MapperScan("com.atguigu.mpdemo1010.mapper")
    public class MybatisPlusConfig {
    
        // 乐观锁插件
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() {
            return new OptimisticLockerInterceptor();
        }
    
       // 分页插件
        @Bean
        public PaginationInterceptor paginationInterceptor() {
            return new PaginationInterceptor();
        }
    
    }

1.  **测试 selectPage 分页**

// 分页查询
        @Test
        public void testPage() {
            // 创建page对象
            // 传入两个参数：当前页 和 每页显示记录数
            Page<User> page = new Page<>(1, 3);
    
            // 调用mp分页查询方法
            // 调用mp分页查询过程中，底层会封装，把所有分页数据分装到page对象中
            userMapper.selectPage(page, null);
    
            // 通过page对象获取分页数据
            page.getRecords().forEach(System.out::println);  //遍历查询的分页数据
            System.out.println(page.getCurrent()); //获取当前页
            System.out.println(page.getSize()); //每页显示记录数
            System.out.println(page.getTotal()); //总记录数
            System.out.println(page.getPages()); //总页数
    
            System.out.println(page.hasNext()); //判断是否有下一页
            System.out.println(page.hasPrevious()); //判断是否有上一页
    
        }

![在这里插入图片描述][27f561c9764b4b178a11f040c9ff9edb.png]

1.  **测试 selectMapsPage 分页：结果集是 Map**

//测试selectMapsPage分页：结果集是Map
        @Test
        void testSelectMapsPage(){
            //创建page对象
            //传入参数：当前页 和 每页显示记录数
            Page<User> page = new Page<>(1,3);
            
            //调用mp分页查询方法
            //调用mp分页查询过程中，底层会封装，把所有分页数据分装到page对象中
            IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);
    
            //注意：此行必须使用 mapIPage 获取记录列表，否则会有数据类型转换错误
            mapIPage.getRecords().forEach(System.out::println);
            System.out.println(page.getCurrent());
            System.out.println(page.getPages());
            System.out.println(page.getSize());
            System.out.println(page.getTotal());
            
            System.out.println(page.hasNext());
            System.out.println(page.hasPrevious());
        }

![在这里插入图片描述][6de1d154810a4039b3983338fda1e4c5.png]

### 四、delete ###

#### 1. 根据id删除记录 ####

@Test
        public void testDeleteById(){
            int result = userMapper.deleteById(1587437781200846849L);
            System.out.println(result);
        }

![在这里插入图片描述][be8a84cbfc254059a4b381a11c5091e2.png]

#### 2. 批量删除 ####

@Test
        public void testDeleteBatchIds() {
            int result = userMapper.deleteBatchIds(Arrays.asList(6, 7, 8));
            System.out.println(result);
        }

![在这里插入图片描述][af153db819e54edba985f75911732b52.png]

#### 3. 简单的条件查询删除 ####

@Test
        public void testDeleteByMap() {
            HashMap<String, Object> map = new HashMap<>();
            map.put("name", "Mary");
            map.put("age", 32);
            int result = userMapper.deleteByMap(map);
            System.out.println(result);
        }

![在这里插入图片描述][9ef6c8eb58a34873883c42e3de514aae.png]

#### 4. 逻辑删除 ####

*  **物理删除：真实删除**，将对应数据从数据库中删除，之后**查询不到**此条被删除数据。
 *  **逻辑删除：假删除**，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中**仍旧能看到**此条数据记录。

1.  **数据库中添加 deleted字段**

ALTER TABLE `user` ADD COLUMN `deleted` boolean

![在这里插入图片描述][813d8f2ae2dc4d2b8b552bf0fb8e6118.png]

1.  **实体类添加deleted 字段**  
    在 `User` 实体类中添加 `deleted` 字段，并加上 `@TableLogic` 注解 和 `@TableField(fill = FieldFill.INSERT)` 注解。

1.  **元对象处理器接口添加deleted的insert默认值**

@Override
        public void insertFill(MetaObject metaObject) {
            logger.info("start insert fill...");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
            this.setFieldValByName("version",1, metaObject);
            this.setFieldValByName("deleted", 0, metaObject);
        }

1.  **application.properties 加入配置**  
    此为默认值，如果你的默认值和mp默认的一样,该配置可无。

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

1.  **在 MybatisPlusConfig 中注册 Bean**

1.  **测试逻辑删除**

*  测试后发现，数据 并没有删除， `deleted` 字段的值由0变为1。
 *  测试后分析打印的 `sql` 语句，是一条 `update`。
 *  **注意：** 被删除数据的 `deleted` 字段的值必须是0，才能被选取出来执行逻辑删除的操作。

/**
         * 测试 逻辑删除
         */
        @Test
        public void testLogicDelete() {
            int result = userMapper.deleteById(5L);
            System.out.println(result);
        }

![在这里插入图片描述][76525f2bed0e40dcbc24c223de401a0a.png]

1.  **测试逻辑删除后的查询**  
    `MyBatis Plus` 中查询操作也会自动添加逻辑删除字段的判断。

/**
         * 测试 逻辑删除后的查询：
         * 不包括被逻辑删除的记录
         */
        @Test
        public void testLogicDeleteSelect() {
            User user = new User();
            List<User> users = userMapper.selectList(null);
            users.forEach(System.out::println);
        }

![在这里插入图片描述][5274eb6021ef491c987eec8e5aa596ca.png]  
  
测试后分析打印的sql语句，包含 `WHERE deleted=0`。  
`SELECT id,name,age,email,create_time,update_time,deleted FROM user WHERE deleted=0`。

### 五、性能分析 ###

性能分析拦截器，**用于输出每条 SQL 语句及其执行时间**。  
SQL 性能执行分析,开发环境使用，**超过指定时间，停止运行**。**有助于发现问题**。

#### 1. 配置插件 ####

1.  **参数说明**  
    参数：`maxTime`： SQL 执行最大时长，超过自动停止运行，有助于发现问题。  
    参数：`format`： SQL是否格式化，默认 `false`。
2.  **在 MybatisPlusConfig 中配置**

//性能分析插件
        /**
         * SQL 执行性能分析插件
         * 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
         */
        @Bean
        @Profile({"dev","test"})// 设置 dev test 环境开启
        public PerformanceInterceptor performanceInterceptor() {
            PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
            performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
            performanceInterceptor.setFormat(true);
            return performanceInterceptor;
        }

1.  **Spring Boot 中设置dev环境**

#环境设置：dev、test、prod
    spring.profiles.active=dev

可以针对各环境新建不同的配置文件: `application-dev.properties`、`application-test.properties`、`application-prod.properties`。

#### 2. 测试 ####

1.  **常规测试**

/**
         * 测试 性能分析插件
         */
        @Test
        public void testPerformance() {
            User user = new User();
            user.setName("Helen");
            user.setEmail("helen@sina.com");
            user.setAge(18);
            userMapper.insert(user);
        }

控制台输出：  
![在这里插入图片描述][55e4dc2f64094b5eaaf33c63c5ca6499.png]

1.  **将maxTime 改小之后再次进行测试**

performanceInterceptor.setMaxTime(5);  //ms，超过此处设置的ms不执行

如果执行时间过长，则抛出异常：`The SQL execution time is too large,`  
![在这里插入图片描述][4883bcdf39e6422a808b32a38da575fb.png]

### 六、其他 ###

如果想进行**复杂条件查询**，那么需要使用条件构造器 `Wapper`，涉及到如下方法:

1、delete
    2、selectOne
    3、selectCount
    4、selectList
    5、selectMaps
    6、selectObjs
    7、update

## 六、MyBatisPlus条件构造器【wapper】 ##

### 一、wapper 介绍 ###

![在这里插入图片描述][339a27e96224423182729929417f86cd.png]

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

*  `AbstractWrapper`: 用于查询条件封装，生成 `sql` 的 `where` 条件。
    
     *  `QueryWrapper`: `Entity` 对象封装操作类，不是用 `lambda` 语法。
     *  `UpdateWrapper`: `Update` 条件封装，用于`Entity` 对象更新操作。
     *  `AbstractLambdaWrapper`: `Lambda` 语法使用 `Wrapper` 统一处理解析 `lambda` 获取 `column`。
        
         *  `LambdaQueryWrapper`: 看名称也能明白就是用于 `Lambda` 语法使用的查询 `Wrapper`。
         *  `LambdaUpdateWrapper`: `Lambda` 更新封装 `Wrapper`。

### 二、AbstractWrapper ###

**注意：** 以下条件构造器的方法入参中的 `column` 均表示**数据库字段**。

1.  **ge、gt、le、lt、isNull、isNotNull**

@Test
        public void testDelete() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper
                    .isNull("name")
                    .ge("age", 12)
                    .isNotNull("email");
            int result = userMapper.delete(queryWrapper);
            System.out.println("delete return count = " + result);
        }

**sql:** `UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL`

1.  **eq、ne**  
    **注意：** `seletOne` 返回的是**一条实体记录，当出现多条时会报错**。

@Test
        public void testSelectOne() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("name", "Tom");
            User user = userMapper.selectOne(queryWrapper);
            System.out.println(user);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name = ?`

1.  **between、notBetween**  
    **注意：** 范围包含大小边界。

@Test
    public void testSelectCount() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age", 20, 30);
    Integer count = userMapper.selectCount(queryWrapper);
    System.out.println(count);
    }

**sql:** `SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ?`

1.  **allEq**

@Test
        public void testSelectList() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            Map<String, Object> map = new HashMap<>();
            map.put("id", 2);
            map.put("name", "Jack");
            map.put("age", 20);
            queryWrapper.allEq(map);
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name = ? AND id = ? AND age = ?`

1.  **like、notLike、likeLeft、likeRight**  
    **注意：** `selectMaps` 返回 `Map` 集合列表。

public void testSelectMaps() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper
                    .notLike("name", "e")
                    .likeRight("email", "t");
            List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
            maps.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ?`

1.  **in、notIn、inSql、notinSql、exists、notExists**

**in、notIn：**

*  `notIn("age",{1,2,3})--->age not in (1,2,3)`
 *  `notIn("age", 1, 2, 3)--->age not in (1,2,3)`

**inSql、notinSql：可以实现子查询**

*  例: `inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)`
 *  例: `inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)`

@Test
        public void testSelectObjs() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            //queryWrapper.in("id", 1, 2, 3);
            queryWrapper.inSql("id", "select id from user where id < 3");
            List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
            objects.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND id IN (select id from user where id < 3)`

1.  **or、and**  
    **注意：** 这里使用的是 `UpdateWrapper`。  
    不调用 `or` 则默认为使用 `and` 连。

@Test
        public void testUpdate1() {
            //修改值
            User user = new User();
            user.setAge(99);
            user.setName("Andy");
            //修改条件
            UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
            userUpdateWrapper
                    .like("name", "h")
                    .or()
                    .between("age", 20, 30);
            int result = userMapper.update(user, userUpdateWrapper);
            System.out.println(result);
        }

**sql:** `UPDATE user SET name=?, age=?, update_time=? WHERE deleted=0 AND name LIKE ? OR age BETWEEN ? AND ?`

1.  **嵌套or、嵌套and**  
    **这里使用了lambda表达式**，`or` 中的表达式最后翻译成`sql`时会被加上圆括号。

@Test
        public void testUpdate2() {
            //修改值
            User user = new User();
            user.setAge(99);
            user.setName("Andy");
            //修改条件
            UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
            userUpdateWrapper
                    .like("name", "h")
                    .or(i -> i.eq("name", "李白").ne("age", 20));
            int result = userMapper.update(user, userUpdateWrapper);
            System.out.println(result);
        }

**sql:** `UPDATE user SET name=?, age=?, update_time=? WHERE deleted=0 AND name LIKE ? OR ( name = ? AND age <> ? )`

1.  **orderBy、orderByDesc、orderByAsc**

@Test
        public void testSelectListOrderBy() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.orderByDesc("id");
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 ORDER BY id DESC`

1.  **last**  
    直接拼接到 `sql` 的最后  
    **注意：** **只能调用一次**, 多次调用以**最后一次为准** 有 `sql` 注入的风险,请谨慎使用。

@Test
        public void testSelectListLast() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.last("limit 1");
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 limit 1`

1.  **指定要查询的列**

@Test
        public void testSelectListColumn() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.select("id", "name", "age");
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }

**sql:** `SELECT id,name,age FROM user WHERE deleted=0`

1.  **set、setSql**  
    最终的 `sql` 会合并 `user.setAge()`，以及 `userUpdateWrapper.set()` 和 `setSql()` 中 的字段。

@Test
        public void testUpdateSet() {
            //修改值
            User user = new User();
            user.setAge(99);
            //修改条件
            UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
            userUpdateWrapper
                    .like("name", "h")
                    .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
                    .setSql(" email = '123@qq.com'");//可以有子查询
            int result = userMapper.update(user, userUpdateWrapper);
        }

**sql:** `UPDATE user SET age=?, update_time=?, name=?, email = '123@qq.com' WHERE deleted=0 AND name LIKE ?`

**创作不易，如果有帮助到您，请给文章点个赞和收藏，让更多的人看到！！！**  
**关注博主不迷路，内容持续更新中。**

[098e82e2f79340209755d5a7dc6fc695.png]: https://img-blog.csdnimg.cn/098e82e2f79340209755d5a7dc6fc695.png
[de0aa5cf30524d8cb858537fe923646a.png]: https://img-blog.csdnimg.cn/de0aa5cf30524d8cb858537fe923646a.png
[http_t.csdn.cn_Y8AkZ]: http://t.csdn.cn/Y8AkZ
[c75825344e154b1fa101c8f4f843dbd1.png]: https://img-blog.csdnimg.cn/c75825344e154b1fa101c8f4f843dbd1.png
[c911d19d79dd4a45bf67148ec2b276ae.png]: https://img-blog.csdnimg.cn/c911d19d79dd4a45bf67148ec2b276ae.png
[25147b181d2949128b14920c68023c0b.png]: https://img-blog.csdnimg.cn/25147b181d2949128b14920c68023c0b.png
[aa62d0200a29448a98e32da4f7559bf2.png]: https://img-blog.csdnimg.cn/aa62d0200a29448a98e32da4f7559bf2.png
[f82b6ade6fed43d89c91292d60c931aa.png]: https://img-blog.csdnimg.cn/f82b6ade6fed43d89c91292d60c931aa.png
[27e69ce0a65441fc8c1d1599c702a44c.png]: https://img-blog.csdnimg.cn/27e69ce0a65441fc8c1d1599c702a44c.png
[886f2fd5bd864f06a325b039dfc0c0b1.png]: https://img-blog.csdnimg.cn/886f2fd5bd864f06a325b039dfc0c0b1.png
[http_mp.baomidou.com]: http://mp.baomidou.com/
[http_mp.baomidou.com_guide]: http://mp.baomidou.com/guide/
[27844a13babb4a59a5adfa3173e318f2.png]: https://img-blog.csdnimg.cn/27844a13babb4a59a5adfa3173e318f2.png
[ae6ee475354b48d8be5fa12198317024.png]: https://img-blog.csdnimg.cn/ae6ee475354b48d8be5fa12198317024.png
[a48beb093020469588812425a438cd41.jpeg]: https://img-blog.csdnimg.cn/a48beb093020469588812425a438cd41.jpeg
[cb46680d54a447ffae36bae83ff8a0fc.png]: https://img-blog.csdnimg.cn/cb46680d54a447ffae36bae83ff8a0fc.png
[3a64d00c70d9478088443b7753621082.png]: https://img-blog.csdnimg.cn/3a64d00c70d9478088443b7753621082.png
[4fee24fbc9234fc4be04a073d9cb2a54.png]: https://img-blog.csdnimg.cn/4fee24fbc9234fc4be04a073d9cb2a54.png
[7db020ade9d247a59389e42fe0a5477a.png]: https://img-blog.csdnimg.cn/7db020ade9d247a59389e42fe0a5477a.png
[https_www.cnblogs.com_haoxinyue_p_5208136.html]: https://www.cnblogs.com/haoxinyue/p/5208136.html
[b63fff1f433941a9aec816da1c742986.png]: https://img-blog.csdnimg.cn/b63fff1f433941a9aec816da1c742986.png
[1f12f6448ed94002932ccdc7a45af918.png]: https://img-blog.csdnimg.cn/1f12f6448ed94002932ccdc7a45af918.png
[5ab22fea179349ccad3abf2d061b5528.png]: https://img-blog.csdnimg.cn/5ab22fea179349ccad3abf2d061b5528.png
[dd76193d1fda4f288b7c53276fd7ddba.png]: https://img-blog.csdnimg.cn/dd76193d1fda4f288b7c53276fd7ddba.png
[26aa2e046e604befbdb69873bd616452.png]: https://img-blog.csdnimg.cn/26aa2e046e604befbdb69873bd616452.png
[40d061c22854451da3a599b1fea314a1.png]: https://img-blog.csdnimg.cn/40d061c22854451da3a599b1fea314a1.png
[5a9550551e054e159deeeedece617b4f.png]: https://img-blog.csdnimg.cn/5a9550551e054e159deeeedece617b4f.png
[bba9fe6018a9488bbd88946bb211f8d2.png]: https://img-blog.csdnimg.cn/bba9fe6018a9488bbd88946bb211f8d2.png
[27f561c9764b4b178a11f040c9ff9edb.png]: https://img-blog.csdnimg.cn/27f561c9764b4b178a11f040c9ff9edb.png
[6de1d154810a4039b3983338fda1e4c5.png]: https://img-blog.csdnimg.cn/6de1d154810a4039b3983338fda1e4c5.png
[be8a84cbfc254059a4b381a11c5091e2.png]: https://img-blog.csdnimg.cn/be8a84cbfc254059a4b381a11c5091e2.png
[af153db819e54edba985f75911732b52.png]: https://img-blog.csdnimg.cn/af153db819e54edba985f75911732b52.png
[9ef6c8eb58a34873883c42e3de514aae.png]: https://img-blog.csdnimg.cn/9ef6c8eb58a34873883c42e3de514aae.png
[813d8f2ae2dc4d2b8b552bf0fb8e6118.png]: https://img-blog.csdnimg.cn/813d8f2ae2dc4d2b8b552bf0fb8e6118.png
[76525f2bed0e40dcbc24c223de401a0a.png]: https://img-blog.csdnimg.cn/76525f2bed0e40dcbc24c223de401a0a.png
[5274eb6021ef491c987eec8e5aa596ca.png]: https://img-blog.csdnimg.cn/5274eb6021ef491c987eec8e5aa596ca.png
[55e4dc2f64094b5eaaf33c63c5ca6499.png]: https://img-blog.csdnimg.cn/55e4dc2f64094b5eaaf33c63c5ca6499.png
[4883bcdf39e6422a808b32a38da575fb.png]: https://img-blog.csdnimg.cn/4883bcdf39e6422a808b32a38da575fb.png
[339a27e96224423182729929417f86cd.png]: https://img-blog.csdnimg.cn/339a27e96224423182729929417f86cd.png