2万字总结《MybatisPlus—为简化开发而生》

待我称王封你为后i 2023-10-02 10:50 6阅读 0赞

## 《MybatisPlus—为简化开发而生》 ##

#### 文章目录 ####

*  《MybatisPlus—为简化开发而生》
 *   *  1、简介
     *  2、特性
     *  3、快速入门
     *   *  1、创建数据库\`mybatis-plus\`
         *  2、创建user表
         *  3、编写项目，初始化项目，使用SpringBoot初始化
         *  4、导入依赖
         *  5、连接数据库
         *  6、使用MybatisPlus
     *  4、配置日志输出
     *  5、插入测试及雪花算法
     *  6、CRUD扩展
     *   *  1、插入操作
         *  2、主键生成策略
         *  3、更新操作
         *  4、自动填充
         *  5、乐观锁
     *  7、查询操作
     *  8、分页查询
     *  9、删除操作
     *  9、逻辑删除
     *  10.性能分析插件
     *  11、条件查询器Wrapper
     *   *  1、测试一：
         *  2、测试二
         *  3、测试三
         *  4、测试四
         *  5、测试五
         *  6、测试六
     *  12、代码生成器

官网：https://www.sogou.com/link?url=58p16RfDRLuiEHkXxtCPmEiZEcHfFSzq

![img][]

### 1、简介 ###

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

### 2、特性 ###

>  *  **无侵入**：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
>  *  **损耗小**：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作，BaseMapper
>  *  **强大的 CRUD 操作**：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求（以后基本的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 操作智能分析阻断，也可自定义拦截规则，预防误操作

### 3、快速入门 ###

地址：https://mp.baomidou.com/guide/quick-start.html\#%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B7%A5%E7%A8%8B

使用第三方组件：

1、导入对应的依赖

2、研究依赖如何配置

3、代码如何编写

4、提高扩展技术能力

> **步骤**

#### 1、创建数据库`mybatis-plus` ####

![img][img 1]

#### 2、创建user表 ####

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

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)
    );
    
    -- 真实开发中 version（乐观锁） deleted（逻辑删除）  gmt_create  gmt_modified

其对应的数据库 Data 脚本如下：

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');

#### 3、编写项目，初始化项目，使用SpringBoot初始化 ####

![img][img 2]

#### 4、导入依赖 ####

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
    
    
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.3.3</version>
            </dependency>

说明：mybatis以及mybatis-plus这两个包不能同时导入

#### 5、连接数据库 ####

#mybatis 5  com.mysql.jdbc.Driver
    
    #mybatis 8  需要加上时区 、com.mysql.cj.jdbc.Driver
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&character=UTF-8&serverTimezone=GMT%2B8
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

传统方式：6、pojo-dao(连接mybatis、配置mapper.xml文件)-service-controller

#### 6、使用MybatisPlus ####

*  pojo

*  mapper接口

package com.kk.mapper;
    
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.kk.pojo.User;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    // 在对应的Mapper 上面实现基本的接口   BaseMapper
    @Repository  //代表持久层
    public interface UserMapper  extends BaseMapper<User>{
        
        List<User> selectList();
        // 所有的CRUD都编写完成
        //不用像以前那样，编写CRUD以及配置文件
    
    
    }

*  注意点：需要在主程序中添加@MapperScan(“com.kk.mapper”)

package com.kk;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    
    //扫描我们的mapper文件夹
    @MapperScan("com.kk.mapper")
    @SpringBootApplication
    public class MybatisPlusApplication {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(MybatisPlusApplication.class, args);
        }
    
    }

*  测试

package com.kk;
    
    import com.kk.mapper.UserMapper;
    import com.kk.pojo.User;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.util.List;
    
    @SpringBootTest
    class MybatisPlusApplicationTests {
        
    
    
        //继承了BaseMapper  BaseMapper所有的方法都可以被使用
        @Autowired
        private UserMapper userMapper;
    
    
    
        @Test
        void contextLoads() {
        
            //参数是一个mapper 条件构造器 这里不用
            //查询全部用户
          List<User> users =  userMapper.selectList(null);
          users.forEach(System.out::println);
        }
    
    }

测试成！

![img][img 3]

### 4、配置日志输出 ###

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

![img][img 4]

### 5、插入测试及雪花算法 ###

### 6、CRUD扩展 ###

#### 1、插入操作 ####

//测试插入功能
    @Test
    public void testInsert(){
        
    
        User user = new User();
        user.setName("kk");
        user.setAge(17);
        user.setEmail("30666@qq.com");
    
        //这里需要一个User对象，所以需要new一个User
        int result = userMapper.insert(user);  //帮我们自动生成id
        System.out.println(result);//受影响的函行数
        System.out.println(user);//发现，id会自动回填
    }

![img][img 5]

#### 2、主键生成策略 ####

> 默认 ID\_WORKER全部唯一id

雪花算法：

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter/snowflake。雪花算法支持的TPS可以达到419万左右（2^22\*1000）。

> 主键自增

配置主键自增：

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

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

![img][img 6]

> 其余源码解释

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

测试：

User实体类

package com.kk.pojo;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableId;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
        //对应数据库中的主键（uuid，自增id，雪花算法，redis，zookeeper)
        @TableId(type = IdType.INPUT) //一旦手动输入id之后，就需要自己配置id
        private Long id;
        private String name;
        private Integer age;
        private String email;
    }

测试类：

package com.kk;
    
    import com.kk.mapper.UserMapper;
    import com.kk.pojo.User;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.util.List;
    
    @SpringBootTest
    class MybatisPlusApplicationTests {
        
    
        //继承了BaseMapper  BaseMapper所有的方法都可以被使用
        @Autowired
        private UserMapper userMapper;
    
    
        //测试插入功能
        @Test
        public void testInsert(){
        
    
            User user = new User();
            user.setId(6L);
            user.setName("kk");
            user.setAge(17);
            user.setEmail("30666@qq.com");
    
            //这里需要一个User对象，所以需要new一个User
            int result = userMapper.insert(user);  //帮我们自动生成id
            System.out.println(result);//受影响的函行数
            System.out.println(user);//发现，id会自动回填
        }
    
    }

#### 3、更新操作 ####

//测试更新功能
        @Test
        public void testUpdate(){
        
            User user = new User();
            //通过调节自动拼接动态sql
            user.setId(6L);
            user.setName("kkkk");
            user.setAge(999);
            //updateById 其参数是一个对象
            int i = userMapper.updateById(user);
            System.out.println(i);
        }

#### 4、自动填充 ####

==创建时间、修改时间！这些操作一遍都是自动化完成的，不用手动更新！

gmt\_create:创建时间，gmt\_modified：修改时间机会所有的表都需要配置，而且需要自动化

> 方式一：数据库级别（工作中不建议使用）

1、在表中新增字段 create\_time,update\_time

![img][img 7]

2、再次测试插入方法

实体类中增加字段

private Date createTime;
    private Date updateTime;

测试

//测试更新功能
    @Test
    public void testUpdate(){
        
        User user = new User();
        //通过调节自动拼接动态sql
        user.setId(6L);
        user.setName("kkkk");
        user.setAge(9999);
        //updateById 其参数是一个对象
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

![img][img 8]

> 方式二：代码级别

1、删除数据库的默认值、更新操作！

![img][img 9]

2、实体类的字段属性上需要增加注解

//记住用util包下的Date!!
    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

3、编写处理器来处理这个注解

package com.kk.handler;
    
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.ibatis.reflection.MetaObject;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    
    
    @Slf4j
    @Component  //一定要注意把处理器加到IOC容器中
    public class MyMetaObjectHandler implements MetaObjectHandler {
        
        //插入时候的填充策略
        @Override
        public void insertFill(MetaObject metaObject) {
        
            log.info("start insert fill ... ...");
            this.setFieldValByName("createTime",new Date(),metaObject);
            this.setFieldValByName("updateTime",new Date(),metaObject);
        }
    
        //更新时候的填充策略
        @Override
        public void updateFill(MetaObject metaObject) {
        
            log.info("start insert fill ... ...");
            this.setFieldValByName("updateTime",new Date(),metaObject);
        }
    }

测试

//测试插入功能
        @Test
        public void testInsert(){
        
    
            User user = new User();
    //        user.setId(6L);
            user.setName("qq");
            user.setAge(17);
            user.setEmail("30666@qq.com");
    
            //这里需要一个User对象，所以需要new一个User
            int result = userMapper.insert(user);  //帮我们自动生成id
            System.out.println(result);//受影响的函行数
            System.out.println(user);//发现，id会自动回填
        }
    
    
        //测试更新功能
        @Test
        public void testUpdate(){
        
            User user = new User();
            //通过调节自动拼接动态sql
            user.setId(1442085733983649796L);
            user.setName("kkkk");
            user.setAge(99999);
            //updateById 其参数是一个对象
            int i = userMapper.updateById(user);
            System.out.println(i);
        }

![img][img 10]

#### 5、乐观锁 ####

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

乐观锁实现方式:

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

l乐观锁：1、先查询，获取版本号 version=1
    --- A线程
    update user set name="kk",version=version+1
    where id=2 and version=1
    
    --- B 线程 抢先完成 ，这个时候 version=2 会导致A修改失败
    update user set name="kk",version=version+1
    where id=2 and version=1

> 测试MP的乐观锁插件

1、给数据库中增加version字段

![img][img 11]

2、实体类增加对应的字段

@Version  //代表乐观锁的注解
    private Integer version;

3、注册组件

package com.kk.config;
    
    
    import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
    import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    //扫描我们的mapper文件夹
    @MapperScan("com.kk.mapper")
    @EnableTransactionManagement
    @Configuration  //配置类 需要添加Configuration
    public class MybatisConfig {
        
    
        //注册乐观锁插件
    
            /**
             * 旧版
             */
    
           /* @Bean
            public OptimisticLockerInterceptor optimisticLockerInterceptor() {
                return new OptimisticLockerInterceptor();
            }*/
    
            /**
             * 新版
             */
            @Bean
            public MybatisPlusInterceptor mybatisPlusInterceptor() {
        
                MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
                mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
                return mybatisPlusInterceptor;
            }
    }

4、测试

//    测试乐观锁  ---成功
        @Test
        public void testmybatisPlusInterceptor(){
        
            //1.查询用户信息
            User user = userMapper.selectById(1L);
            //2.修改用户信息
            user.setName("kk");
            user.setEmail("0000@qq.com");
            //3.执行更新操作
            userMapper.updateById(user);
        }
    
    
    //    测试乐观锁  ---失败  多线程下
    
    @Test
    public void testmybatisPlusInterceptor2(){
        
    
            //线程1
        User user = userMapper.selectById(1L);
        user.setName("kk111");
        user.setEmail("0000@qq.com");
    
        //模拟另外一个线程执行了插队操作
        User user2 = userMapper.selectById(1L);
        user2.setName("kk222");
        user2.setEmail("0000@qq.com");
        userMapper.updateById(user2);
    
    
        //可以使用自旋锁来尝试多次提交
        userMapper.updateById(user);  //如果没有乐观锁就会覆盖插队线程的值
    }

### 7、查询操作 ###

//测试查询  (测试批量查询)
        @Test
        public void  testSelectById(){
        
    //        User user = userMapper.selectById(1L);
            List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2,3));
            users.forEach(System.out::println);
        }
    
        //条件查询  map操作
    
        @Test
        public void testSelectByBatchIds(){
        
            HashMap<String, Object> map = new HashMap<>();
            //自定义要查询到的条件
            map.put("name","kk");
            map.put("age","17");
    
            List<User> users = userMapper.selectByMap(map);
            users.forEach(System.out::println);
        }

### 8、分页查询 ###

MbatisPlus内置了分页插件

1、配置拦截器组件

// 旧版
        @Bean
        public PaginationInterceptor paginationInterceptor() {
        
            PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
            // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
            // paginationInterceptor.setOverflow(false);
            // 设置最大单页限制数量，默认 500 条，-1 不受限制
            // paginationInterceptor.setLimit(500);
            // 开启 count 的 join 优化,只针对部分 left join
            paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
            return paginationInterceptor;
        }
        
        // 最新版
        @Bean
        public MybatisPlusInterceptor mybatisPlusInterceptor() {
        
            MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
            interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
            return interceptor;
        }

2、直接使用Page对象即可

//测试分页查询
    @Test
    public void testPage(){
        
        //参数一 当前页
        //参数二 页面大小
        Page<User> page = new Page<>(1,5);
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
    }

### 9、删除操作 ###

//测试删除
        @Test
        public void testDeleteById(){
        
            userMapper.deleteById(1442085733983649796L);
        }
    
        //批量通过删除
        @Test
        public  void testDeleteBatchId(){
        
            userMapper.deleteBatchIds(Arrays.asList(1442085733983649794L,1442085733983649795L));
        }
    
        //通过map删除
        @Test
        public void testDeleteMap(){
        
           HashMap<String,Object> map = new HashMap<>();
           map.put("name","Tom");
            userMapper.deleteByMap(map);
        }

### 9、逻辑删除 ###

> 物理删除:从数据库中直接移除
> 
> 逻辑删除: 在数据库中没有被移除,而是通过一个变量来让他失效! deleted=0=>deleted=1

管理员可以查看被删除的记录!防止数据的丢失,类似于回收站!

测试:

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

![img][img 12]

2.实体类中增加属性

//逻辑删除
    @TableLogic
    private Integer deleted;

3.配置（现在新版的Mybatis不用下面的这个方法）

config

//注册逻辑删除
    @Bean
    public ISqlInjector sqlInjector(){
        
        return new LogicSqlInjector();
    }

application.properties

# 配置逻辑删除组件
    mybatis-plus.global-config.db-config.logic-delete-value=1
    mybatis-plus.global-config.db-config.logic-not-delete-value=0

其实执行的时update

![img][img 13]

### 10.性能分析插件 ###

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

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

1、导入插件

/**
         * SQL执行效率插件
         */
        @Bean
        @Profile({
        "dev","test"})// 设置 dev test 环境开启，保证我们的效率
        public PerformanceInterceptor performanceInterceptor() {
        
            PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
            performanceInterceptor.setMaxTime(100); //ms 设置sql执行的最大时间，如果超过了则不执行
            performanceInterceptor.setFormat(true);
            return performanceInterceptor;
        }

2、配置

#  设置开发环境
    spring.profiles.active=dev

3、测试

### 11、条件查询器Wrapper ###

一些复杂的sql就可以用wrapper代替

![img][img 14]

#### 1、测试一： ####

package com.kk;
    
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.kk.mapper.UserMapper;
    import com.kk.pojo.User;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.util.List;
    
    @SpringBootTest
    public class WrapperTest {
        
    
        //继承了BaseMapper  BaseMapper所有的方法都可以被使用
        @Autowired
        private UserMapper userMapper;
    
    
        @Test
        void contextLoads() {
        
          //查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于18岁
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper
                    .isNotNull("name")
                    .isNotNull("email")
                    .ge("age",18);
            userMapper.selectList(wrapper).forEach(System.out::println);
        }
    }

#### 2、测试二 ####

@Test
     void test2(){
        
        //查询名字等于zz的
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","小白");
        User user = userMapper.selectOne(wrapper);  //查询一个数据
        // 如果有出现多个数据结果，使用list或者Map
        System.out.println(user);
    }

注意：deleted=1的是查不出来的

![img][img 15]

#### 3、测试三 ####

@Test
    void test3(){
        
        //查询年龄在 18-35之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,35);
    
        Long count = userMapper.selectCount(wrapper);//查询结果数
        System.out.println(count);
    }

![img][img 16]

#### 4、测试四 ####

//模糊查询
    @Test
    void test4(){
        
        //查询年龄在 18-35之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //左和右   e%（在右）   %e（在左）
        wrapper
                .notLike("name","e")
                .likeRight("email","t");
    
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

![img][img 17]

#### 5、测试五 ####

@Test
    void test5(){
        
    
        QueryWrapper<User> wrapper = new QueryWrapper<>();
       //id 在子查询中查出来
        wrapper.inSql("id","select id from user where id <3");
    
    
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

![img][img 18]

#### 6、测试六 ####

//查询排序
    @Test
    void test6(){
        
    
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //通过id进行排序
        wrapper.orderByDesc("id");
        //Desc 降序
        //Asc  升序
    
    
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

![img][img 19]

### 12、代码生成器 ###

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

导入所有的依赖

<dependencies>
    
    
        
    
    <dependency>
        <groupId>org.apache.velocity</groupId>
        <artifactId>velocity-engine-core</artifactId>
        <version>2.3</version>
    </dependency>
        
        
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>
    
    
    
    
    
    
        
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
    
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        
        
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
    
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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>
    </dependencies>

注意：如果引擎包和这个lang3的依赖包导入不了，需要在该项目建立lib文件夹，并将这两个包导入，并且添加为库

![img][img 20]

测试：

package com.kk;
    
    
    import com.baomidou.mybatisplus.annotation.DbType;
    import com.baomidou.mybatisplus.annotation.FieldFill;
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.generator.AutoGenerator;
    import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
    import com.baomidou.mybatisplus.generator.config.GlobalConfig;
    import com.baomidou.mybatisplus.generator.config.PackageConfig;
    import com.baomidou.mybatisplus.generator.config.StrategyConfig;
    import com.baomidou.mybatisplus.generator.config.po.TableFill;
    import com.baomidou.mybatisplus.generator.config.rules.DateType;
    import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    
    
    import java.util.ArrayList;
    
    //代码自动生成器
    public class KkCode {
        
        public static void main(String[] args) {
        
            // 需要构建一个 代码自动生成器 对象
            AutoGenerator mpg = new AutoGenerator();
    
            // 配置策略
            // 1、全局配置
            GlobalConfig gc = new GlobalConfig();
            String projectPath = System.getProperty("user.dir");
            gc.setOutputDir(projectPath+"/src/main/java");
            gc.setAuthor("kk"); gc.setOpen(false);
            gc.setFileOverride(false);
    
            // 是否覆盖
            gc.setServiceName("%sService");
    
            // 去Service的I前缀
            gc.setIdType(IdType.ID_WORKER);
            gc.setDateType(DateType.ONLY_DATE);
            gc.setSwagger2(true);
            mpg.setGlobalConfig(gc);
    
            //2、设置数据源
            DataSourceConfig dsc = new DataSourceConfig();
            dsc.setUrl("jdbc:mysql://localhost:3306/mybatis-plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            dsc.setUsername("root");
            dsc.setPassword("123456");
            dsc.setDbType(DbType.MYSQL); mpg.setDataSource(dsc);
    
            //3、包的配置
            PackageConfig pc = new PackageConfig();
            //只需要改实体类名字 和包名 还有 数据库配置即可
            pc.setModuleName("blog");
            pc.setParent("com.kk");
            pc.setEntity("entity");
            pc.setMapper("mapper");
            pc.setService("service");
            pc.setController("controller");
            mpg.setPackageInfo(pc);
    
            //4、策略配置
            StrategyConfig strategy = new StrategyConfig();
            strategy.setInclude("user");
    
            // 设置要映射的表名
            strategy.setNaming(NamingStrategy.underline_to_camel);
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);
            strategy.setEntityLombokModel(true);
    
            // 自动lombok；
            strategy.setLogicDeleteFieldName("deleted");
    
            // 自动填充配置
            TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
            TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
            ArrayList<TableFill> tableFills = new ArrayList<>();
    
            tableFills.add(gmtCreate); tableFills.add(gmtModified);
            strategy.setTableFillList(tableFills);
    
            // 乐观锁
            strategy.setVersionFieldName("version");
            strategy.setRestControllerStyle(true);
            strategy.setControllerMappingHyphenStyle(true);
    
            // localhost:8080/hello_id_2
            mpg.setStrategy(strategy);
            mpg.execute(); //执行
        }
    
    }

测试成功！

troller");  
mpg.setPackageInfo(pc);

//4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");
    
        // 设置要映射的表名
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);
    
        // 自动lombok；
        strategy.setLogicDeleteFieldName("deleted");
    
        // 自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
    
        tableFills.add(gmtCreate); tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);
    
        // 乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
    
        // localhost:8080/hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }

==测试成功！==
    
    ![img](https://img-blog.csdnimg.cn/img_convert/1ff6bf8070dab21b36430158813af540.png)

[img]: https://img-blog.csdnimg.cn/img_convert/aaa0072880678f9a26a47f125caccc8d.png
[MyBatis-Plus _opens new window]: https://github.com/baomidou/mybatis-plus
[MyBatis _opens new window]: https://www.mybatis.org/mybatis-3/
[img 1]: https://img-blog.csdnimg.cn/img_convert/826d89a6763ffcfd623ed8298a994f72.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/f7727ac5504f4f3cb12ab212aba3e23f.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/37ad523a5477c6f628c83c5a02c9dda4.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/416092fe777f5aa18e47dbdec0c0fc2a.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/4ec1a14bb1fee53c7c06964e3d1675e4.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/03ce4111bdeae709c7c8c807cf29b73e.png
[img 7]: https://img-blog.csdnimg.cn/img_convert/d703c122b99c7d2a92308702cf5480fe.png
[img 8]: https://img-blog.csdnimg.cn/img_convert/77174d2b4d394d564a7d965e0705357c.png
[img 9]: https://img-blog.csdnimg.cn/img_convert/5622e9ad8560b7009f1cac547c118f4a.png
[img 10]: https://img-blog.csdnimg.cn/img_convert/2d0aeba0c639d7239a5cbefd99c401d7.png
[img 11]: https://img-blog.csdnimg.cn/img_convert/15afcb27b1744808462529c1239ec89d.png
[img 12]: https://img-blog.csdnimg.cn/img_convert/35f50a8d361204e566a6486c1e73319c.png
[img 13]: https://img-blog.csdnimg.cn/img_convert/8937e8ee6db922a0d4f3d0e7fbafdf04.png
[img 14]: https://img-blog.csdnimg.cn/img_convert/d42d7fc73695cb9c3a90a8797300deb9.png
[img 15]: https://img-blog.csdnimg.cn/img_convert/3ed881f7118dc1130c0bffc441309e9b.png
[img 16]: https://img-blog.csdnimg.cn/img_convert/184a5ac5a967c8e0485b8219c7137484.png
[img 17]: https://img-blog.csdnimg.cn/img_convert/4b7004fdb23110a595ec65ad41babf38.png
[img 18]: https://img-blog.csdnimg.cn/img_convert/48c0016c2b31a36c5bb775663720b5ae.png
[img 19]: https://img-blog.csdnimg.cn/img_convert/b86b8c90ec72a17ff2f065de84c92ceb.png
[img 20]: https://img-blog.csdnimg.cn/img_convert/3d3a80e96e52c8de7aae1cd97a3a8875.png