快速上手MyBatis Plus：简化CRUD操作，提高开发效率！

「爱情、让人受尽委屈。」 2024-04-17 06:46 127阅读 0赞

#### MyBatisPlus ####

*   *  1，MyBatisPlus入门案例与简介
     *   *  1.1 入门案例
         *   *  步骤1:创建数据库及表
             *  步骤2:创建SpringBoot工程
             *  步骤3:勾选配置使用技术
             *  步骤4:pom.xml补全依赖
             *  步骤5:添加MP的相关配置信息
             *  步骤6:根据数据库表创建实体类
             *  步骤7:创建Dao接口
             *  步骤8:编写引导类
             *  步骤9:编写测试类
         *  1.2 MybatisPlus简介
     *  2，标准数据层开发
     *   *  2.1 标准CRUD使用
         *  2.2 新增
         *  2.3 删除
         *  2.4 修改
         *  2.5 根据ID查询
         *  2.6 查询所有
         *  2.7 Lombok
         *   *  概念
             *  使用步骤
             *   *  步骤1:添加lombok依赖
                 *  步骤2:安装Lombok的插件
                 *  步骤3:模型类上添加注解
         *  2.8 分页功能
         *   *  步骤1:调用方法传入参数获取返回值
             *  步骤2:设置分页拦截器
             *  步骤3:运行测试程序
     *  3，DQL编程控制
     *   *  3.1 条件查询
         *   *  3.1.1 条件查询的类
             *  3.1.2 环境构建
             *  3.1.3 构建条件查询
             *  3.1.4 多条件构建
             *  3.1.5 null判定
         *  3.2 查询投影
         *   *  3.2.1 查询指定字段
             *  3.2.2 聚合查询
             *  3.2.3 分组查询
         *  3.3 查询条件
         *   *  3.3.1 等值查询
             *  3.3.2 范围查询
             *  3.3.3 模糊查询
             *  3.3.4 排序查询
         *  3.4 映射匹配兼容性
         *   *  问题1:表字段与编码属性设计不同步
             *  问题2:编码中添加了数据库中未定义的属性
             *  问题3：采用默认查询开放了更多的字段查看权限
             *  知识点1：@TableField
             *  问题4:表名与编码开发设计不同步
             *  知识点2：@TableName

### 1，MyBatisPlus入门案例与简介 ###

#### 1.1 入门案例 ####

*  MybatisPlus(简称MP)是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提供效率。

##### 步骤1:创建数据库及表 #####

create database if not exists mybatisplus_db character set utf8;
    use mybatisplus_db;
    CREATE TABLE user (
        id bigint(20) primary key auto_increment,
        name varchar(32) not null,
        password  varchar(32) not null,
        age int(3) not null ,
        tel varchar(32) not null
    );
    insert into user values(1,'Tom','tom',3,'18866668888');
    insert into.........

##### 步骤2:创建SpringBoot工程 #####

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

##### 步骤3:勾选配置使用技术 #####

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

**说明:**

*  由于MP并未被收录到idea的系统内置配置，无法直接选择加入，需要手动在pom.xml中配置添加

##### 步骤4:pom.xml补全依赖 #####

<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.1</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>

**说明:**

*  druid数据源可以加也可以不加，SpringBoot有内置的数据源，可以配置成使用Druid数据源
 *  从MP的依赖关系可以看出，通过依赖传递已经将MyBatis与MyBatis整合Spring的jar包导入，我们不需要额外在添加MyBatis的相关jar包  
    ![在这里插入图片描述][63fa84789f02465d9536973e6e34c856.png]

##### 步骤5:添加MP的相关配置信息 #####

resources默认生成的是properties配置文件，可以将其替换成yml文件，并在文件中配置数据库连接的相关信息:`application.yml`

spring:
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC 
        username: root
        password: root

**说明**:serverTimezone是用来设置时区，UTC是标准时区，和咱们的时间差8小时，所以可以将其修改为`Asia/Shanghai`

##### 步骤6:根据数据库表创建实体类 #####

public class User {
           
        private Long id;
        private String name;
        private String password;
        private Integer age;
        private String tel;
        //setter...getter...toString方法略
    }

##### 步骤7:创建Dao接口 #####

@Mapper
    public interface UserDao extends BaseMapper<User>{
        
    }

##### 步骤8:编写引导类 #####

@SpringBootApplication
    //@MapperScan("com.itheima.dao")
    public class Mybatisplus01QuickstartApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(Mybatisplus01QuickstartApplication.class, args);
        }
    
    }

**说明**:Dao接口要想被容器扫描到，有两种解决方案:

*  方案一:在Dao接口上添加`@Mapper`注解，并且确保Dao处在引导类所在包或其子包中
    
     *  该方案的缺点是需要在每一Dao接口中添加注解
 *  方案二:在引导类上添加`@MapperScan`注解，其属性为所要扫描的Dao所在包
    
     *  该方案的好处是只需要写一次，则指定包下的所有Dao接口都能被扫描到，`@Mapper`就可以不写。

##### 步骤9:编写测试类 #####

@SpringBootTest
    class MpDemoApplicationTests {
        
    
    	@Autowired
    	private UserDao userDao;
    	@Test
    	public void testGetAll() {
        
    		List<User> userList = userDao.selectList(null);
    		System.out.println(userList);
    	}
    }

**说明:**

userDao注入的时候下面有红线提示的原因是什么?

*  UserDao是一个接口，不能实例化对象。
 *  只有在服务器启动IOC容器初始化后，由框架创建DAO接口的代理对象来注入。
 *  现在服务器并未启动，所以代理对象也未创建，IDEA查找不到对应的对象注入，所以提示报红。
 *  一旦服务启动，就能注入其代理对象，所以该错误提示不影响正常运行。

查看运行结果:  
![在这里插入图片描述][b29f773ec268474a810cd26602c9f04c.png]  
跟之前整合MyBatis相比，你会发现我们不需要在DAO接口中编写方法和SQL语句了，只需要继承`BaseMapper`接口即可。整体来说简化很多。

#### 1.2 MybatisPlus简介 ####

MyBatisPlus（简称MP）是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提高效率。

通过刚才的案例，相信大家能够体会简化开发和提高效率这两个方面的优点。

MyBatisPlus的官网为:`https://mp.baomidou.com/`  
![在这里插入图片描述][4bb8cd26b7624784a713a26d80b2bc60.png]

从这张图中我们可以看出MP旨在成为MyBatis的最好搭档，而不是替换MyBatis,所以可以理解为MP是MyBatis的一套增强工具，它是在MyBatis的基础上进行开发的，我们虽然使用MP但是底层依然是MyBatis的东西，也就是说我们也可以在MP中写MyBatis的内容。

对于MP的学习，大家可以参考着官方文档来进行学习，里面都有详细的代码案例。

MP的特性:

*  无侵入：只做增强不做改变，不会对现有工程产生影响
 *  强大的 CRUD 操作：内置通用 Mapper，少量配置即可实现单表CRUD 操作
 *  支持 Lambda：编写查询条件无需担心字段写错
 *  支持主键自动生成
 *  内置分页插件
 *  ……

### 2，标准数据层开发 ###

#### 2.1 标准CRUD使用 ####

对于标准的CRUD功能都有哪些以及MP都提供了哪些方法可以使用呢?

我们先来看张图:  
![在这里插入图片描述][5502e36d16c94fea883d6739fbf45df8.png]

#### 2.2 新增 ####

在进行新增之前，我们可以分析下新增的方法:

int insert (T t)

*  T:泛型，新增用来保存新增数据
 *  int:返回值，新增成功后返回1，没有新增成功返回的是0

在测试类中进行新增操作:

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
    
        @Test
        void testSave() {
        
            User user = new User();
            user.setName("我是程序员");
            user.setPassword("123");
            user.setAge(12);
            user.setTel("4006184000");
            userDao.insert(user);
        }
    }

执行测试后，数据库表中就会添加一条数据。（其中，会发现id是很长的一串数字，并不是自动递增的。）

#### 2.3 删除 ####

在进行删除之前，我们可以分析下删除的方法:

int deleteById (Serializable id)

*  Serializable：参数类型
    
     *  思考:参数类型为什么是一个序列化类?  
        ![在这里插入图片描述][fcf77c9c04bf46ef99443892e9df754e.png]  
        从这张图可以看出，
        
         *  String和Number是Serializable的子类，
         *  Number又是Float,Double,Integer等类的父类，
         *  能作为主键的数据类型都已经是Serializable的子类，
         *  MP使用Serializable作为参数类型，就好比我们可以用Object接收任何数据类型一样。
 *  int:返回值类型，数据删除成功返回1，未删除数据返回0。

在测试类中进行删除操作:

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
    
        @Test
        void testDelete() {
        
            userDao.deleteById(1401856123725713409L);
        }
    }

#### 2.4 修改 ####

在进行修改之前，我们可以分析下修改的方法:

int updateById(T t);

*  T:泛型，需要修改的数据内容，注意因为是根据ID进行修改，所以传入的对象中需要有ID属性值
 *  int:返回值，修改成功后返回1，未修改数据返回0

在测试类中进行修改操作:

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
    
        @Test
        void testUpdate() {
        
            User user = new User();
            user.setId(1L);
            user.setName("Tom888");
            user.setPassword("tom888");
            userDao.updateById(user);
        }
    }

**说明**:修改的时候，只修改实体对象中有值的字段。

#### 2.5 根据ID查询 ####

在进行根据ID查询之前，我们可以分析下根据ID查询的方法:

T selectById (Serializable id)

*  Serializable：参数类型,主键ID的值
 *  T:根据ID查询只会返回一条数据

在测试类中进行根据id查询操作:

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetById() {
        
            User user = userDao.selectById(2L);
            System.out.println(user);
        }
    }

#### 2.6 查询所有 ####

在进行查询所有之前，我们可以分析下查询所有的方法:

List<T> selectList(Wrapper<T> queryWrapper)

*  Wrapper：用来构建条件查询的条件，目前我们没有可直接传为Null。
 *  List:因为查询的是所有，所以返回的数据是一个集合。

在测试类中进行查询所有操作:

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll() {
        
            List<User> userList = userDao.selectList(null);
            System.out.println(userList);
        }
    }

#### 2.7 Lombok ####

代码写到这，我们会发现DAO接口类的编写现在变成最简单的了，里面什么都不用写。反过来看看模型类的编写都需要哪些内容:

*  私有属性
 *  setter…getter…方法
 *  toString方法
 *  构造函数

虽然这些内容不难，同时也都是通过IDEA工具生成的，但是过程还是必须得走一遍，那么对于模型类的编写有没有什么优化方法?

##### 概念 #####

*  Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发。

##### 使用步骤 #####

###### 步骤1:添加lombok依赖 ######

<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        
    </dependency>

**注意**：版本可以不用写，因为SpringBoot中已经管理了lombok的版本。

###### 步骤2:安装Lombok的插件 ######

新版本IDEA已经内置了该插件，如果删除setter和getter方法程序有报红，则需要安装插件  
![在这里插入图片描述][712ad3b90c104fb0b007ecc1b61e3d71.png]

如果在IDEA中找不到lombok插件，可以访问如下网站

`https://plugins.jetbrains.com/plugin/6317-lombok/versions`

根据自己IDEA的版本下载对应的lombok插件，下载成功后，在IDEA中采用离线安装的方式进行安装。  
![在这里插入图片描述][ab01e9a10ef14ca18eb00b8d5bf2e74c.png]

###### 步骤3:模型类上添加注解 ######

Lombok常见的注解有:

*  @Setter:为模型类的属性提供setter方法
 *  @Getter:为模型类的属性提供getter方法
 *  @ToString:为模型类的属性提供toString方法
 *  @EqualsAndHashCode:为模型类的属性提供equals和hashcode方法
 *  @Data:是个组合注解，包含上面的注解的功能
 *  @NoArgsConstructor:提供一个无参构造函数
 *  @AllArgsConstructor:提供一个包含所有参数的构造函数

Lombok的注解还有很多，上面标红的三个是比较常用的。

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
        private Long id;
        private String name;
        private String password;
        private Integer age;
        private String tel;
    }

**说明:**

Lombok只是简化模型类的编写，我们之前的方法也能用，比如有人会问:我如果只想要有name和password的构造函数，该如何编写?

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
        private Long id;
        private String name;
        private String password;
        private Integer age;
        private String tel;
    
        public User(String name, String password) {
        
            this.name = name;
            this.password = password;
        }
    }

这种方式是被允许的。

#### 2.8 分页功能 ####

基础的增删改查就已经学习完了，刚才我们在分析基础开发的时候，有一个分页功能还没有实现。

分页查询使用的方法是:

IPage<T> selectPage(IPage<T> page, Wrapper<T> queryWrapper)

*  IPage:用来构建分页查询条件。
 *  Wrapper：用来构建条件查询的条件，目前我们没有可直接传为Null。
 *  IPage:返回值，你会发现构建分页条件和方法的返回值都是IPage。

IPage是一个接口，我们需要找到它的实现类来构建它，具体的实现类，可以进入到IPage类中按ctrl+h,会找到其有一个实现类为`Page`。

##### 步骤1:调用方法传入参数获取返回值 #####

@SpringBootTest
    class Mybatisplus01QuickstartApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        //分页查询
        @Test
        void testSelectPage(){
        
            //1 创建IPage分页对象,设置分页参数,1为当前页码，3为每页显示的记录数
            IPage<User> page=new Page<>(1,3);
            //2 执行分页查询
            userDao.selectPage(page,null);
            //3 获取分页结果
            System.out.println("当前页码值："+page.getCurrent());
            System.out.println("每页显示数："+page.getSize());
            System.out.println("一共多少页："+page.getPages());
            System.out.println("一共多少条数据："+page.getTotal());
            System.out.println("数据："+page.getRecords());
        }
    }

##### 步骤2:设置分页拦截器 #####

这个拦截器MP已经为我们提供好了，我们只需要将其配置成Spring管理的bean对象即可。

@Configuration
    public class MybatisPlusConfig {
        
        
        @Bean
        public MybatisPlusInterceptor mybatisPlusInterceptor(){
        
            //1 创建MybatisPlusInterceptor拦截器对象
            MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
            //2 添加分页拦截器
            mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
            return mpInterceptor;
        }
    }

**说明**:上面的代码记不住咋办呢?

这些内容在MP的官方文档中有详细的说明，我们可以查看官方文档类配置  
![在这里插入图片描述][8e2d9c9fd2ed4951b4f7a44fc2240ad4.png]

##### 步骤3:运行测试程序 #####

![在这里插入图片描述][157cf9132bd64e4cbfb422d4c1fc8a54.png]  
如果想查看MP执行的SQL语句，可以修改application.yml配置文件，

mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印SQL日志到控制台

打开日志后，就可以在控制台打印出对应的SQL语句，开启日志功能性能就会受到影响，调试完后记得关闭。  
![在这里插入图片描述][eb023b8954854bb78b7a2d4b17357b5c.png]

### 3，DQL编程控制 ###

#### 3.1 条件查询 ####

##### 3.1.1 条件查询的类 #####

*  MyBatisPlus将书写复杂的SQL查询条件进行了封装，使用编程的形式完成查询条件的组合。

这个我们在前面都有见过，比如查询所有和分页查询的时候，都有看到过一个`Wrapper`类，这个类就是用来构建查询条件的，如下图所示:  
![在这里插入图片描述][0f8aa7b50fe84b91ab5b208024b89a06.png]  
那么条件查询如何使用Wrapper来构建呢?

##### 3.1.2 环境构建 #####

在构建条件查询之前，我们先来准备下环境

*  创建一个SpringBoot项目，结构为:  
    ![在这里插入图片描述][f278397f5bee40a6a1fd4c59edb1356b.png]
 *  测试的时候，控制台打印的日志比较多，速度有点慢而且不利于查看运行结果，所以接下来我们把这个日志处理下:
    
     *  取消初始化spring日志打印，resources目录下添加logback.xml，名称固定，内容如下:
        
            <?xml version="1.0" encoding="UTF-8"?>
            <configuration>
            </configuration>
        
        **说明**:logback.xml的配置内容，如果有兴趣可以自行百度查询。
     *  取消MybatisPlus启动banner图标  
        ![在这里插入图片描述][5c99af3bc9bc4bd1a3d47c61511ab33a.png] application.yml添加如下内容:
        
            # mybatis-plus日志控制台输出
            mybatis-plus:
              configuration:
                log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
              global-config:
                banner: off # 关闭mybatisplus启动图标
     *  取消SpringBoot的log打印  
        ![在这里插入图片描述][2aee5a284f234868846f73552c21d24f.png]
        
        application.yml添加如下内容:
        
            spring:
              main:
                banner-mode: off # 关闭SpringBoot启动图标(banner)

##### 3.1.3 构建条件查询 #####

在进行查询的时候，我们的入口是在Wrapper这个类上，因为它是一个接口，所以我们需要去找它对应的实现类，关于实现类也有很多，说明我们有多种构建查询条件对象的方式，  
![在这里插入图片描述][1d9525cbe1b84ebeb890468f5b2a0e12.png]

1.  先来看第一种:QueryWrapper

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            QueryWrapper qw = new QueryWrapper();
            qw.lt("age",18);
            List<User> userList = userDao.selectList(qw);
            System.out.println(userList);
        }
    }

*  lt: 小于(<) ,最终的sql语句为
    
        SELECT id,name,password,age,tel FROM user WHERE (age < ?)

第一种方式介绍完后，有个小问题就是在写条件的时候，容易出错，比如age写错，就会导致查询不成功

1.  接着来看第二种:QueryWrapper的基础上使用lambda

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            QueryWrapper<User> qw = new QueryWrapper<User>();
            qw.lambda().lt(User::getAge, 10);//添加条件
            List<User> userList = userDao.selectList(qw);
            System.out.println(userList);
        }
    }

*  User::getAget,为lambda表达式中的，类名::方法名，最终的sql语句为:

SELECT id,name,password,age,tel FROM user WHERE (age < ?)

**注意**:构建LambdaQueryWrapper的时候泛型不能省。

此时我们再次编写条件的时候，就不会存在写错名称的情况，但是qw后面多了一层lambda()调用。

1.  接着来看第三种:LambdaQueryWrapper

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.lt(User::getAge, 10);
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

这种方式就解决了上一种方式所存在的问题。

##### 3.1.4 多条件构建 #####

学完了三种构建查询对象的方式，每一种都有自己的特点，所以用哪一种都行，刚才都是一个条件，那如果有多个条件该如何构建呢?

> 需求:查询数据库表中，年龄在10岁到30岁之间的用户信息

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.lt(User::getAge, 30);
            lqw.gt(User::getAge, 10);
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  gt：大于(>),最终的SQL语句为
    
        SELECT id,name,password,age,tel FROM user WHERE (age < ? AND age > ?)
 *  构建多条件的时候，可以支持链式编程
    
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.lt(User::getAge, 30).gt(User::getAge, 10);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);

> 需求:查询数据库表中，年龄小于10或年龄大于30的数据

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  or()就相当于我们sql语句中的`or`关键字,不加默认是`and`，最终的sql语句为:
    
        SELECT id,name,password,age,tel FROM user WHERE (age < ? OR age > ?)

##### 3.1.5 null判定 #####

先来看一张图，  
![在这里插入图片描述][cf592cb5d24f4486b04820f8d098dc85.png]

*  我们在做条件查询的时候，一般会有很多条件可以供用户进行选择查询。
 *  这些条件用户可以选择使用也可以选择不使用，比如我要查询价格在8000以上的手机。
 *  在输入条件的时候，价格有一个区间范围，按照需求只需要在第一个价格输入框中输入8000。
 *  后台在做价格查询的时候，一般会让 price>值1 and price <值2。
 *  因为前端没有输入值2，所以如果不处理的话，就会出现 price>8000 and price < null问题。
 *  这个时候查询的结果就会出问题，具体该如何解决?  
    ![在这里插入图片描述][347a28aace45451f86ded689126e13f0.png]

> 需求:查询数据库表中，根据输入年龄范围来查询符合条件的记录
> 
> 用户在输入值的时候，
> 
> 如果只输入第一个框，说明要查询大于该年龄的用户
> 
> 如果只输入第二个框，说明要查询小于该年龄的用户
> 
> 如果两个框都输入了，说明要查询年龄在两个范围之间的用户

思考第一个问题：后台如果想接收前端的两个数据，该如何接收?

我们可以使用两个简单数据类型，也可以使用一个模型类，但是User类中目前只有一个age属性,如:

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

使用一个age属性，如何去接收页面上的两个值呢?这个时候我们有两个解决方案

方案一:添加属性age2,这种做法可以但是会影响到原模型类的属性内容

@Data
    public class User {
        
        private Long id;
        private String name;
        private String password;
        private Integer age;
        private String tel;
        private Integer age2;
    }

方案二:新建一个模型类,让其继承User类，并在其中添加age2属性，UserQuery在拥有User属性后同时添加了age2属性。

@Data
    public class User {
        
        private Long id;
        private String name;
        private String password;
        private Integer age;
        private String tel;
    }
    
    @Data
    public class UserQuery extends User {
        
        private Integer age2;
    }

环境准备好后，我们来实现下刚才的需求：

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            //模拟页面传递过来的查询数据
            UserQuery uq = new UserQuery();
            uq.setAge(10);
            uq.setAge2(30);
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            if(null != uq.getAge2()){
        
                lqw.lt(User::getAge, uq.getAge2());
            }
            if( null != uq.getAge()) {
        
                lqw.gt(User::getAge, uq.getAge());
            }
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

上面的写法可以完成条件为非空的判断，但是问题很明显，如果条件多的话，每个条件都需要判断，代码量就比较大，来看MP给我们提供的简化方式：

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            //模拟页面传递过来的查询数据
            UserQuery uq = new UserQuery();
            uq.setAge(10);
            uq.setAge2(30);
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.lt(null!=uq.getAge2(),User::getAge, uq.getAge2());
            lqw.gt(null!=uq.getAge(),User::getAge, uq.getAge());
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  lt()方法  
    ![在这里插入图片描述][edbb9d325e8c48c18f612cf633448189.png]  
    condition为boolean类型，返回true，则添加条件，返回false则不添加条件

#### 3.2 查询投影 ####

##### 3.2.1 查询指定字段 #####

目前我们在查询数据的时候，什么都没有做默认就是查询表中所有字段的内容，我们所说的查询投影即不查询所有字段，只查询出指定内容的数据。

具体如何来实现?

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.select(User::getId,User::getName,User::getAge);
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  select(…)方法用来设置查询的字段列，可以设置多个，最终的sql语句为:
    
        SELECT id,name,age FROM user
 *  如果使用的不是lambda，就需要手动指定字段
    
        @SpringBootTest
        class Mybatisplus02DqlApplicationTests {
              
        
            @Autowired
            private UserDao userDao;
            
            @Test
            void testGetAll(){
              
                QueryWrapper<User> lqw = new QueryWrapper<User>();
                lqw.select("id","name","age","tel");
                List<User> userList = userDao.selectList(lqw);
                System.out.println(userList);
            }
        }
    
     *  最终的sql语句为:SELECT id,name,age,tel FROM user

##### 3.2.2 聚合查询 #####

> 需求:聚合函数查询，完成count、max、min、avg、sum的使用
> 
> count:总记录数
> 
> max:最大值
> 
> min:最小值
> 
> avg:平均值
> 
> sum:求和

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            QueryWrapper<User> lqw = new QueryWrapper<User>();
            //lqw.select("count(*) as count");
            //SELECT count(*) as count FROM user
            //lqw.select("max(age) as maxAge");
            //SELECT max(age) as maxAge FROM user
            //lqw.select("min(age) as minAge");
            //SELECT min(age) as minAge FROM user
            //lqw.select("sum(age) as sumAge");
            //SELECT sum(age) as sumAge FROM user
            lqw.select("avg(age) as avgAge");
            //SELECT avg(age) as avgAge FROM user
            List<Map<String, Object>> userList = userDao.selectMaps(lqw);
            System.out.println(userList);
        }
    }

为了在做结果封装的时候能够更简单，我们将上面的聚合函数都起了个名称，方面后期来获取这些数据

##### 3.2.3 分组查询 #####

> 需求:分组查询，完成 group by的查询使用

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            QueryWrapper<User> lqw = new QueryWrapper<User>();
            lqw.select("count(*) as count,tel");
            lqw.groupBy("tel");
            List<Map<String, Object>> list = userDao.selectMaps(lqw);
            System.out.println(list);
        }
    }

*  groupBy为分组，最终的sql语句为
    
        SELECT count(*) as count,tel FROM user GROUP BY tel

**注意:**

*  聚合与分组查询，无法使用lambda表达式来完成
 *  MP只是对MyBatis的增强，如果MP实现不了，我们可以直接在DAO接口中使用MyBatis的方式实现

#### 3.3 查询条件 ####

前面我们只使用了lt()和gt(),除了这两个方法外，MP的查询条件还有很多:

*  范围匹配（> 、 = 、between）
 *  模糊匹配（like）
 *  空判定（null）
 *  包含性匹配（in）
 *  分组（group）
 *  排序（order）
 *  ……

##### 3.3.1 等值查询 #####

> 需求:根据用户名和密码查询用户信息

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.eq(User::getName, "Jerry").eq(User::getPassword, "jerry");
            User loginUser = userDao.selectOne(lqw);
            System.out.println(loginUser);
        }
    }

*  eq()： 相当于 `=`,对应的sql语句为
    
        SELECT id,name,password,age,tel FROM user WHERE (name = ? AND password = ?)
 *  selectList：查询结果为多个或者单个
 *  selectOne:查询结果为单个

##### 3.3.2 范围查询 #####

> 需求:对年龄进行范围查询，使用lt()、le()、gt()、ge()、between()进行范围查询

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.between(User::getAge, 10, 30);
            //SELECT id,name,password,age,tel FROM user WHERE (age BETWEEN ? AND ?)
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  gt():大于(>)
 *  ge():大于等于(>=)
 *  lt():小于(<)
 *  lte():小于等于(<=)
 *  between():between ? and ?

##### 3.3.3 模糊查询 #####

> 需求:查询表中name属性的值以`J`开头的用户信息,使用like进行模糊查询

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
            lqw.likeLeft(User::getName, "J");
            //SELECT id,name,password,age,tel FROM user WHERE (name LIKE ?)
            List<User> userList = userDao.selectList(lqw);
            System.out.println(userList);
        }
    }

*  like():前后加百分号,如 %J%
 *  likeLeft():前面加百分号,如 %J
 *  likeRight():后面加百分号,如 J%

##### 3.3.4 排序查询 #####

> 需求:查询所有数据，然后按照id降序

@SpringBootTest
    class Mybatisplus02DqlApplicationTests {
        
    
        @Autowired
        private UserDao userDao;
        
        @Test
        void testGetAll(){
        
            LambdaQueryWrapper<User> lwq = new LambdaQueryWrapper<>();
            /**
             * condition ：条件，返回boolean，
             		当condition为true，进行排序，如果为false，则不排序
             * isAsc:是否为升序，true为升序，false为降序
             * columns：需要操作的列
             */
            lwq.orderBy(true,false, User::getId);
    
            userDao.selectList(lw
        }
    }

除了上面演示的这种实现方式，还有很多其他的排序方法可以被调用，如图:  
![在这里插入图片描述][24c36392a3f2491baea406b966387300.png]

*  orderBy排序
    
     *  condition:条件，true则添加排序，false则不添加排序。
     *  isAsc:是否为升序，true升序，false降序。
     *  columns:排序字段，可以有多个。
 *  orderByAsc/Desc(单个column):按照指定字段进行升序/降序。
 *  orderByAsc/Desc(多个column):按照多个字段进行升序/降序。
 *  orderByAsc/Desc。
    
     *  condition:条件，true添加排序，false不添加排序。
     *  多个columns：按照多个字段进行排序。

除了上面介绍的这几种查询条件构建方法以外还会有很多其他的方法，比如isNull,isNotNull,in,notIn等等方法可供选择，具体参考官方文档的条件构造器来学习使用，具体的网址为:

`https://mp.baomidou.com/guide/wrapper.html#abstractwrapper`

#### 3.4 映射匹配兼容性 ####

前面我们已经能从表中查询出数据，并将数据封装到模型类中，这整个过程涉及到一张表和一个模型类:  
![在这里插入图片描述][df7256ad751741638eb7f6035a4675a5.png]

之所以数据能够成功的从表中获取并封装到模型对象中，原因是表的字段列名和模型类的属性名一样。

那么问题就来了:

##### 问题1:表字段与编码属性设计不同步 #####

当表的列名和模型类的属性名发生不一致，就会导致数据封装不到模型对象，这个时候就需要其中一方做出修改，那如果前提是两边都不能改又该如何解决?

MP给我们提供了一个注解`@TableField`,使用该注解可以实现模型类属性名和表的列名之间的映射关系。  
![在这里插入图片描述][f0a7f508e53d47f2a96a1a2122cc8457.png]

##### 问题2:编码中添加了数据库中未定义的属性 #####

当模型类中多了一个数据库表不存在的字段，就会导致生成的sql语句中在select的时候查询了数据库不存在的字段，程序运行就会报错，错误信息为:

Unknown column ‘多出来的字段名称’ in ‘field list’

具体的解决方案用到的还是`@TableField`注解，它有一个属性叫`exist`，设置该字段是否在数据库表中存在，如果设置为false则不存在，生成sql语句查询的时候，就不会再查询该字段了。  
![在这里插入图片描述][65108be42003412f86c28db438f7de47.png]

##### 问题3：采用默认查询开放了更多的字段查看权限 #####

查询表中所有的列的数据，就可能把一些敏感数据查询到返回给前端，这个时候我们就需要限制哪些字段默认不要进行查询。解决方案是`@TableField`注解的一个属性叫`select`，该属性设置默认是否需要查询该字段的值，true(默认值)表示默认查询该字段，false表示默认不查询该字段。  
![在这里插入图片描述][e0bf123456684ee095b14fdf91f6e10a.png]

##### 知识点1：@TableField #####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@TableField</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>属性注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>模型类属性定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置当前属性对应的数据库表中的字段关系</td> 
  </tr> 
  <tr> 
   <td>相关属性</td> 
   <td>value(默认)：设置数据库表字段名称<br>exist:设置属性在数据库表字段中是否存在，默认为true，此属性不能与value合并使用<br>select:设置属性是否参与查询，此属性与select()映射配置不冲突</td> 
  </tr> 
 </tbody> 
</table>

##### 问题4:表名与编码开发设计不同步 #####

该问题主要是表的名称和模型类的名称不一致，导致查询失败，这个时候通常会报如下错误信息:

Table ‘databaseName.tableNaem’ doesn’t exist,翻译过来就是数据库中的表不存在。  
![在这里插入图片描述][3660534f92d14675a2d926f1a9dbb567.png]

解决方案是使用MP提供的另外一个注解`@TableName`来设置表与模型类之间的对应关系。

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

##### 知识点2：@TableName #####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@TableName</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>模型类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置当前类对应于数据库表关系</td> 
  </tr> 
  <tr> 
   <td>相关属性</td> 
   <td>value(默认)：设置数据库表名称</td> 
  </tr> 
 </tbody> 
</table>

**后记  
????美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ ???**

[3b09717d41604023965efa5856f3c674.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/f1a042687eaf405a9b5989a2a6793155.png
[3ee105bc349045e4b48482a9f68a0e6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/a9426168de0b4069b64a156490bc120e.png
[63fa84789f02465d9536973e6e34c856.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/f45936ac4132421eb1abf35d2f05c6ac.png
[b29f773ec268474a810cd26602c9f04c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/57470947c1184c9ba3360742eba6ff24.png
[4bb8cd26b7624784a713a26d80b2bc60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/ea9f5612b4274e4a9e9c5eea8c3ef899.png
[5502e36d16c94fea883d6739fbf45df8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/fee891a9e73348bebda049294c2cc53f.png
[fcf77c9c04bf46ef99443892e9df754e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/65818454e2a64ec59a074ec79ecefe27.png
[712ad3b90c104fb0b007ecc1b61e3d71.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/cfa1c7b10a2e4154a01e2d0b73e08e98.png
[ab01e9a10ef14ca18eb00b8d5bf2e74c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/7368ecf3e48047aabfb8557d24d10e02.png
[8e2d9c9fd2ed4951b4f7a44fc2240ad4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/1561cc1076cc41d9b6e0ea32e0abe56c.png
[157cf9132bd64e4cbfb422d4c1fc8a54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/0c6f867cf3db4198b68400c63eea0a82.png
[eb023b8954854bb78b7a2d4b17357b5c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/0895648bb9d249a696ec40e25a1b9f10.png
[0f8aa7b50fe84b91ab5b208024b89a06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/d3afe474debd405e89ac258c894402bb.png
[f278397f5bee40a6a1fd4c59edb1356b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/36c04785a68c4a6caae1888ff0aeb94e.png
[5c99af3bc9bc4bd1a3d47c61511ab33a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/00468cd1f71944aab718e27bb06502ec.png
[2aee5a284f234868846f73552c21d24f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/63de0763411549b785004c8b3a8f86f8.png
[1d9525cbe1b84ebeb890468f5b2a0e12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/9507a949cc8849ff8b37125a12bbdedd.png
[cf592cb5d24f4486b04820f8d098dc85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/6cc33c4518d14429b6a06a88ac7cbb17.png
[347a28aace45451f86ded689126e13f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/85f930624f9f414ba4c666d56328e178.png
[edbb9d325e8c48c18f612cf633448189.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/6b7123e17aef4694815573c099797966.png
[24c36392a3f2491baea406b966387300.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/1aeeea72768842a9be2a0262101db239.png
[df7256ad751741638eb7f6035a4675a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/3559abb9069746cfbed6d999c6034186.png
[f0a7f508e53d47f2a96a1a2122cc8457.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/1d3727e53de348a48569f0be4a9a3505.png
[65108be42003412f86c28db438f7de47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/08011cd1e4864222bdd943ec2adcf4af.png
[e0bf123456684ee095b14fdf91f6e10a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/fa6bce45a3f54ed7a53493514fa239f9.png
[3660534f92d14675a2d926f1a9dbb567.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/e0e8c3d4082a4da2876a407544bb5618.png
[5212246cfc3942b18c6d4911bb8589d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/5ffc0145cfdc493cbeb4d4d36884519e.png