一、Mybatis-Plus简介

1、什么是Mybatis-Plus

Mybatis-Plus是一个Mybatis（opens new window）的增强工具，在Mybatis的基础上只做增强不做改变，为简化开发。

2、Mybatis-Plus的优势

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

3、Mybatis-Plus的框架结构

二、SpringBoot整合Mybatis-Plus入门

1、创建maven工程，添加依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

2、创建数据库表employee

CREATE TABLE employee(
    emp_id BIGINT(20) NOT NULL,
    name VARCHAR(30),
    emp_gender VARCHAR(6),
    age INT,
    email VARCHAR(50),
    PRIMARY KEY(emp_id)
);
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367686308726788098,'刘晓娟','女',20,'liuxianjuan@qq.com');
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367709299695099906,'张春雨','男',28,'zhangchunyu@sina.com');
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367717669156028418,'何雨柱','男',23,'heyuzhu@126.com');

3、构建数据模型Employee

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
//指定当前实体类映射哪张数据库表， 默认是跟实体类名一致
@TableName(value = "tb_employee")
public class Employee {
    @TableId
    private Long empId;
    //当表中的列与实体类属性不一致时，使用TableField指定数据库中的列名
    @TableField(value = "emp_name")
    private String name;
    private String empGender;
    private Integer age;
    private String email;
    //Mybatis-Plus会自动将驼峰命名法转换成mysql中_形式（deptId---> dept_id）
    private Long deptId; 

    //当表中没有remark时，使用TableField的exist=false属性忽略该字段
    @TableField(exist = false)
    private String remark;
}

• @TableName(“表名”) ：指定当前实体类映射哪张数据库表， 默认是跟实体类名一致
• @TableField(“列名”) ： 指定当前属性映射数据库表哪一列， 默认是跟属性名一致
  • 例子： @TableField(exist = false) // 当属性没有映射列时,使用
• @TableId(“自增算法”) : 标记当前属性映射表主键。
  • 例子 ：@TableId(type=IdType.AUTO) ID自增
  • @TableId(type=IdType.NONE) 无状态,该类型为未设置主键类型
  • @TableId(type=IdType.INPUT) insert前自行set主键值
  • @TableId(type=IdType.ASSIGN_ID) 分配ID
  • @TableId(type=IdType.ASSIGN_UUID) 分配UUID,主键类型为String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认default方法)

4、配置application.properties文件

#mysql
spring.datasource.url=jdbc:mysql://192.168.126.129:3306/mybatis-plus?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=admin
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 配置slq打印日志
第一种：
logging.level.cn.wolfcode.mp.mapper=debug
第二种：
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

5、写个EmployeeMapper接口继承BaseMapper

public interface EmployeeMapper extends BaseMapper<Employee> {

}

6、编写SpringBoot启动类

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

三、CRUD

1、BaseMapper接口方法介绍

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如下：

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * <p>这个 Mapper 支持 id 泛型</p>
 *
 * @author hubin
 * @since 2016-01-23
 */
public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    int deleteById(Serializable id);

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体对象
     * @since 3.4.4
     */
    int deleteById(T entity);

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 删除（根据ID或实体 批量删除）
     *
     * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    int updateById(@Param(Constants.ENTITY) T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，查询一条记录
     * <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
            if (ts.size() != 1) {
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
            }
            return ts.get(0);
        }
        return null;
    }

    /**
     * 根据 Wrapper 条件，判断是否存在记录
     *
     * @param queryWrapper 实体对象封装操作类
     * @return
     */
    default boolean exists(Wrapper<T> queryWrapper) {
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0;
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * <p>注意： 只返回第一个字段的值</p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

2、Insert方法

@Test
public void testInsert() {
    Employee employee=new Employee();
    //employee.setEmpId(100000);
    employee.setName("刘龙");
    employee.setEmpGender("男");
    employee.setAge(25);
    employee.setEmail("liulong@163.com");
    employeeMapper.insert(employee);
}

3、更新数据的通用方法

• 1、updateById方法
  根据id进行记录更新，如果对象属性未传值，则不会更新该字段，保持数据库表原来字段值

public void testUpdateById() {
    Employee employee=new Employee();
    employee.setEmpId(10)
    employee.setName("刘龙");
    employee.setEmpGender("女");
    employee.setAge(23);
    employee.setEmail("liulong@163.com");
    employeeMapper.updateById(employee);
}

• 2、update(entity，wrapper)方法

public void testdateById(){
    //根据员工的名字,更新
    Employee employee2=new Employee();
    employee2.setEmpGender("男");
    employee2.setAge(18);
    employee2.setEmail("liulong@126.com");
    employeeMapper.update(employee2,new UpdateWrapper<Employee>().eq("name","刘龙"));
}

4、查询数据的通用方法

• 1、selectById方法
  根据id查询指定记录

@Test
public void testSelectById() {
    Employee employee=employeeMapper.selectById(1);
    System.out.println(employee);
}

• 2、selectBatchIds方法
  批量查询指多个id的记录集合

@Test
public void testSelectBatchIds() {
    List list= Arrays.asList(1,2,3);
    List<Employee> employeeList = employeeMapper.selectBatchIds(list);
    employeeList.forEach(System.out::println);
}

• 3、selectByMap方法
  根据Map集合中传入的条件进行查询，每个条件都是and关系

@Test
public void testSelectByMap() {
    Map<String,Object> map=new HashMap<>();
    map.put("emp_gender","男");
    map.put("age",29);
    List<Employee> employeeList = employeeMapper.selectByMap(map);
    employeeList.forEach(System.out::println);
}

5、删除数据方法

• 1、deleteById方法
  根据id删除记录

@Test
public void testDeleteById(){
    int rows=employeeMapper.deleteById(1);
    System.out.println("受影响的行数:"+rows);
}

• 2、deleteByMap方法
  根据Map中的条件进行删除，map中的条件在sql语句中是and关系

@Test
public void testDeleteByMap(){
    Map<String,Object> map=new HashMap<>();
    map.put("emp_gender","男");
    map.put("emp_name","刘辉");
    int rows=employeeMapper.deleteByMap(map);
    System.out.println("受影响的行数:"+rows);
}

• 3、deletebatchIds方法
  根据传入List集合中的id进行批量删除

@Test
public void testDeleteBatchIds(){
    List list= Arrays.asList(4,7,1);
    int rows=employeeMapper.deleteBatchIds(list);
    System.out.println("受影响的行数:"+rows);
}

四、Mybatis-Plus条件构造器

1、条件构造器介绍

在mybatis-plus中提了构造条件的类Wrapper，它可以根据自己的意图定义我们需要的条件。Wrapper是一个抽象类，一般情况下我们用它的子类QueryWrapper来实现自定义条件查询。

2、SelectOne方法

//查询姓名为刘辉军并且性别为男的员工
@Test
public void testSelectOne(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.eq("name","刘辉军");
    queryWrapper.eq("emp_gender","男");
    Employee employee = employeeMapper.selectOne(queryWrapper);
    System.out.println(employee);
}

3、SelectList方法

//查询姓名中带有"磊"的并且年龄小于30的员工
@Test
public void testSelectList(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.like("name","磊").lt("age",30);
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}
 
//查询姓刘的或者性别为男，按年龄的除序排序
@Test
public void testSelectList2(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.like("name","王")
        .or().eq("emp_gender","男")
        .orderByDesc("age");
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}
 
//查询姓刘的并且（年龄小于35或者邮箱不为空）
@Test
public void testSelectList3(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.likeRight("name","刘")
        .and(wq->wq.lt("age",35).or().isNotNull("email"));
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}

4、SelectPage方法

SelectPage用于分页，在Mybatis-Plus中分页有两种：一种是逻辑分页或叫内存分页，另一个是物理分页。内存分页就是把数据全部查询出来放到内容中，返回你想要的一部分数据，当数据量非常庞大时，这种方法就行不通了，因为太耗内容，所以一般采用物理分页，需要SpringMVC中加入物理分页配置：

@Configuration
public class MybatisPlusConfig {
 
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

@Test
public void testSelectPage(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.lt("age",50);
    Page<Employee> page=new Page<>(1,2);
    Page<Employee> employeePage = employeeMapper.selectPage(page, queryWrapper);
    System.out.println("当前页:"+ employeePage.getCurrent());
    System.out.println("每页记录数:"+employeePage.getSize());
    System.out.println("总记录数:"+employeePage.getTotal());
    System.out.println("总页数:"+employeePage.getPages());
    List<Employee> employeeList = employeePage.getRecords();
    employeeList.forEach(System.out::println);
}

5、Update方法

//根据姓名和年龄修改记录
@Test
public void testUpdate(){
    QueryWrapper<Employee> updateWrapper=new QueryWrapper<>();
    updateWrapper.eq("name","刘龙")
        .eq("age",25);
    Employee employee=new Employee();
    employee.setEmpId(1367720249630318593L);
    employee.setName("刘龙");
    employee.setEmail("lilong111@.qq.com");
    employee.setAge(26);
    employee.setEmpGender("女");
    int rows=employeeMapper.update(employee,updateWrapper);
    System.out.println("受影响的行数:"+rows);
}

6、Delete方法

//根据姓名和年龄删除记录
@Test
public void testDelete(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.eq("name","刘龙")
        .eq("age",26);
    int rows=employeeMapper.delete(queryWrapper);
    System.out.println("受影响的行数:"+rows);
}

7、条件构造器和常用接口

7.1、wapper介绍

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

AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
    UpdateWrapper ：  Update 条件封装，用于Entity对象更新操作
    AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
        LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
        LambdaUpdateWrapper ： Lambda 更新封装Wrapper

具体使用

//查询对应容器的
QueryWrapper<SowingResults> condition = new QueryWrapper<>();
condition.lambda().eq(SowingResults::getMaterialCode, form.getMaterialCode())//等于条件查询
        .notIn(SowingResults::getStatus, 3,4)//不等于not in  写法 
        .ne(SowingResults::getIsDeleted, 1);//不能等于
SowingResults one = sowingResultsService.getOne(condition);

QueryWrapper的方法

7.2、QueryWrapper

• 组装查询条件

@Test
public void test01() {
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name", "b")
            .between("age", 20, 30)
            .isNotNull("email");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

• 组装排序条件

@Test
public void test02() {
    //按年龄降序查询用户，如果年龄相同则按id升序排列
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,id ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("age").orderByAsc("id");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

• 组装删除条件

@Test
public void test03() {
    //删除email为空的用户
    //DELETE FROM t_user WHERE (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.isNull("email");
    //条件构造器也可以构建删除语句的条件
    int result = userMapper.delete(queryWrapper);
    System.out.println("受影响的行数：" + result);
}

• 条件的优先级

@Test
public void test04() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE is_deleted=0 AND (name LIKE ? AND age > ? OR email IS NULL)
    queryWrapper.like("name", "b").gt("age", 20).or().isNull("email");
    User user = new User();
    user.setAge(18);
    user.setEmail("user@atguigu.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

@Test
public void test004() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR email IS NULL)) //lambda表达式内的逻辑优先运算
    queryWrapper.like("name", "a").and(i -> i.gt("age", 22).or().isNull("email"));
    User user = new User();
    user.setAge(18);
    user.setEmail("user@atguigu.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

• 组装select子句（注意）

@Test
public void test05() {
    //查询用户信息的username和age字段
    //SELECT username,age FROM t_user
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值 为null
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}

• 实现子查询

@Test
public void test06() {
    //查询id小于等于3的用户信息
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (id IN (select id from t_user where id <= 5))
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.inSql("id", "select id from t_user where id <= 5");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
}

7.3、UpdateWrapper(注意)与6、LambdaUpdateWrapper对比

@Test
public void test07() {
    //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息修改
    //组装set子句以及修改条件
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //lambda表达式内的逻辑优先运算
    updateWrapper
            .set("age", 58)
            .set("email", "user58@atguigu.com")
            .like("name", "a")
            .and(i -> i.gt("age", 20)
                    .or()
                    .isNull("email"));
    //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null
    //UPDATE t_user SET age=?,email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR email IS NULL))
    //User user = new User();
    //user.setName("张三");
    //int result = userMapper.update(user, updateWrapper);
    //UPDATE t_user SET age=?,email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR email IS NULL))
    int result = userMapper.update(null, updateWrapper);
    System.out.println(result);
}

7.4、condition（注意）

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果

• 思路一：

@Test
public void test08() {
    //定义查询条件，有可能为null（用户未输入或未选择） 
    String username = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成
    if (StringUtils.isNotBlank(username)) {
        queryWrapper.like("name", "a");
    }
    if (ageBegin != null) {
        queryWrapper.ge("age", ageBegin);
    }
    if (ageEnd != null) {
        queryWrapper.le("age", ageEnd);
    }
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (age >= ? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

• 思路二：
  • 上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查询条件，简化代码的编写

@Test
public void test08UseCondition() {
    //定义查询条件，有可能为null（用户未输入或未选择）
    String username = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成
    queryWrapper.like(StringUtils.isNotBlank(username), "name", "a")
            .ge(ageBegin != null, "age", ageBegin)
            .le(ageEnd != null, "age", ageEnd);
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (age >= ? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

7.5、LambdaQueryWrapper

@Test
public void test09() {
    //定义查询条件，有可能为null（用户未输入）
    String username = "a";
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    //避免使用字符串表示字段，防止运行时错误
    queryWrapper.like(StringUtils.isNotBlank(username), User::getName, username)
            .ge(ageBegin != null, User::getAge, ageBegin)
            .le(ageEnd != null, User::getAge, ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

7.6、LambdaUpdateWrapper与3、UpdateWrapper对比

@Test
public void test10() {
    //组装set子句
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.set(User::getAge, 18)
            .set(User::getEmail, "user@atguigu.com")
            .like(User::getName, "a")
            .and(i -> i.lt(User::getAge, 24)
                    .or()
                    .isNull(User::getEmail));
    //lambda 表达式内的逻辑优先运算
    User user = new User();
    int result = userMapper.update(user, updateWrapper);
    System.out.println("受影响的行数：" + result);
}

8、高级查询

• 1、列投影 select

@Test
public void test10() {
    //组装set子句
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.set(User::getAge, 18)
            .set(User::getEmail, "user@atguigu.com")
            .like(User::getName, "a")
            .and(i -> i.lt(User::getAge, 24)
                    .or()
                    .isNull(User::getEmail));
    //lambda 表达式内的逻辑优先运算
    User user = new User();
    int result = userMapper.update(user, updateWrapper);
    System.out.println("受影响的行数：" + result);
}

/**
 * wrapper.select指定查询某些列
 * 需求：查询所有员工， 返回员工name， age列
 * SELECT name,age FROM employee
 */
@Test
public void query1(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.select("name","age");
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);

}

/**
 * 需求：查询所有员工， 返回员工以a字母开头的列
 * SELECT id,age,admin FROM employee
 */
@Test
public void query2(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.select(Employee.class,tableFieldInfo -> tableFieldInfo.getProperty().startsWith("a"));
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

• 2、排序 orderByAsc/orderByDesc

/**
 * orderByAsc
 * 需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
 * SELECT id,name,password,email,age,admin,dept_id FROM employee ORDER BY age ASC,id ASC
 */
@Test
public void query3(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.orderByAsc("age","id");
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * 需求：查询所有员工信息按age正序排， 如果age一样， 按id倒序排
 * SELECT id,name,password,email,age,admin,dept_id FROM employee ORDER BY age ASC,id DESC
 */
@Test
public void query4(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.orderByAsc("age").orderByDesc("id");
    employeeMapper.selectList(wrapper);
}

• 3、 分组查询
  groupBy

/**
 * groupBy
 * 需求： 以部门id进行分组查询，查每个部门员工个数
 */
@Test
public void query5(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.groupBy("dept_id")
            .select("dept_id","count(*) count");
    employeeMapper.selectList(wrapper);
}

having

/**
 * having
 * 需求： 以部门id进行分组查询，查每个部门员工个数， 将大于3人的部门过滤出来
 * SELECT dept_id,count(*) count FROM employee GROUP BY dept_id HAVING count(*) > 3
 */
@Test
public void query6(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.groupBy("dept_id")
            .select("dept_id","count(*) count")
            .having("count(*) > 3");
    employeeMapper.selectList(wrapper);
}

• 4、比较运算符

/**
 * allEq ： 全等匹配
 * 需求：查询name=dafei， age=18的员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (name = ? AND age = ?)
 */
@Test
public void query7(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","dafei");
    map.put("age",18);
    map.put("dept_id",null);
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.allEq(map,false);//是否允许空字段传入比对条件中
    employeeMapper.selectList(wrapper);

}

/**
 * gt:>  lt:<  ge:>=  le:<=  ne:<>不等于
 * 需求：查询age 大于18岁 小于30岁员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (age > ? AND age < ?)
 */
@Test
public void query8(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.gt("age",18).lt("age",30);
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * between/notBetween
 * 需求：查询年龄介于18~30岁的员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (age BETWEEN ? AND ?)
 */
@Test
public void query9(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.between("age",18,30);
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * isNull/isNotNull
 * 需求： 查询dept_id 为null 员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (dept_id IS NULL)
 */
@Test
public void query10(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.isNull("dept_id");
    employeeMapper.selectList(wrapper);
}

/**
 * in
 * 需求： 查询id为1， 2 的员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (id IN (?,?))
 */
@Test
public void query11(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.in("id",1L,2L);
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * notIn
 * 需求： 查询id不为1， 2 的员工信息
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (id NOT IN (?,?))
 */
@Test
public void query12(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.notIn("id",1L,2L);
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * inSql("id","1,2")(sql片段拼接) == in
 * notInSql("id","1,2")(sql片段拼接) == notIn
 * 需求： 查询id为1， 2 的员工信息
 */
@Test
public void query13(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.inSql("id","1,2");
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

• 5、模糊查询

/**
 * like/notLike
 * 需求： 查询name中含有fei字样的员工
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (name LIKE ?)
 */
@Test
public void query14(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.like("name","fei");
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * likeLeft: LIKE '%值'
 * 需求： 查询name以fei结尾的员工信息
 */
@Test
public void query15(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.likeLeft("name","fei");
    employeeMapper.selectList(wrapper);
}

/**
 * likeRight: LIKE '值%'
 * 需求： 查询姓赵的员工信息
 */
@Test
public void query16(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.likeRight("name","赵");
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

• 6、逻辑运算符

/**
 *
 * 需求： 查询age = 18 或者 name=dafei 或者 id =1 的用户
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (age = ? OR name = ? OR id = ?)
 */
@Test
public void query17(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.eq("age",18)
            .or()
            .eq("name","dafei")
            .or()
            .eq("id",1L);
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * 嵌套OR
 * 需求：查询name含有fei字样的，或者 年龄在18到30之间的用户
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (name = ? OR (age >= ? AND age <= ?))
 *
 */
@Test
public void query18(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.eq("name","dafei")
            .or(a -> a.ge("age",18).le("age",30));
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);
}

/**
 * 嵌套and
 *需求：查询name含有fei字样的并且 年龄在小于18或者大于30的用户
 * SELECT id,name,password,email,age,admin,dept_id FROM employee WHERE (name LIKE ? AND (age < ? OR age > ?))
 */
@Test
public void query19(){
    QueryWrapper<Employee> wrapper = new QueryWrapper<>();
    wrapper.like("name","fei")
            .and(a -> a.lt("age",18).or().gt("age",30));
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(System.out::println);

}

五、Mybatis-Plus的Service封装

1、通用service简介

Mybatis-Plus除了通用的Mapper还有通用的Servcie层，这也减少了相对应的代码工作量，把通用 的接口提取到公共。其实按照MP的这种思想，可以自己也实现一些通用的Controller。

2、通用service常用方法介绍

/**
* 插入一条记录（选择字段，策略插入）
*
* @param entity 实体对象
*/
default boolean save(T entity) {
    return SqlHelper.retBool(getBaseMapper().insert(entity));
}
 
/**
* 根据 ID 选择修改
*
* @param entity 实体对象
*/
default boolean updateById(T entity) {
    return SqlHelper.retBool(getBaseMapper().updateById(entity));
}
 
/**
* TableId 注解存在更新记录，否插入一条记录
*
* @param entity 实体对象
*/
boolean saveOrUpdate(T entity);
 
/**
* 根据 Wrapper，查询一条记录 <br/>
* <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT
1")</p>
*
* @param queryWrapper 实体对象封装操作类 {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
*/
default T getOne(Wrapper<T> queryWrapper) {
    return getOne(queryWrapper, true);
}
 
/**
* 根据 Wrapper，查询一条记录
*
* @param queryWrapper 实体对象封装操作类 {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
* @param throwEx 有多个 result 是否抛出异常
*/
T getOne(Wrapper<T> queryWrapper, boolean throwEx);

3、通用service的案例

• 构建service接口

public interface EmloyeeService extends IService<Employee> {
}

• 构建service实现类

@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper,Employee> implements EmloyeeService {
}

• 通用service测试

@Test
public void testSave(){
    Employee employee=new Employee();
    employee.setName("孙宝来");
    employee.setEmpGender("男");
    employee.setAge(30);
    employee.setEmail("sunbaolai@qq.com");
    employeeService.save(employee);
}
 
@Test
public void testSaveOrUpdate(){
    Employee employee=new Employee();
    employee.setEmpId(1367720249630318594L);
    employee.setName("孙宝来");
    employee.setEmpGender("女");
    employee.setAge(33);
    employee.setEmail("sunbaolai@qq.com");
    employeeService.saveOrUpdate(employee);
}
 
@Test
public void testGetOne(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.gt("age",24);
    Employee employee = employeeService.getOne(queryWrapper,false);
    System.out.println(employee);
}

六、逻辑删除

只对自动注入的 sql 起效: 执行原生sql：是否删除条件不回自动添加

• 插入: 不作限制
• 查找: 追加 where 条件过滤掉已删除数据,如果使用 wrapper.entity 生成的 where 条件也会自动追加该字段，追加未删除的条件
• 更新: 追加 where 条件防止更新到已删除数据,如果使用 wrapper.entity 生成的 where 条件也会自动追加该字段，追加未删除的条件
• 删除: 转变为 更新（逻辑删除），更改是否删除字段的值

1、方法一 配置文件配置

• 步骤1：application.yml

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不
                                # 配置步骤2)
      logic-delete-value: 1     # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

• 步骤2：实体类字段上加上@TableLogic注解

@TableLogic
private Integer deleted;

2、方法二 直接在Entity写@TableLogic，并指定value和delval 的属性值

/**
 * 逻辑删除
 * value = "" 默认的原值
 * delval = "" 删除后的值
 * ：@TableLogic(value="默认的原值",delval="删除后的值")
 *
 *  删：逻辑删除
 *  改：sql默认添加在where条件字段中 and is_del = 0
 *  查：sql自动加上了条件未删除条件：SELECT * from xxxtable  where is_del =0
 */
@TableLogic(value = "0",delval = "1")
private Integer isDel;

七、自动填充功能

执行原生sql：不会自动填充，是否删除条件不回自动添加

1、填充原理：直接给entity的属性设置值若无值则入库会是null

2、自动填充失效：

使用boolean update(Wrapper updateWrapper)这个方法，自动填充会失效
boolean update(Wrapper updateWrapper)的底层实现为:

default boolean update(Wrapper<T> updateWrapper) {
    return this.update((Object)null, updateWrapper);
}

属性自动填充需要从第一个参数获取Object实体类,自动填充的核心方法:populateKeys中会判断
tableInfo就是获取的实体类对象,所以导致属性自动填充失效.

if (null == tableInfo) {
        /* 不处理 */
        return parameterObject;
}

使用带实体的修改方法
boolean update(T entity, Wrapper<T> updateWrapper)
例：new一个空的entity
this.update(new ServiceItemIcon(),
            Wrappers.<ServiceItemIcon>lambdaUpdate()
                    .set(!ObjectUtils.isEmpty(status), ServiceItemIcon::getStatus, status)
                    .eq(ServiceItemIcon::getUid, uid)
    );

3、配置步骤

• 步骤1：自定义填充器

import com.alib.scenery.common.threadLocal.UserThreadLocal;
import com.alib.scenery.vo.user.request.LoginUser;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @Description: 填充器 执行原生sql不会自动填充(如：SqlRunner)
 */
@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    private static final String UPDATE = "updateBy";

    private static final String UPDATE_TIME = "updateTime";

    /**
     * 新增 给公共的字段赋值
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {

        LoginUser loginUser = UserThreadLocal.getLoginUser();
        log.info("MyMetaObjectHandler=insertFill=loginUser:{}",loginUser);

        String userName = ObjectUtils.isNotNull(loginUser) ? loginUser.getUsername() : null;

        this.setFieldValByName("createBy",userName,metaObject);

        this.setFieldValByName("createTime",new Date(),metaObject);

        this.setFieldValByName(UPDATE,userName,metaObject);

        this.setFieldValByName(UPDATE_TIME,new Date(),metaObject);

    }

    /**
     * 修改 给公共的字段赋值
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {

        LoginUser loginUser = UserThreadLocal.getLoginUser();
        log.info("MyMetaObjectHandler=updateFill=loginUser:{}",loginUser);

        this.setFieldValByName(UPDATE,ObjectUtils.isNotNull(loginUser) ? loginUser.getUsername() : null,metaObject);

        this.setFieldValByName(UPDATE_TIME,new Date(),metaObject);

    }

}

• 步骤2：定义BaseEntity，每个Entity 需继承BaseEntity

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

import java.io.Serializable;
import java.util.Date;

/**
 * @Description: 统一自动填充实体（抽取每个表公共的字段） 需要配合填充器才能生效
 *
 * DEFAULT：         默认不处理
 * INSERT：          插⼊时填充字段
 * UPDATE：          更新时填充字段
 *INSERT_UPDATE：    插⼊和更新时填充字段
 */
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class BaseEntity implements Serializable {
    private static final long serialVersionUID = 953878410015883109L;

    @TableField(fill = FieldFill.INSERT)
    private String createBy;

    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private String updateBy;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

    /**
     * 逻辑删除
     * value = "" 默认的原值
     * delval = "" 删除后的值
     * ：@TableLogic(value="默认的原值",delval="删除后的值")
     *
     *  删：逻辑删除
     *  改：sql默认添加在where条件字段中 and is_del = 0
     *  查：sql自动加上了条件未删除条件：SELECT * from xxxtable  where is_del =0
     */
    @TableLogic(value = "0",delval = "1")
    private Integer isDel;

}

八、执行原生sql （使用SqlRunner方式）

注：执行原生sql不会自动填充(SqlRunner)，不初始化SqlRunner会报错：IllegalArgumentException

* 1.使用SqlRunner需要在application.yml配置文件中配置：
# 是否初始化 SqlRunner
#不打开使用SqlRunner报错：Cause: java.lang.IllegalArgumentException: Mapped Statements collection does not    
#contain value for com.baomidou.mybatisplus.core.mapper.SqlRunner.SelectList
enableSqlRunner: true

• 2、查询

/**
 * 查询用户信息(原生sql) 执行原生sql不会自动填充(SqlRunner)
 * @param vo
 * @return
 */
public JsonResult sqlRunnerFindUserByCondition(UserRequestVo vo){
    List<UserRequestVo> list = new ArrayList<>();
    List<Map<String, Object>> maps = SqlRunner.db().selectList("SELECT * FROM `user` WHERE 1 = 1 AND is_del = '0' ORDER BY create_time DESC");
    if(ObjectUtils.isNotNull(maps) && !maps.isEmpty()){
        UserRequestVo dataVo = null;
        for (Map<String, Object> map : maps) {
            dataVo = new UserRequestVo();
            Object id = map.get("id");
            dataVo.setId(ObjectUtils.isNull(id) ? null : Integer.parseInt(String.valueOf(id)));

            Object userName = map.get("user_name");
            dataVo.setUserName(ObjectUtils.isNull(userName) ? "" : String.valueOf(userName));

            Object phoneNumber = map.get("phone_number");
            dataVo.setPhoneNumber(ObjectUtils.isNull(phoneNumber) ? "" : String.valueOf(phoneNumber));

            list.add(dataVo);
        }
    }
    return JsonResult.ok(list);
}

• 3、新增

/**
 * 新增用户 （原生sql） 执行原生sql不会自动填充(SqlRunner)
 * @param vo
 * @return
 * INSERT INTO `user` (user_name,phone_number,gender,open_id) VALUES('哈哈' , '17890000000' , '1', '7f5b07c0a2914a7a94a23b84d468fe8f')
 */
@Override
public JsonResult sqlRunnerSaveUser(UserRequestVo vo) {
    boolean insertFlag = SqlRunner.db().insert("INSERT INTO `user` (user_name,phone_number,gender,open_id) VALUES({0} , {1} , {2}, {3})",
            vo.getUserName(),vo.getPhoneNumber(),vo.getGender(),UUID.randomUUID().toString().replace("-",""));

    return insertFlag ? JsonResult.ok("新增成功") : JsonResult.fail("新增失败");
}

• 4、修改

/**
 * 修改用户信息 （原生sql） 执行原生sql不会自动填充(SqlRunner)
 * @param vo
 * @return
 * UPDATE `user` SET user_name = '奥巴驴',gender = '1' WHERE id = 3
 */
@Override
public JsonResult sqlRunnerUpdateUser(UserRequestVo vo) {
    boolean updateFlag = SqlRunner.db().update("UPDATE `user` SET user_name = {0},gender = {1} WHERE id = {2}",
            vo.getUserName(), vo.getGender(), vo.getId());
    return updateFlag ? JsonResult.ok("修改成功") : JsonResult.fail("修改失败");
}

新增后返回id

• 1、keyProperty=“id” useGeneratedKeys=“true”

<insert id="insert" keyProperty="id" useGeneratedKeys="true">
    insert into staff_order(tenant_id, institution_id, s_order_id, p_order_id, staff_id, staff_name,
                            staff_type, order_model,
                            staff_phone, provider_id,
                            order_status,
                            order_start_time, depart_start_time, service_start_time, service_stop_time, start_img,
                            start_lat,
                            start_longitude, start_address, stop_img, stop_lat, stop_longitude, stop_address,
                            description, status,order_no)
    values (#{tenantId}, #{institutionId}, #{sOrderId}, #{pOrderId}, #{staffId}, #{staffName}, #{staffType},
            #{orderModel}, #{staffPhone},
            #{providerId}, #{orderStatus},
            #{orderStartTime}, #{departStartTime}, #{serviceStartTime}, #{serviceStopTime}, #{startImg},
            #{startLat},
            #{startLongitude}, #{startAddress}, #{stopImg}, #{stopLat}, #{stopLongitude}, #{stopAddress},
            #{description},
            #{status},#{orderNo})
</insert>

• 2、selectKey 标签

<insert id="insertStaffOrder" parameterType="com.baidu.mine.common.entity.po.StaffOrder">
    <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
        select last_insert_id();
    </selectKey>
    insert into staff_order(tenant_id, institution_id, s_order_id, p_order_id, staff_id, staff_name,
    staff_type, order_model,
    staff_phone, provider_id,
    order_status,
    order_start_time, depart_start_time, service_start_time, service_stop_time, start_img,
    start_lat,
    start_longitude, start_address, stop_img, stop_lat, stop_longitude, stop_address,
    description, status)
    values (#{tenantId}, #{institutionId}, #{sOrderId}, #{pOrderId}, #{staffId}, #{staffName}, #{staffType},
    #{orderModel}, #{staffPhone},
    #{providerId}, #{orderStatus},
    #{orderStartTime}, #{departStartTime}, #{serviceStartTime}, #{serviceStopTime}, #{startImg},
    #{startLat},
    #{startLongitude}, #{startAddress}, #{stopImg}, #{stopLat}, #{stopLongitude}, #{stopAddress},
    #{description},
    #{status})
</insert>

九、MybatisPlus多表分页查询

MybatisPlus编写SQL语句实现多表条件分页查询

MyBatis-Plus在单表简单的CRUD操作上十分便捷，但当涉及到复杂的多表间的联合查询，而且还要携带条件的情况下，就会显得无从下手，一般情况下我们可以在service层写大量的代码逻辑达到多表条件查询的要求，当然也可以手写sql语句，这样更加方便。

1、controller层

@RequestMapping("xxx")
@RestController
public class StudentController{
    @Autowired
    private StudentService service;
    ...
    @GetMapping("{current}/{size}")
    public IPage<StudentResVo> queryPageList(
        @PathVariable("current") Long current,
        @PathVariable("size") Long size,
        StudentQueryVo vo
    ){
        // 创建page对象
        Page<StudentResVo> pageParam = new Page<>(current, size);
        // 调用service层的方法
        IPage<StudentResVo> pageModel = service.queryPageList(vo, pageParam);
        return pageModel;
    }
    ...
}

值得一提的是，分页功能是调用MyBatis-Plus插件通过AOP方式实现的，只需要传递分页的参数（current和size），不需要编写任何的代码逻辑。

2、MyBatis-Plus分页插件配置

@Configuration
@MapperScan("xxx.xxx")
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }
}

3、service层

// 接口
public interface StudentService extends IService<Student>{
    ...
    IPage<StudentResVo> queryPageList(StudentQueryVo vo, Page<StudentResVo> pageParam);
    ...

}
// 实现类
@Service
public class StudentServiceImpl 
    extends ServiceImpl<StudentMapper, Student> 
    implements StudentService {
    ...
    @Override
    public IPage<StudentResVo> queryPageList(StudentQueryVo vo, Page<StudentResVo> pageParam) {
        // 检查查询条件
        if (vo != null && vo.getKeyword() != null) {
            vo.setKeyword(vo.getKeyword().trim());
        }
        // 调用mapper层的方法
        return baseMapper.queryPageList(pageParam, vo);
    }
    ...

}

最后在mapper层定义并在xml文件中编写sql语句实现方法

4、mapper层

@Mapper
public interface StudentMapper extends BaseMapper<Student>{
    ...
    IPage<StudentResVo> queryPageList(Page<StudentResVo> pageParam, @Param("vo") StudentQueryVo vo);
    ...
}

• 在xml文件中编写SQL语句

<select id="queryPageList" resultType="StudentResVo">
    select 
        s.id,
        u1.real_name as student_name,
        u2.real_name as teacher_name
    from 
        student s 
        left join teacher t on t.id = s.teacher_id
        left join user u1 on u1.id = s.user_id
        left join user u2 on u2.id = t.user_id
    where 
        s.is_deleted = 0 and t.is_deleted = 0 # 需要手动添加逻辑删除条件
        <if test="vo.keyword != null and vo.keyword != ''">
            and u1.real_name like concat('%',#{vo.keyword},'%')
        </if>
</select>

至此，就在MyBatis中完成多表的条件查询操作了。

十、Mybatis-Plus代码生成器

1、代码生成器介绍

代码生成器顾名思义就是为我们生成一些代码，省去了我们一些时间。AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率,MyBatis-Plus从3.0.3 之后移除了代码生成器与模板引擎的默认依赖，需要手动添加相关依赖，才能实现代码生成器功能。

2、构建maven工程，引入依赖

<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>
</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.2.0</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

3、创建代码生成器对象

public class CodeGenerator {
    public static void main(String[] args) {
        //1.获取代码生成器的对象
        AutoGenerator autoGenerator = new AutoGenerator();

        //设置数据库相关配置
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        autoGenerator.setDataSource(dataSource);

        //设置全局配置
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setOutputDir(System.getProperty("user.dir")+"/mybatisplus_04_generator/src/main/java");    //设置代码生成位置
        globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
        globalConfig.setAuthor("huangyibo");    //设置作者
        globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
        globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
        globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
        autoGenerator.setGlobalConfig(globalConfig);

        //设置包名相关配置
        PackageConfig packageInfo = new PackageConfig();
        packageInfo.setParent("com.aaa");   //设置生成的包名，与代码所在位置不冲突，二者叠加组成完整路径
        packageInfo.setEntity("domain");    //设置实体类包名
        packageInfo.setMapper("dao");   //设置数据层包名
        autoGenerator.setPackageInfo(packageInfo);

        //策略设置
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
        strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称，模块名 = 数据库表名 - 前缀名  例如： User = tbl_user - tbl_
        strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
        strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
        strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
        strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
        autoGenerator.setStrategy(strategyConfig);
        //2.执行生成操作
        autoGenerator.execute();
    }
}

MyBatis-Plus代码生成器（最新版）

• 导入pom.xml依赖

<!--mybatis-plus依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>
<!--MP代码生成器依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.1</version>
</dependency>
<!--模板引擎依赖-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>

• 导入配置生成代码

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.Collections;

/**
 * @Author: huangyibo
 * @Date: 2024/1/9 17:54
 * @Description:
 */
public class CodeGenerator {

    public static void main(String[] args) {
        String url = "jdbc:mysql://192.168.169.168:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&maxReconnects=10&useSSL=false&allowMultiQueries=true";
        String username = "root";
        String password = "lroot@123";
        String tableName = "sys_data_table";
        String outputDir = "E:/mybatis-plus-generator/";
        generation(url, username,password, tableName, outputDir);
    }

    /**
     * 根据表名生成相应结构代码
     * @param url       数据库连接url
     * @param username  用户名
     * @param password  密码
     * @param tableName 表名
     */
    public static void generation(String url, String username,String password, String tableName, String outputDir){
        FastAutoGenerator.create(url, username, password)
                .globalConfig(builder -> {
                    builder.author("huangyibo")
                            //启用swagger
                            //.enableSwagger()
                            //指定输出目录
                            .outputDir(outputDir);
                })
                .packageConfig(builder -> {
                    builder.entity("entity")//实体类包名
                            .parent("com.landray.data")//父包名。如果为空，将下面子包名必须写全部， 否则就只需写子包名
                            .controller("controller")//控制层包名
                            .mapper("dao")//mapper层包名
                            //.other("dto")//生成dto目录 可不用
                            .service("service")//service层包名
                            .serviceImpl("service.impl")//service实现类包名
                            //自定义mapper.xml文件输出目录
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml,System.getProperty("user.dir")+"/src/main/resources/mapper"));
                })
                .strategyConfig(builder -> {
                    //设置要生成的表名
                    builder.addInclude(tableName)
                            .addTablePrefix("sys_")//设置表前缀过滤
                            .entityBuilder()
                            .enableLombok()
                            .enableChainModel()
                            .naming(NamingStrategy.underline_to_camel)//数据表映射实体命名策略：默认下划线转驼峰underline_to_camel
                            .columnNaming(NamingStrategy.underline_to_camel)//表字段映射实体属性命名规则：默认null，不指定按照naming执行
                            //.idType(IdType.AUTO)//添加全局主键类型
                            .formatFileName("%s")//格式化实体名称，%s取消首字母I,
                            .mapperBuilder()
                            .enableMapperAnnotation()//开启mapper注解
                            .enableBaseResultMap()//启用xml文件中的BaseResultMap 生成
                            .enableBaseColumnList()//启用xml文件中的BaseColumnList
                            .formatMapperFileName("%sMapper")//格式化Dao类名称
                            .formatXmlFileName("%sMapper")//格式化xml文件名称
                            .serviceBuilder()
                            .formatServiceFileName("%sService")//格式化 service 接口文件名称
                            .formatServiceImplFileName("%sServiceImpl")//格式化 service 接口文件名称
                            .controllerBuilder()
                            .enableRestStyle();
                })
//                .injectionConfig(consumer -> {
//            Map<String, String> customFile = new HashMap<>();
//            // 配置DTO（需要的话）但是需要有能配置Dto的模板引擎，比如freemarker，但是这里我们用的VelocityEngine，因此不多作介绍
//            customFile.put("DTO.java", "/templates/entityDTO.java.ftl");
//            consumer.customFile(customFile);
//           })
                .execute();
        System.out.println("SUCCESS");
    }

}

参考：
https://blog.csdn.net/m0_67296957/article/details/131723536

https://blog.csdn.net/qq_43158254/article/details/123291753

https://blog.csdn.net/weixin_43811057/article/details/123449767

https://blog.csdn.net/chat_bot/article/details/127629101

https://blog.csdn.net/m0_65818274/article/details/131903595

https://blog.csdn.net/Drifter_Galaxy/article/details/130790319

https://blog.csdn.net/aiwokache/article/details/129176894

https://blog.csdn.net/a534563/article/details/131459593