0
0

Mybatis-Plus详解

1. Mybatis-Plus概念

1.1 Mybatis-Plus介绍

官⽹：https://mp.baomidou.com/
MyBatis-Plus（简称 MP）是⼀个 MyBatis 的增强⼯具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提
⾼效率⽽⽣。

1.2 特性

  • ⽆侵⼊：只做增强不做改变，引⼊它不会对现有⼯程产⽣影响，如丝般顺滑。
  • 损耗⼩：启动即会⾃动注⼊基本 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 操作智能分析阻断，也可⾃定义拦截规则，预防误操作。

1.3 架构

2. Mybatis-Plus快速⼊⻔

2.1 安装

全新的 MyBatis-Plus 3.0 版本基于 JDK8，提供了 lambda 形式的调⽤，所以安装集成 MP3.0 要求如下：

  • JDK 8+
  • Maven or Gradle

Spring Boot（Spring Boot工程中集成Mybatis-Plus****）
Maven：

<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.4.0</version>
</dependency>

Spring MVC（普通Maven工程集成Mybatis-Plus）
Maven:

<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus</artifactId>
   <version>3.4.0</version>
</dependency>

对于Mybatis整合MP有常常有三种⽤法，分别是Mybatis+MP、Spring+Mybatis+MP、SpringBoot+Mybatis+MP。

2.2 创建数据库以及表

-- 创建测试表
DROP TABLE IF EXISTS tb_user;
CREATE TABLE user
(
 id BIGINT(20) NOT NULL COMMENT '主键ID',
 name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
 age INT(11) NULL DEFAULT NULL COMMENT '年龄',
 email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
 PRIMARY KEY (id) );

-- 插⼊测试数据
INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[email protected]'), 
(2, 'Jack', 20, '[email protected]'), 
(3, 'Tom', 28, '[email protected]'), 
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

2.3 创建⼯程

创建一个Maven工程 com.zm.mp
导⼊依赖：

 <dependencies>
        <!-- mybatis-plus插件依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.1.1</version>
        </dependency>

        <!--Mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>

        <!--简化bean代码的⼯具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.4 Mybatis + MP

下⾯演示，通过纯Mybatis与Mybatis-Plus整合。

创建⼦Module： zm-mybatis-plus-simple

    <?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
                                 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>zm-mybatis-plus</artifactId>
            <groupId>com.zm.mp</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>

        <modelVersion>4.0.0</modelVersion>
        <artifactId>zm-mybatis-plus-simple</artifactId>
    </project>

引入log4j.properties：

log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

Mybatis实现查询User

第⼀步，编写sqlMapConfig.xml⽂件：


    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <properties resource="jdbc.properties"></properties>

        <!--environments: 运⾏环境-->
        <environments default="development">
            <environment id="development">
                <!--当前的事务事务管理器是JDBC-->
                <transactionManager type="JDBC"></transactionManager>
                <!--数据源信息 POOLED：使⽤mybatis的连接池-->
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>

        <!--引⼊映射配置⽂件-->
        <mappers>
             <package name="com.zm.mapper"/>
        </mappers>
    </configuration>

第⼆步，编写User实体对象：（这⾥使⽤lombok进⾏了进化bean操作）

@Data // getter setter @toString
@NoArgsConstructor
@AllArgsConstructor
public class User {
      private Long id;
      private String name;
      private Integer age;
      private String email; 
}

第三步，编写UserMapper接⼝：

public interface UserMapper {
 
 List<User> findAll();
}

第四步，编写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.zm.mapper.UserMapper">
        <!-- 查询所有 -->
        <select id="findAll" resultType="com.zm.pojo.User">
            select * from user
        </select>
    </mapper>

第五步，编写TestMybatis测试⽤例：

public class MPTest {
    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> all = mapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }
}

测试结果：

注：如果实体类名称和表名称不⼀致，可以在实体类上添加注解@TableName("指定数据库表名")

Mybatis+MP实现查询User

第⼀步，将UserMapper继承BaseMapper，将拥有了BaseMapper中的所有⽅法：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zm.pojo.User;

public interface UserMapper extends BaseMapper<User> {
}

第⼆步，使⽤MP中的MybatisSqlSessionFactoryBuilder进行构建：

@Test
public void test2()throws IOException{
        InputStream resourceAsStream=Resources.getResourceAsStream("sqlMapConfig.xml");
        //这⾥使⽤的是MP中的MybatisSqlSessionFactoryBuilder
        SqlSessionFactory sqlSessionFactory=new MybatisSqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession=sqlSessionFactory.openSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        // 可以调⽤BaseMapper中定义的⽅法
        // List<User> all = mapper.findAll();
        List<User> all=mapper.selectList(null);
        for(User user:all){
           System.out.println(user);
        }
}

测试：

注：如果实体类名称和表名称不⼀致，可以在实体类上添加注解@TableName("指定数据库表名")。

简单说明：

  • 由于使⽤了 MybatisSqlSessionFactoryBuilder进⾏了构建，继承的BaseMapper中的⽅法就载⼊到了SqlSession中，所以就可以直接使⽤相关的⽅法；
  • 如图：

https://img-blog.csdnimg.cn/3cf331d25a3e49e18660b6974e5ca3c7.png

2.5 Spring + Mybatis + MP

引⼊了Spring框架，数据源、构建等⼯作就交给了Spring管理。

创建⼦Module（zm-mybatis-plus-spring）

<?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
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>zm-mybatis-plus</artifactId>
        <groupId>com.zm.mp</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>zm-mybatis-plus-spring</artifactId>
    <properties>
        <spring.version>5.1.6.RELEASE</spring.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

实现查询User

第⼀步，编写jdbc.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mp?serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=root

第⼆步，编写applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation=" http://www.springframework.org/schema/beans
                                http://www.springframework.org/schema/beans/spring-beans.xsd
                                http://www.springframework.org/schema/context
                                http://www.springframework.org/schema/context/spring-context.xsd">
        <!--引⼊properties-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
        <!--dataSource数据源-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>

        <!--将sqlSessionFactory对象的创建交给Spring。这⾥使⽤MP提供的sqlSessionFactory,完成spring与mp的整合-->
        <bean id="sqlSessionFactory"
              class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
        </bean>

        <!--扫描mapper接⼝，使⽤的依然是mybatis原⽣的扫描器-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.zm.mapper"/>
        </bean>
    </beans>

第三步，编写User对象以及UserMapper接⼝：

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

public interface UserMapper extends BaseMapper<User> {
 List<User> findAll();
}

第四步，编写测试⽤例：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestSpringMP {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void test2() throws IOException {
        List<User> users = this.userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

2.6 SpringBoot + Mybatis + MP

使⽤SpringBoot将进⼀步的简化MP的整合，需要注意的是，由于使⽤SpringBoot需要继承parent，所以需要重新创建⼯程，并不是创建⼦Module。

创建SpringBoot⼯程并导⼊对应依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--简化代码的⼯具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--mybatis-plus的springboot⽀持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

引入log4j.properties：

log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

编写application.properties：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

编写pojo：

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

编写mapper：

public interface UserMapper extends BaseMapper<User> {
}

编写启动类：

package com.zm.mp;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
@MapperScan("com.zm.mp.mapper") //设置mapper接⼝的扫描包
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

编写测试⽤例测试：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        List<User> userList = userMapper.selectList(null);
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

结果：

User(id=1, name=Jone, age=18, [email protected])
User(id=2, name=Jack, age=20, [email protected])
User(id=3, name=Tom, age=28, [email protected])
User(id=4, name=Sandy, age=21, [email protected])
User(id=5, name=Billie, age=24, [email protected])

3. 通⽤CRUD

通过前⾯的学习，我们了解到通过继承BaseMapper就可以获取到各种各样的单表操作，接下来我们将详细讲解这些操作。

3.1 插⼊操作

⽅法定义

/**
 * 插⼊⼀条记录
 *
 * @param entity 实体对象.
 */
 int insert(T entity);

测试⽤例

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    
     /*
      测试添加
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setAge(18);
        user.setEmail("[email protected]");
        user.setName("张三");

        //返回的result是受影响的⾏数，并不是⾃增后的id
        int result = userMapper.insert(user);
        System.out.println(result);
        System.out.println(user.getId());
    }
}

结果：

查看数据库表中数据：

通过数据库可以看到，数据已经写⼊到了数据库，但是，id的值不正确，我们期望的是数据库⾃增⻓，实际是MP⽣成了id的值写⼊到了数据库。

如何设置id的⽣成策略呢？

MP⽀持的id策略：

package com.baomidou.mybatisplus.annotation;
import lombok.Getter;
/**
 * ⽣成ID类型枚举类
 *
 * @author zm
 * @since 2021-11-10
 */
@Getter
public enum IdType {
    /**
     * 数据库ID⾃增
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型
     */
    NONE(1),
    /**
     * ⽤户输⼊ID
     * <p>该类型可以通过⾃⼰注册⾃动填充插件进⾏填充</p>
     */
    INPUT(2),
    /* 以下3种类型、只有当插⼊对象ID 为空，才⾃动填充。 */
    /**
     * 全局唯⼀ID (idWorker)
     */
    ID_WORKER(3),
    /**
     * 全局唯⼀ID (UUID)
     */
    UUID(4),
    /**
     * 字符串全局唯⼀ID (idWorker 的字符串表示)
     */
    ID_WORKER_STR(5);
    private final int key;
    IdType(int key) {
        this.key = key;
    }
}

修改User对象：

package com.zm.mp.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
    @TableId(type = IdType.AUTO) //指定id类型为⾃增⻓
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

注意：由于我们刚开始创建表的时候并没有指定主键id自增，这里的用@TableId设置主键自增策略时需要在数据表中也要设置主键自增，所以我们修改一下User表中的id字段为自增。再测试。

通过测试发现数据插⼊成功，id的值也是正确的。

@TableField

在MP中通过@TableField注解可以指定字段的⼀些属性，常常解决的问题有2个：

1、对象中的属性名和字段名不⼀致的问题（⾮驼峰）
2、对象中的属性字段在表中不存在的问题

使⽤：

其他⽤法，如⼤字段不加⼊查询字段（意思就是查询的时候不返回该字段的值）：

效果：

3.2 更新操作

在MP中，更新操作有2种，⼀种是根据id更新，另⼀种是根据条件更新。

3.2.1 根据id更新

⽅法定义：

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

测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;

   @Test
   public void testUpdateById() {
     User user = new User();
     user.setId(5L); //主键
     user.setAge(21); //更新的字段
     //根据id更新，更新不为null的字段
     this.userMapper.updateById(user);
  }
}

3.2.2 根据条件更新

⽅法定义：

/**
 * 根据 whereEntity 条件，更新记录
 *
 *正常的更新sql语句为：update 表名 set 字段=值 where 条件语句;
 *
 * @param entity 实体对象 (set 条件值,可以为 null)
 * @param updateWrapper 实体对象封装操作类（可以为 null,⾥⾯的 entity ⽤于⽣成 where 语句）
 */
 int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T>
updateWrapper);

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import net.minidev.json.writer.UpdaterMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    
    /*
     根据条件进行更新：将姓名为“张三”的年龄修改为30岁。
    */
   @Test
   public void testUpdate() {
       User user = new User();
       //更新的字段
       user.setAge(30); 
       //更新的条件
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       wrapper.eq("name", "张三");
       //执⾏更新操作
       int result = this.userMapper.update(user, wrapper);
       System.out.println("result = " + result);
   }
}

或者，通过UpdateWrapper进⾏更新：

@Test
public void testUpdate(){
        //更新的条件以及字段
        UpdateWrapper<User> wrapper=new UpdateWrapper<>();
        wrapper.eq("name","张三").set("age",30);
        //执⾏更新操作
        int result=this.userMapper.update(null,wrapper);
        System.out.println("result = "+result);
}

均可达到更新的效果。

3.3 删除操作

3.3.1 deleteById（根据 ID 删除）

⽅法定义：

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

测试⽤例：

package com.zm.mp;
import com.zm.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteById() {
        //执⾏删除操作
        int result = this.userMapper.deleteById(5L);
        System.out.println("result = " + result);
    }
}

3.3.2 deleteByMap（根据 columnMap 条件，删除记录）

⽅法定义：

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

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("age", 30);
        columnMap.put("name", "张三");
        //将columnMap中的元素设置为删除的条件，多个之间为and关系
        int result = this.userMapper.deleteByMap(columnMap);
        System.out.println("result = " + result);
    }
}

3.3.3 delete（根据 entity 条件，删除记录）

⽅法定义：

/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

测试⽤例：

package com.lagou.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        User user = new User();
        user.setAge(30);
        user.setName("张三");
        //将实体对象进⾏包装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        int result = this.userMapper.delete(wrapper);
        System.out.println("result = " + result);
    }
}

3.3.4 deleteBatchIds（根据ID 批量删除）
⽅法定义：

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

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        //根据id集合批量删除
        int result = this.userMapper.deleteBatchIds(Arrays.asList(1L, 10L, 20L));
        System.out.println("result = " + result);
    }
}

3.4 查询操作

MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分⻚查询等操作。

3.4.1、selectById（根据 ID 查询）

⽅法定义：

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

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectById() {
        //根据id查询数据
        User user = this.userMapper.selectById(2L);
        System.out.println("result = " + user);
    }
}

结果：

result = User(id=2, name=Jack, age=20, [email protected])

3.4.2、selectBatchIds（根据ID 批量查询）

⽅法定义：

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

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectBatchIds() {
        //根据id集合批量查询
        List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L));
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果：

User(id=2, name=Jack, age=20, [email protected])
User(id=3, name=Tom, age=28, [email protected])

3.4.3、selectOne（根据 entity 条件，查询⼀条记录，如果查询结果超过一条会报错）

⽅法定义：

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

测试用例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectOne() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("name", "jack");
        //根据条件查询⼀条数据，如果结果超过⼀条会报错
        User user = this.userMapper.selectOne(wrapper);
        System.out.println(user);
    }
}

结果：

User(id=2, name=Jack, age=20, [email protected])

3.4.4、selectCount（根据 Wrapper 条件，查询总记录数）

⽅法定义：

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

测试用例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectCount() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄⼤于23岁
        //根据条件查询数据条数
        Integer count = this.userMapper.selectCount(wrapper);
        System.out.println("count = " + count);
    }
}
}

结果：

count = 2

3.4.5、selectList（根据 entity 条件，查询全部记录）

⽅法定义：

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

测试用例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄⼤于23岁
        //根据条件查询数据
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }
}

结果：

user = User(id=3, name=Tom, age=28, [email protected])
user = User(id=5, name=Billie, age=24, [email protected])

3.4.6、selectPage（根据 entity 条件，查询全部记录（并分⻚））

⽅法定义：

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

配置分页插件：

package com.zm.mp;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.zm.mp.mapper") //设置mapper接⼝的扫描包
public class MybatisPlusConfig {
    /**
     * 分⻚插件  也就是配置分页功能的拦截器
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

测试用例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
 
    @Test
    public void testSelectPage() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 10); //年龄⼤于10岁

        //第一个参数：当前页    第二个参数：每页的条数
        Page<User> page = new Page<>(1, 2);
        //根据条件查询数据
        IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数：" + iPage.getTotal());
        System.out.println("总⻚数：" + iPage.getPages());
        System.out.println("分页数据：" + iPage.getRecords());
        /*List<User> users = iPage.getRecords();
        for (User user : users) {
            System.out.println("user = " + user);
        }*/
    }
}

结果：

数据库表数据：

运行结果：

3.5 SQL注⼊的原理

前⾯我们已经知道，MP在启动后会将BaseMapper中的⼀系列的⽅法注册到meppedStatements中，那么究竟是如何注⼊的呢？流程⼜是怎么样的？下⾯我们将⼀起来分析下。

在MP中，ISqlInjector负责SQL的注⼊⼯作，它是⼀个接⼝，AbstractSqlInjector是它的实现类，实现关系如下：

在AbstractSqlInjector中，主要是由inspectInject()⽅法进⾏注⼊的，如下：

@Override
public void inspectInject(MapperBuilderAssistant builderAssistant,Class<?>
mapperClass){
        Class<?> modelClass=extractModelClass(mapperClass);
        if(modelClass!=null){
          String className=mapperClass.toString();
          Set<String> mapperRegistryCache=GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
            if(!mapperRegistryCache.contains(className)){
                List<AbstractMethod> methodList=this.getMethodList();
              if(CollectionUtils.isNotEmpty(methodList)){
                TableInfo tableInfo=TableInfoHelper.initTableInfo(builderAssistant,modelClass);
               // 循环注⼊⾃定义⽅法
                methodList.forEach(m->m.inject(builderAssistant,mapperClass,modelClass,tableInfo));
              }else{
                   logger.debug(mapperClass.toString()+", No effective injection method was found.");
              }
                   mapperRegistryCache.add(className);
            }
        }
}

在实现⽅法中， methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass,tableInfo)); 是关键，循环遍历⽅法，进⾏注⼊。
最终调⽤抽象⽅法injectMappedStatement进⾏真正的注⼊：

/**
 * 注⼊⾃定义 MappedStatement
 *
 * @param mapperClass mapper 接⼝
 * @param modelClass mapper 泛型
 * @param tableInfo 数据库表反射信息
 * @return MappedStatement
 */
 public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

查看该⽅法的实现：

以SelectById为例查看：

public class SelectById extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?>modelClass, TableInfo tableInfo) {
        SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
        SqlSource sqlSource = new RawSqlSource(configuration,
                        String.format(sqlMethod.getSql(),
                        sqlSelectColumns(tableInfo, false),
                        tableInfo.getTableName(), tableInfo.getKeyColumn(),
                        tableInfo.getKeyProperty(),
                        tableInfo.getLogicDeleteSql(true, false)), Object.class);
        return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
    }
}

可以看到，⽣成了SqlSource对象，再将SQL通过addSelectMappedStatement⽅法添加到meppedStatements中。

4. 配置

在MP中有⼤量的配置，其中有⼀部分是Mybatis原⽣的配置，另⼀部分是MP的配置，详情：

使用配置 | MyBatis-Plus

下⾯我们对常⽤的配置做讲解。

4.1、基本配置

4.1.1、configLocation

MyBatis 配置⽂件位置，如果有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatisConfiguration 的具体内容请参考MyBatis 官⽅⽂档

Spring Boot环境中（在application.properties中加载mybatis的核心配置文件sqlMapConfig.xml）：

#加载全局配置文件
mybatis-plus.config-location = classpath:sqlMapConfig.xml

Spring MVC：

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
     <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
</bean>

4.1.2、mapperLocations

MyBatis Mapper 所对应的 XML ⽂件位置，如果在 Mapper 中有⾃定义⽅法（XML 中有⾃定义实现），需要进⾏该配置，告诉 Mapper 所对应的 XML ⽂件位置。

Spring Boot：

#加载映射配置文件
mybatis-plus.mapper-locations = classpath*:mapper/*.xml

Spring MVC：

<bean id="sqlSessionFactory"
      class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
   <property name="mapperLocations" value="classpath*:mapper/*.xml"/>
</bean>

Maven 多模块项⽬的扫描路径需以 classpath*： 开头 （即加载多个 jar 包下的 XML ⽂件）。

测试：
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.zm.mapper.UserMapper">
        <select id="findById" resultType="com.zm.pojo.User">
            select * from user where id = #{id}
        </select>
    </mapper>

package com.zm.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zm.pojo.User;

public interface UserMapper extends BaseMapper<User> {
    User findById(Long id);
}

测试用例 ：

package com.zm.zmmpspringboot;

import com.zm.mapper.UserMapper;
import com.zm.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest

public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectPage() {
        User user = this.userMapper.findById(2L);
        System.out.println(user);
    }
}

运行结果：

4.1.3、typeAliasesPackage

MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML ⽂件中可以直接使⽤类名，⽽不⽤使⽤全限定的类名（即 XML 中调⽤的时候不⽤包含包名）。
Spring Boot：

#起别名
mybatis-plus.type-aliases-package = com.zm.pojo

Spring MVC：

<bean id="sqlSessionFactory"
      class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="typeAliasesPackage" value="com.zm.pojo"/>
</bean>

4.2、进阶配置

本部分（Configuration）的配置⼤都为 MyBatis 原⽣⽀持的配置，这意味着您可以通过 MyBatis XML 配置⽂件的形式进⾏配置。

4.2.1、mapUnderscoreToCamelCase

  • 类型： boolean
  • 默认值： true

是否开启⾃动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java属性名 aColumn（驼峰命名） 的类似映射。

注意：
此属性在 MyBatis 中原默认值为 false，在 MyBatis-Plus 中，此属性也将⽤于⽣成最终的 SQL 的 select body。
如果数据库命名符合规则⽆需使⽤ @TableField 注解指定数据库字段名。

示例（SpringBoot）：

#关闭⾃动驼峰映射，该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case=false

4.2.2、cacheEnabled

  • 类型： boolean
  • 默认值： true

全局地开启或关闭配置⽂件中的所有映射器已经配置的任何缓存，默认为 true。
示例：

mybatis-plus.configuration.cache-enabled=false

4.3、DB（数据库） 策略配置

4.3.1、idType

  • 类型： com.baomidou.mybatisplus.annotation.IdType
  • 默认值： ID_WORKER

全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。

进行全局配置后表示所有的实体类在做插入数据时都可做到主键自增，而不是像@TableId(type = IdType.AUTO)一样只针对单个的实体类有效。

示例：
SpringBoot：

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

SpringMVC：

<!--这⾥使⽤MP提供的sqlSessionFactory，完成了Spring与MP的整合-->
    <bean id="sqlSessionFactory"
          class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="globalConfig">
            <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
                <property name="dbConfig">
                    <bean
                            class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                        <property name="idType" value="AUTO"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

4.3.2、tablePrefix

  • 类型： String
  • 默认值： null

表名前缀，全局配置后可省略@TableName()配置。

举例：将原来的表名（user）修改成（tb_user）。若进行了以下配置那在对应的实体类上可以省略@TableName(tb_user)，然后实体类依然写成User即可。

SpringBoot：

# 全局配置表名前缀
mybatis-plus.global-config.db-config.table-prefix=tb_

SpringMVC：

 <bean id="sqlSessionFactory"
          class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="globalConfig">
            <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
                <property name="dbConfig">
                    <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                        <property name="idType" value="AUTO"/>
                        <property name="tablePrefix" value="tb_"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

5. 条件构造器

在MP中，Wrapper接⼝的实现类关系如下：

可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，接下来我们重点学习AbstractWrapper以及其⼦类。

说明:
QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的⽗类⽤于⽣成 sql 的 where 条件, entity 属性也⽤于⽣成 sql 的 where 条件。

注意: entity ⽣成的 where 条件与 使⽤各个 api ⽣成的 where 条件没有任何关联⾏为。

官⽹⽂档地址：mybatis.plus

5.1、allEq

5.1.1、说明

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
  • 全部eq(或个别isNull)

个别参数说明:
params ：key 为数据库字段名, value 为字段值。
null2IsNull ：为 true 则在 map 的 value 为 null 时调⽤ isNull ⽅法,为 false 时则忽略 value 为 null 的。

boolean condition：这个参数表示该条件是否加入最后生成的sql中，false表示不加入。

  • 例1: allEq({id:1,name:"⽼王",age:null}) ---> id = 1 and name = '⽼王' and age is null
  • 例2: allEq({id:1,name:"⽼王",age:null}, false) ---> id = 1 and name = '⽼王'
allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter,Map<R, V> params, boolean null2IsNull)

个别参数说明:
filter : 过滤函数,是否允许字段传⼊⽐对条件中；
params 与 null2IsNull : 同上。

  • 例1: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"⽼王",age:null}) ---> name = '⽼ 王' and age is null
  • 例2: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"⽼王",age:null}, false) ---> name= '⽼王'

5.1.2、测试⽤例

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

     @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //设置条件
        Map<String, Object> params = new HashMap<>();
        params.put("name", "jack");
        params.put("age", null);

        /*
         无 filter过滤器
         */
        // sql语句--> SELECT * FROM user WHERE name = ? AND age IS NULL
        wrapper.allEq(params);

        // sql语句--> SELECT * FROM user WHERE name = ?
        wrapper.allEq(params,false);

        /*
         有 filter过滤器
         */
        // sql语句--> SELECT * FROM user WHERE name = ? AND age IS NULL
        wrapper.allEq((k, v) -> (k.equals("name") || k.equals("age")),params);
        
        // sql语句--> SELECT * FROM user WHERE name = ?
        wrapper.allEq((k, v) -> (k.equals("name")),params);
       

        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

5.2、基本⽐较操作

  • eq -- 等于 =
  • ne -- 不等于 <>
  • gt -- ⼤于 >
  • ge -- ⼤于等于 >=
  • lt -- ⼩于 <
  • le -- ⼩于等于 <=
  • between -- BETWEEN 值1 AND 值2
  • notBetween -- NOT BETWEEN 值1 AND 值2
  • in -- 字段 IN (value.get(0), value.get(1), ...)
  • notIn -- 字段 NOT IN (v0, v1, ...)

测试⽤例：

package com.zm.mp;

import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //SELECT * FROM user WHERE password = ? AND age >= ? AND name IN (?,?,?)
        wrapper.eq("email", "[email protected]")
               .ge("age", 20)
               .in("name", "jack", "jone", "tom");

        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

5.3、模糊查询

  • like -- LIKE '%值%' -- 例: like("name", "王") ---> name like '%王%'
  • notLike -- NOT LIKE '%值%' -- 例: notLike("name", "王") ---> name not like '%王%'
  • likeLeft -- LIKE '%值' 例: likeLeft("name", "王") ---> name like '%王'
  • likeRight -- LIKE '值%' -- 例: likeRight("name", "王") ---> name like '王%'

测试⽤例：

package com.zm.mp;
import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //SELECT * FROM user WHERE name LIKE ?
        // 即：查询姓名中 包含'子' 的这条数据
        //Parameters: %⼦%(String)
        wrapper.like("name", "⼦");
      
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

5.4、排序

  • orderBy -- 排序：ORDER BY 字段, ... -- 例: orderBy(true, true, "id", "name") ---> order by id ASC,name ASC
  • orderByAsc（正序或升序） -- 排序：ORDER BY 字段, ... ASC --- 例: orderByAsc("id", "name") ---> order by id ASC,name ASC
  • orderByDesc（倒序或降序） -- 排序：ORDER BY 字段, ... DESC -- 例: orderByDesc("id", "name") ---> order by id DESC,name DESC

测试⽤例：

package com.zm.mp;
import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        
        // SELECT * FROM user ORDER BY age DESC
        // 根据年龄倒序排序查找
        wrapper.orderByDesc("age");
        
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

5.5、逻辑查询

  • or -- 拼接 OR -- 主动调⽤ or 表示紧接着下⼀个⽅法不是⽤ and 连接!(不调⽤ or 则默认为使⽤ and 连接)
  • and -- AND 嵌套 -- 例: and(i -> i.eq("name", "李⽩").ne("status", "活着")) ---> and (name = '李⽩' and status <> '活着')

测试⽤例：

package com.zm.mp;
import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        
       //SELECT * FROM user WHERE name = ? OR age = ?
        wrapper.eq("name", "jack").or().eq("age", 24);
       
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

5.6、select

在MP查询中，默认查询所有的字段。如果有需要也可以通过select⽅法进⾏指定字段查询。

package com.zm.mp;
import com.zm.mp.mapper.UserMapper;
import com.zm.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testWrapper() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        
        //SELECT id,name FROM user WHERE name = ? OR age = ?
        wrapper.eq("name", "jack")
               .or()
               .eq("age", 24)
               .select("id", "name");
        
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

6. ActiveRecord

ActiveRecord（简称AR）⼀直⼴受动态语⾔（ PHP 、 Ruby 等）的喜爱，⽽ Java 作为准静态语⾔，对于ActiveRecord 往往只能感叹其优雅，所以我们也在 AR 道路上进⾏了⼀定的探索，希望⼤家能够喜欢（来自官网）。

什么是ActiveRecord？
ActiveRecord也属于ORM（对象关系映射）层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很⼤程度的快速实现模型的操作，⽽且简洁易懂。

ActiveRecord的主要思想是：

  • 每⼀个数据库表对应创建⼀个类，类的每⼀个对象实例对应于数据库中表的⼀⾏记录；通常表的每个字段在类中都有相应的Field；
  • ActiveRecord同时负责把⾃⼰持久化，在ActiveRecord中封装了对数据库的访问，即CURD;；
  • ActiveRecord是⼀种领域模型(Domain Model)，封装了部分业务逻辑；

6.1、开启AR之旅

在MP中，开启AR⾮常简单，只需要将实体对象继承Model即可。

package com.zm.mp.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User extends Model<User> {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

注意： 使用AR模式除了实体对象继承Model外，还必须存在一个对应的原始mapper（比如这个项目中User实体 对应的UserMapper）并继承BaseMapper。

6.2、根据主键查询

在之前的案例中我们查询都是先注入对应的userMapper ，然后用userMapper去调用对应的selectById()方法。但在AR模式下我们直接用user对象调用对应的方法即可，因为我们已经继承了Model。

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    /*
       AR模式下根据ID查询操作
     */
    @Test
    public void testAR() {
        User user = new User();
        user.setId(2L);
        User user2 = user.selectById();
        System.out.println(user2);
    }
}

6.3、新增数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    /*
       AR模式下插入操作
     */
    @Test
    public void testARInsert() {
        User user = new User();
        user.setName("李四");
        user.setAge(30);
        user.setEmail("[email protected]");
        boolean insert = user.insert();
        System.out.println(insert);
    }
}

日志结果：

[main] [com.zm.mp.mapper.UserMapper.insert]-[DEBUG] ==> Preparing: INSERT INTO
user ( name, age, email ) VALUES ( ?, ?, ? )
[main] [com.zm.mp.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 李四(String),
30(Integer), [email protected](String)
[main] [com.zm.mp.mapper.UserMapper.insert]-[DEBUG] <== Updates: 1

6.4、更新操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    /*
       AR模式下更新操作
     */
    @Test
    public void testARUpdate() {
        User user = new User();
        user.setId(8L);
        user.setAge(35);
        boolean update = user.updateById();
        System.out.println(update);
    }
}

日志结果：

[main] [com.zm.mp.mapper.UserMapper.updateById]-[DEBUG] ==> Preparing: UPDATE
user SET age=? WHERE id=?
[main] [com.zm.mp.mapper.UserMapper.updateById]-[DEBUG] ==> Parameters: 35(Integer),
8(Long)
[main] [com.zm.mp.mapper.UserMapper.updateById]-[DEBUG] <== Updates: 1

6.5、删除操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    /*
       AR模式下删除记录
     */
    @Test
    public void testARDelete() {
        User user = new User();
        user.setId(7L);
        boolean delete = user.deleteById();
        System.out.println(delete);
    }
}

6.6、根据条件查询

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;

    /*
       AR模式下根据条件查询：查询年龄大于等于20 的记录
    */
    @Test
    public void testARFindById() {
        User user = new User();
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.ge("age", "20");
        List<User> users = user.selectList(userQueryWrapper);
        for (User user1 : users) {
            System.out.println(user1);
        }
    }
}

7. 插件

7.1、mybatis的插件机制

MyBatis 允许你在已映射语句执⾏过程中的某⼀点进⾏拦截调⽤。默认情况下，MyBatis 允许使⽤插件来拦截的⽅法调⽤包括：

  1. Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
  2. ParameterHandler (getParameterObject, setParameters)
  3. ResultSetHandler (handleResultSets, handleOutputParameters)
  4. StatementHandler (prepare, parameterize, batch, update, query)

我们看到了可以拦截Executor接⼝的部分⽅法，⽐如update，query，commit，rollback等⽅法，还有其他接⼝的⼀些⽅法等。

总体概括为：

  1. 拦截执⾏器的⽅法
  2. 拦截参数的处理
  3. 拦截结果集的处理
  4. 拦截Sql语法构建的处理

拦截器示例：

package com.zm.plugins;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import java.util.Properties;

@Intercepts({@Signature(
        type = Executor.class,
        method = "update",
        args = {MappedStatement.class, Object.class})})
public class MyInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //拦截⽅法，具体业务逻辑编写的位置
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        //创建target对象的代理对象,⽬的是将当前拦截器加⼊到该对象中
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        //属性设置
    }
}

注⼊到Spring容器：

/**
 * ⾃定义拦截器
 */
@Bean
public MyInterceptor myInterceptor(){
        return new MyInterceptor();
}

或者通过xml配置，mybatis-config.xml：

   <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <plugins>
            <plugin interceptor="com.zm.plugins.MyInterceptor"></plugin>
        </plugins>
    </configuration>

7.2、执⾏分析插件

在MP中提供了对SQL执⾏的分析的插件，可⽤作阻断全表更新、删除的操作。

注意：该插件仅适⽤于开发环境，不适⽤于⽣产环境。

SpringBoot配置：

@Bean
public SqlExplainInterceptor sqlExplainInterceptor(){
        SqlExplainInterceptor sqlExplainInterceptor=new SqlExplainInterceptor();

        List<ISqlParser> sqlParserList=new ArrayList<>();

        // 攻击 SQL 阻断解析器、加⼊解析链
        sqlParserList.add(new BlockAttackSqlParser());
        sqlExplainInterceptor.setSqlParserList(sqlParserList);

        return sqlExplainInterceptor;
}

测试：

@Test
public void testUpdate(){
        User user=new User();
        user.setAge(20);
        int result=this.userMapper.update(user,null);
        System.out.println("result = "+result);
}

结果：

Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Prohibition
of table update operation
 at com.baomidou.mybatisplus.core.toolkit.ExceptionUtils.mpe(ExceptionUtils.java:49)
 at com.baomidou.mybatisplus.core.toolkit.Assert.isTrue(Assert.java:38)
 at com.baomidou.mybatisplus.core.toolkit.Assert.notNull(Assert.java:72)
 at
com.baomidou.mybatisplus.extension.parsers.BlockAttackSqlParser.processUpdate(BlockAtta
ckSqlParser.java:45)
 at
com.baomidou.mybatisplus.core.parser.AbstractJsqlParser.processParser(AbstractJsqlParse
r.java:92)
 at
com.baomidou.mybatisplus.core.parser.AbstractJsqlParser.parser(AbstractJsqlParser.java:
67)
 at
com.baomidou.mybatisplus.extension.handlers.AbstractSqlParserHandler.sqlParser(Abstract
SqlParserHandler.java:76)
 at
com.baomidou.mybatisplus.extension.plugins.SqlExplainInterceptor.intercept(SqlExplainIn
terceptor.java:63)
 at org.apache.ibatis.plugin.Plugin.invoke(Plugin.java:61)
 at com.sun.proxy.$Proxy70.update(Unknown Source)
 at
org.apache.ibatis.session.defaults.DefaultSqlSession.update(DefaultSqlSession.java:197)
 ... 41 more

可以看到，当执⾏全表更新时，会抛出异常，这样有效防⽌了⼀些误操作。

7.3、性能分析插件

性能分析拦截器，⽤于输出每条 SQL 语句及其执⾏时间，可以设置最⼤执⾏时间，超过时间会抛出异常。

该插件只⽤于开发环境，不建议⽣产环境使⽤。

配置：
javaconfig⽅式：

@Bean
public PerformanceInterceptor performanceInterceptor(){
        PerformanceInterceptor performanceInterceptor=new PerformanceInterceptor();
        
        // 设置sql语句的最大执行时间（单位毫秒） 
        performanceInterceptor.setMaxTime(100);
        
        // 设置sql是否格式化显示
        performanceInterceptor.setFormat(true);
        
        return performanceInterceptor;
}

xml⽅式：

 <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <plugins>
            <!-- SQL 执⾏性能分析，开发环境使⽤，线上不推荐。 maxTime 指的是 sql 最⼤执⾏时⻓ -->
            <plugin
                    interceptor="com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor">
                <property name="maxTime" value="100"/>
                <!--SQL是否格式化 默认false-->
                <property name="format" value="true"/>
            </plugin>
        </plugins>
    </configuration>

执⾏结果：

可以看到，执⾏时间为75ms。如果将maxTime设置为1，那么，该操作会抛出异常:

7.4、乐观锁插件

乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果冲突，则返回给用户异常信息，让用户决定如何去做。乐观锁适用于读多写少的场景，这样可以提高程序的吞吐量。

7.4.1、主要适⽤场景

意图：
当要更新⼀条记录的时候，希望这条记录没有被别⼈更新。

乐观锁实现⽅式：

  • 取出记录时，获取当前version；
  • 更新时，带上这个version；
  • 执⾏更新时， set version = newVersion where version = oldVersion；
  • 如果version不对，就更新失败。

7.4.2、插件配置

spring xml（xml方式）：

<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>

spring boot（javaconfig方式）：

@Configuration
@MapperScan("com.zm.mapper")
public class MybatisPlusConfig {
    

    /*
      旧版。  这里就以旧版进行演示
    */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

    /*
       // 新版。 注意：使用新版时mybatis-plus版本要求在3.4.0 版本以上
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
    */

}

7.4.3、注解实体字段

需要为实体字段添加@Version注解。
第⼀步，为表添加version字段，并且设置初始值为1：

ALTER TABLE `user`
ADD COLUMN `version` int(10) NULL AFTER `email`;

UPDATE `user` SET `version`='1';

第⼆步，为User实体对象添加version字段，并且添加@Version注解：

@Version
private Integer version;

7.4.4、测试更新

测试⽤例：

@Test
    public void testUpdate03(){

        //第一步：查询id为6的用户
        User user = userMapper.selectById(6L);

        //第二步：对该用户信息进行修改
        user.setName("张三_update");

        //第三步：执行更新操作
        int i = userMapper.updateById(user);
        System.out.println(i);

    }

执⾏结果：

通过日志记录可以看到，更新的条件中有version条件，并且更新的version为2。

模拟一下并发过程 事务一修改数据未提交、事务二执行插入（乐观锁插件本质）。

@Test
    void testUpdate04(){
        // 线程1 查询id为6的用户
        User user1 = userMapper.selectById(6L);
        // 线程1 对用户信息进行修改
        user1.setName("change By user1");

        // 线程2 查询id为6的用户
        User user2 = userMapper.selectById(6L);
        // 线程B 对用户信息进行修改
        user2.setName("chang By user2");

        // 执行更新操作
        int i2 = userMapper.updateById(user2);
        int i1 = userMapper.updateById(user1);
        System.out.println("user2修改结果："+i2 );
        System.out.println("user1修改结果："+i1 );
    }

运行结果：事务1 更新失败，事务2更新成功

7.4.5、特别说明

  • ⽀持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
  • 整数类型下 newVersion = oldVersion + 1
  • newVersion 会回写到 entity 中
  • 仅⽀持 updateById(id) 与 update(entity, wrapper) ⽅法
  • 在 update(entity, wrapper) ⽅法下, wrapper 不能复⽤!!!

8. Sql 注⼊器

我们已经知道，在MP中，通过AbstractSqlInjector将BaseMapper中的⽅法注⼊到了Mybatis容器，这样这些⽅法才可以正常执⾏。

那么，如果我们需要扩充BaseMapper中的⽅法，⼜该如何实现呢？

下⾯我们以扩展findAll⽅法为例进⾏学习。

8.1、编写MyBaseMapper继承BaseMapper

package com.zm.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;

/*
  通用mapper接口，以后创建其他mapper接口时，不在继承BaseMapper，而是继承MyBaseMapper
*/
public interface MyBaseMapper<T> extends BaseMapper<T> {
 List<T> findAll();
}

其他的Mapper都可以继承该Mapper，这样实现了统⼀的扩展。
如：

package com.zm.mapper;
import com.zm.pojo.User;

public interface UserMapper extends MyBaseMapper<User> {
 User findById(Long id);
}

8.2、编写MySqlInjector（自定义sql注入器）

如果直接继承AbstractSqlInjector的话，原有的BaseMapper中的⽅法将失效，所以我们选择继承
DefaultSqlInjector进⾏扩展。

package com.zm.sqlInjector;
import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
import java.util.List;

public class MySqlInjector extends DefaultSqlInjector {
    @Override
    public List<AbstractMethod> getMethodList() {
        List<AbstractMethod> methodList = super.getMethodList();
        // 再扩充⾃定义的⽅法
        methodList.add(new FindAll());

       
        return methodList;
    }
}

8.3、编写FindAll

package com.zm.sqlInjector;
import com.baomidou.mybatisplus.core.enums.SqlMethod;
import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;

public class FindAll extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        String sqlMethod = "findAll";
        String sql = "select * from " + tableInfo.getTableName();
        SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
        return this.addSelectMappedStatement(mapperClass, sqlMethod, sqlSource, modelClass, tableInfo);
    }
}

8.4、注册到Spring容器

/**
* ⾃定义SQL注⼊器
*/
@Bean
public MySqlInjector mySqlInjector(){
 return new MySqlInjector();
}

8.5、测试

@Test
public void testFindAll(){
   List<User> users = this.userMapper.findAll();
   for (User user : users) {
      System.out.println(user);
   }
}

运行结果：

⾄此，我们实现了全局扩展SQL注⼊器。

9. ⾃动填充功能

有些时候我们可能会有这样的需求，插⼊或者更新数据时，希望有些字段可以⾃动填充数据，⽐如密码、version等。在MP中提供了这样的功能，可以实现⾃动填充。

9.1、添加@TableField注解

@TableField(fill = FieldFill.INSERT) //插⼊数据时进⾏填充
private String version;

为version属性添加⾃动填充功能，在新增数据时有效。
FieldFill提供了多种模式选择：

public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插⼊时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插⼊和更新时填充字段
     */
    INSERT_UPDATE
}

9.2、自定义实现类实现元对象处理接口。

package com.zm.handler;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

@Component // 生成MyMetaObjectHandler 的实例对象存到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
       
            //字段为空，可以进⾏填充
            setFieldValByName("version", 1, metaObject);
        
    }

    @Override
    public void updateFill(MetaObject metaObject) {
    }
}

9.3、测试

@Test
public void testInsert(){
        User user=new User();
        user.setName("老王");
        user.setAge(18);
        user.setEmail("[email protected]");
        
        int result=this.userMapper.insert(user);
        System.out.println("result = "+result);
}

结果：通过结果我们可以看到数据库中version字段的值添加上了，自动填充成功。

注意事项：

  • 填充原理是直接给**entity**的属性设置值!!!
  • 注解则是指定该属性在对应情况下必有值,如果无值则入库会是null
  • **MetaObjectHandler提供的默认方法的策略均为:如果属性有值则不覆盖,如果填充值为null**则不填充
  • 字段必须声明TableField注解,属性fill选择对应策略,该声明告知Mybatis-Plus需要预留注入SQL字段
  • 填充处理器MyMetaObjectHandler在 Spring Boot 中需要声明@Component或@Bean注入
  • 要想根据注解FieldFill.xxx和字段名以及字段类型来区分必须使用父类的strictInsertFill或者strictUpdateFill方法
  • 不需要根据任何来区分可以使用父类的fillStrategy方法
  • update(T t,Wrapper updateWrapper)时t不能为空,否则自动填充失效

10. 逻辑删除

开发系统时，有时候在实现功能时，删除操作需要实现逻辑删除，所谓逻辑删除就是将数据标记为删除，⽽并⾮真正的物理删除（⾮DELETE操作），查询时需要携带状态条件，确保被标记的数据不被查询到。这样做的⽬的就是避免数据被真正的删除。

MP就提供了这样的功能，⽅便我们使⽤，接下来我们⼀起学习下。

10.1、修改表结构

为tb_user表增加deleted字段，⽤于表示数据是否被删除，1代表删除，0代表未删除。

ALTER TABLE `user`
ADD COLUMN `deleted` int(1) NULL DEFAULT 0 COMMENT '1代表删除，0代表未删除' AFTER `version`;

同时，也修改User实体，增加deleted属性并且添加**@TableLogic**注解：

@TableLogic
private Integer deleted;

10.2、配置

application.properties：

# 逻辑已删除值(默认为 1)
mybatis-plus.global-config.db-config.logic-delete-value=1
# 逻辑未删除值(默认为 0)
mybatis-plus.global-config.db-config.logic-not-delete-value=0

10.3、测试

 /*
   删除id为8的记录
  */
@Test
public void testDeleteById(){
  this.userMapper.deleteById(8L);
}

执⾏的日志与结果：

测试查询：

    /*
       查询id为8的记录
     */
    @Test
    public void selectById() {
        User user = this.userMapper.selectById(8L);
        System.out.println("查询到的结果为：" + user);
    }

执⾏的日志与结果：

至此，已经实现了逻辑删除。

11. 代码⽣成器

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

11.1、创建一个新的springboot⼯程

pom.xml：

<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.3.4.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>

        <groupId>com.zm</groupId>
        <artifactId>zm-mp-generator</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>zm-mp-generator</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>11</java.version>
        </properties>

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <!--mybatis-plus的springboot⽀持-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.1.1</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-generator</artifactId>
                <version>3.1.1</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-freemarker</artifactId>
            </dependency>
            <!--mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </dependency>
            <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>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

11.2、代码

package com.zm.generator;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.FileOutConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

/**
 * <p>
 * mysql 代码⽣成器演示例⼦
 * </p>
 */
public class MysqlGenerator {
    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输⼊" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输⼊正确的" + tip + "！");
    }

    /**
     * RUN THIS
     */
    public static void main(String[] args) {
        // 代码⽣成器
        AutoGenerator mpg = new AutoGenerator();
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("zm");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp? useUnicode = true & useSSL = false & characterEncoding = utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        pc.setParent("com.zm.mp.generator");
        mpg.setPackageInfo(pc);

        // ⾃定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        List<FileOutConfig> focList = new ArrayList<>();
        focList.add(new FileOutConfig("/templates/mapper.xml.ftl") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // ⾃定义输⼊⽂件名称
                return projectPath + "/zm-mp-generator/src/main/resources/mapper/" +
                        pc.getModuleName() + "/" + tableInfo.getEntityName() + "Mapper" +
                        StringPool.DOT_XML;
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        mpg.setTemplate(new TemplateConfig().setXml(null));
        
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);

        //strategy.setSuperEntityClass("com.baomidou.mybatisplus.samples.generator.common.BaseEnt ity");
        strategy.setEntityLombokModel(true);

        //strategy.setSuperControllerClass("com.baomidou.mybatisplus.samples.generator.common.BaseController");
        strategy.setInclude(scanner("表名"));
        strategy.setSuperEntityColumns("id");
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        
        // 选择 freemarker 引擎需要指定如下加，注意 pom 依赖必须有！
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}

通过测试发现，代码已经生成。结构如下：

12. MybatisX 快速开发插件

MybatisX 是⼀款基于 IDEA 的快速开发插件，为效率⽽⽣。
安装⽅法：打开 IDEA，进⼊ File -> Settings -> Plugins，输⼊ mybatisx 搜索并安装。
功能：

  • Java 与 XML 调回跳转

  • Mapper ⽅法⾃动⽣成 XML

标签： mybatis java mysql
本文转载自: https://blog.csdn.net/bier_zm/article/details/125808590
版权归原作者 YMeng_Zhang 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Mybatis-Plus详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

IDE Eval Resetter 安装和配置指南

docker compose入门7—详解build命令

推送到 Git 返回错误代码 403 致命：HTTP 请求失败

大数据毕业设计python基于Hadoop的租房数据分析系统

Flink流处理与网络安全

云服务器3——安装及配置Hadoop

Kafka+RabbitMQ+ActiveMQ看看消息队列设计精要14

文章导航