mybatisplus querywrapper 的使用【进阶篇】-摩杜云开发者社区

新建springboot项目

mybatisplus querywrapper 的使用【进阶篇】_后端

mybatisplus querywrapper 的使用【进阶篇】_spring_02

mysql数据库

DROP TABLE IF EXISTS h_user;
CREATE TABLE h_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 h_user;
INSERT INTO h_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');

配置

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.15</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.shrimpking</groupId>
    <artifactId>springboot-vue-test12</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-vue-test12</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>
        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>spring-boot-starter-swagger</artifactId>
            <version>1.5.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

server.port=8089

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimeZone=UTC
spring.datasource.username=root
spring.datasource.password=mysql123
#日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#配置别名
mybatis-plus.type-aliases-package=com.shrimpking.pojo

代码

user.java

package com.shrimpking.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author shrimpking
 * @since 2023-09-07
 */
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("h_user")
@ApiModel(value="User对象", description="")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "主键ID")
    private Long id;

    @ApiModelProperty(value = "姓名")
    private String name;

    @ApiModelProperty(value = "年龄")
    private Integer age;

    @ApiModelProperty(value = "邮箱")
    private String email;


}

userMapper.java

package com.shrimpking.mapper;

import com.shrimpking.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author shrimpking
 * @since 2023-09-07
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {

}

userservice.java

package com.shrimpking.service;

import com.shrimpking.pojo.User;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author shrimpking
 * @since 2023-09-07
 */
public interface UserService extends IService<User> {

}

userserviceimpl.java

package com.shrimpking.service.impl;

import com.shrimpking.pojo.User;
import com.shrimpking.mapper.UserMapper;
import com.shrimpking.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author shrimpking
 * @since 2023-09-07
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

usercontroller.java

package com.shrimpking.controller;


import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author shrimpking
 * @since 2023-09-07
 */
@RestController
@RequestMapping("/user")
public class UserController {

}

userMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.shrimpking.mapper.UserMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.shrimpking.pojo.User">
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="age" property="age" />
        <result column="email" property="email" />
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        id, name, age, email
    </sql>

</mapper>

QueryTest.java

package com.shrimpking;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.shrimpking.mapper.UserMapper;
import com.shrimpking.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import sun.awt.image.URLImageSource;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

/**
 * Created by IntelliJ IDEA.
 *
 * @Author : Shrimpking
 * @create 2023/9/7 16:33
 */
@SpringBootTest
public class QueryTest
{
    @Autowired
    private UserMapper userMapper;

    //等值查询
    @Test
    public void eq(){
        //创建条件查询对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //设置查询条件，指定查询的字段和值
        queryWrapper.eq("name","Tom");
        //进行条件查询，获取结果
        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user);
        //SELECT id,name,age,email FROM h_user WHERE (name = ?)
    }

    //等值查询
    @Test
    public void eq2(){
        //创建条件查询对象
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //设置查询条件，指定查询的字段和值
        queryWrapper.eq(User::getName,"Tom");
        //进行条件查询，获取结果
        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user);
        //SELECT id,name,age,email FROM h_user WHERE (name = ?)
    }

    //查询值为null
    @Test
    public void isNull(){
        //创建条件查询对象
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //设置查询条件，指定查询的字段和值
        queryWrapper.eq(User::getName,null);
        //进行条件查询，获取结果
        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user); //结果为0, 不合理
    }

    //查询值为null，优化
    @Test
    public void isNull2(){
        //创建条件查询对象
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        //设置查询条件，指定查询的字段和值
        queryWrapper.eq(name != null,User::getName,name);
        //进行条件查询，获取结果
        List<User> userList = this.userMapper.selectList(queryWrapper);
        //为null时，查询全部，结果合理
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user
    }

    //多条件查询
    @Test
    public void allEq(){

        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(User::getName,"Tom");
        queryWrapper.eq(User::getAge,28); // 相当于 并且 and

        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user);
        //SELECT id,name,age,email FROM h_user WHERE (name = ? AND age = ?)
    }

    //多条件查询
    @Test
    public void allEq2(){
        //构建查询条件
        HashMap<String,Object> map = new HashMap<>();
        map.put("name","Tom");
        map.put("age",28);
        //查询
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.allEq(map,false); //第二参数，false，表示条件值为null时，舍弃该查询项

        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user);
        //SELECT id,name,age,email FROM h_user WHERE (name = ? AND age = ?)
    }

    //多条件查询
    @Test
    public void allEq3(){
        //构建查询条件
        HashMap<String,Object> map = new HashMap<>();
        map.put("name",null); //为null时
        map.put("age",28);
        //查询
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.allEq(map,false); //第二参数，false，表示条件值为null时，舍弃该查询项

        User user = this.userMapper.selectOne(queryWrapper);
        System.out.println(user);
        //SELECT id,name,age,email FROM h_user WHERE (age = ?)
    }

    //不相等查询
    @Test
    public void ne(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.ne(User::getName,"Tom");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name <> ?)
    }

    //大于 查询
    @Test
    public void gt(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        Integer age = 18;
        queryWrapper.gt(User::getAge,age);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age > ?)
    }

    //大于等于 查询
    @Test
    public void ge(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        Integer age = 18;
        queryWrapper.ge(User::getAge,age);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age >= ?)
    }

    //小于 查询
    @Test
    public void lt(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        Integer age = 21;
        queryWrapper.lt(User::getAge,age);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age < ?)
    }

    //小于等于 查询
    @Test
    public void le(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        Integer age = 21;
        queryWrapper.le(User::getAge,age);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age <= ?)
    }

    //值区间 查询
    @Test
    public void between(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.between(User::getAge,18,30);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age BETWEEN ? AND ?)
    }

    //不在值区间范围 查询
    @Test
    public void notBetween(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.notBetween(User::getAge,18,30);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age NOT BETWEEN ? AND ?)
    }

    //模糊查询 不区分出现位置
    @Test
    public void like(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"J");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name LIKE ?) Parameters: %J%(String)
    }

    //模糊查询 不包含
    @Test
    public void notLike(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.notLike(User::getName,"J");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name NOT LIKE ?)  Parameters: %J%(String)
    }

    //左模糊查询
    @Test
    public void likeLeft(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.likeLeft(User::getName,"e"); //字符串结尾字母是e的
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name LIKE ?) Parameters: %e(String)
    }

    //右模糊查询
    @Test
    public void likeRight(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.likeRight(User::getName,"J"); //字符串开头字母是J
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name LIKE ?) Parameters: J%(String)
    }

    //判断为空
    @Test
    public void isNull3(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNull(User::getEmail); //邮箱为空的
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (email IS NULL)
    }

    //判断不为空
    @Test
    public void isNotNull(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNotNull(User::getEmail); //邮箱不为空的
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (email IS NOT NULL)
    }

    //包含 in
    @Test
    public void in(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        ArrayList<Integer> ages = new ArrayList<>();
        ages.add(18);
        ages.add(20);
        queryWrapper.in(User::getAge,ages);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age IN (?,?))

    }

    //不包含 notin
    @Test
    public void notIn(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        ArrayList<Integer> ages = new ArrayList<>();
        ages.add(18);
        ages.add(20);
        queryWrapper.notIn(User::getAge,ages);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age NOT IN (?,?))
    }

    //insql
    @Test
    public void inSql(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        String ages = "select age from h_user where name like '%J%'";
        queryWrapper.inSql(User::getAge,ages);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age IN (select age from h_user where name like '%J%'))
    }

    //not insql
    @Test
    public void notInSql(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        String ages = "select age from h_user where name like '%J%'";
        queryWrapper.notInSql(User::getAge,ages);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age NOT IN (select age from h_user where name like '%J%'))
    }

    //分组查询
    @Test
    public void groupBy(){
        //mysql : select age,count(*) as field_count from h_user group by age;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //分组字段
        queryWrapper.groupBy("age");
        //查询字符串
        queryWrapper.select("age,count(*) as field_count");
        //结果封装在map中
        List<Map<String, Object>> maps = this.userMapper.selectMaps(queryWrapper);
        System.out.println(maps);
        //SELECT age,count(*) as field_count FROM h_user GROUP BY age
        //[{field_count=1, age=18}, {field_count=1, age=20}, {field_count=1, age=21}, {field_count=1, age=24}, {field_count=1, age=28}]
    }

    //聚合查询
    @Test
    public void having(){
        //mysql : select age,count(*) as field_count from h_user group by age having field_count >= 2;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //分组字段
        queryWrapper.groupBy("age");
        //查询字符串
        queryWrapper.select("age,count(*) as field_count");
        //聚合条件
        queryWrapper.having("field_count >= 2");
        //结果封装在map中
        List<Map<String, Object>> maps = this.userMapper.selectMaps(queryWrapper);
        System.out.println(maps);
        //SELECT age,count(*) as field_count FROM h_user GROUP BY age HAVING field_count >= 2
    }

    //升序排序
    @Test
    public void orderByAsc(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByAsc(User::getAge, User::getId);//先根据年龄，在根据id
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user ORDER BY age ASC,id ASC
    }

    //降序排序
    @Test
    public void orderByDesc(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByDesc(User::getAge, User::getId);//先根据年龄，在根据id
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user ORDER BY age DESC,id DESC
    }

    //多条件排序
    @Test
    public void orderBy(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //设置排序字段和排序方式
        //参数1，如果排序字段为null时，是否要作为排序字段，false为舍弃
        //参数2，是否升序
        //参数3，排序字段
        queryWrapper.orderBy(true,true, User::getAge); //年龄升序
        queryWrapper.orderBy(true,false, User::getId); // id 降序
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user ORDER BY age ASC,id DESC
    }

    //内嵌逻辑查询
    @Test
    public void func(){
        //模拟前端，开启模糊查询
        boolean likeCondition = true;
        String name = "J";
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.func(new Consumer<LambdaQueryWrapper<User>>()
        {
            @Override
            public void accept(LambdaQueryWrapper<User> userLambdaQueryWrapper)
            {
                if(likeCondition){
                    //模糊查询
                    userLambdaQueryWrapper.like(User::getName,name);
                }else
                {
                    //精确查询
                    userLambdaQueryWrapper.eq(User::getName,name);
                }
            }
        });
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //true: SELECT id,name,age,email FROM h_user WHERE (name LIKE ?)
        //false: SELECT id,name,age,email FROM h_user WHERE (name = ?)
    }

    //逻辑查询 and
    @Test
    public void and(){
        //查询年满20周岁，并且姓名中含有字母a的人
        Integer age = 20;
        String name = "a";
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.ge(User::getAge,age).like(User::getName,name);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age >= ? AND name LIKE ?)
    }

    //逻辑查询，嵌套 and
    @Test
    public void and2(){
        //查询电子邮箱不为空，（年龄大于22岁，或者名字为tom）的人
        Integer age = 22;
        String name = "Tom";
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNotNull(User::getEmail)
                .and(child -> child.gt(User::getAge,age).or().eq(User::getName,name));
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (email IS NOT NULL AND (age > ? OR name = ?))

    }

    //逻辑查询 or
    @Test
    public void or(){
        //查询年龄小于18岁，或者年龄大于35岁的人，
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.lt(User::getAge,18).or().gt(User::getAge,35);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (age < ? OR age > ?)
    }

    //逻辑查询 or 嵌套
    @Test
    public void or2(){
        //查询姓名包含b，或者年龄在18至22之间的人
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"b").
                or(child -> child.ge(User::getAge,18).le(User::getAge,22));
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (name LIKE ? OR (age >= ? AND age <= ?))

    }

    //自定义查询条件
    @Test
    public void apply(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.apply("email like '%baomidou.com%'");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (email like '%baomidou.com%')
    }

    //mysql 分页 查询数据
    @Test
    public void last(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.last("limit 0,3");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user limit 0,3
    }

    //exists
    @Test
    public void exists(){
        //exists函数中为true，即有查询结果时，主查询才生效
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.exists("select id from h_user where email is not null");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (EXISTS (select id from h_user where email is not null))
    }

    //not exists
    @Test
    public void notExists(){
        //not exists函数中为false，即无查询结果时，主查询才生效
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.notExists("select id from h_user where age < 18");
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age,email FROM h_user WHERE (NOT EXISTS (select id from h_user where age < 18))
    }

    //查询字段
    @Test
    public void select(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(User::getId, User::getName, User::getAge);
        List<User> userList = this.userMapper.selectList(queryWrapper);
        System.out.println(userList);
        //SELECT id,name,age FROM h_user

    }


}