MyBatis-Plus - 深入进阶

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` bigint(20) NULL DEFAULT NULL COMMENT '主键',
  `name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int(11) NULL DEFAULT NULL COMMENT '年龄',
  `email` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
  `manager_id` bigint(20) NULL DEFAULT NULL COMMENT '直属上级id',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
  `version` int(11) NULL DEFAULT 1 COMMENT '版本',
  `deleted` int(1) NULL DEFAULT 0 COMMENT '逻辑删除标识（0，未删除；1，已删除）'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `user` VALUES (1234, '大boss', 40, '[email protected]', NULL, '2019-10-02 10:08:02', '2019-10-02 10:08:05', 1, 0);
INSERT INTO `user` VALUES (2345, '王天风', 25, '[email protected]', 1234, '2019-10-02 10:09:07', '2019-10-02 10:09:10', 1, 0);
INSERT INTO `user` VALUES (2346, '李艺伟', 28, '[email protected]', 2345, '2019-10-02 10:10:09', '2019-10-02 10:10:12', 1, 0);
INSERT INTO `user` VALUES (3456, '张雨绮', 31, '[email protected]', 2345, '2019-10-02 10:10:54', '2019-10-02 10:10:58', 1, 0);
INSERT INTO `user` VALUES (4566, '刘雨红', 32, '[email protected]', 2345, '2019-10-02 10:11:51', '2019-10-02 10:11:55', 1, 0);
SET FOREIGN_KEY_CHECKS = 1;

逻辑删除

设定逻辑删除规则

在配置文件中配置逻辑删除和逻辑未删除的值

mybatis-plus:
  global-config:
      logic-not-delete-value: 0
      logic-delete-value: 1

在pojo类中在逻辑删除的字段加注解@TableLogic

@Data
@EqualsAndHashCode(callSuper = false)
public class User extends Model<User> {
    @TableId(type = IdType.AUTO)
    private Long id;
    @TableField(condition = SqlCondition.LIKE)
    private String name;
    private Integer age;
    private String email;
    private Long managerId;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private Integer version;
    @TableLogic
    private Integer deleted;
}

测试

通过id逻辑删除

@Test
public void deleteById(){
    userMapper.deleteById(4566L);
}

查询中排除删除标识字段及注意事项

逻辑删除字段只是为了标识数据是否被逻辑删除，在查询的时候，并不想也将该字段查询出来。

我们只需要在delete字段上增加@TableField(select = false)mybatisplus在查询的时候就会自动忽略该字段。

@Test
public void selectIgnoreDeleteTest(){
    userMapper.selectById(3456L);
}

其他测试

package com.dsf.mp.fakeDelete.dao;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsf.mp.fakeDelete.FakeDeleteApp;
import com.dsf.mp.fakeDelete.entity.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.time.format.DateTimeFormatter;
import java.util.List;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = FakeDeleteApp.class)
public class UserMapperTest {
    @Autowired
    UserMapper userMapper;


    @Test
    public void insert() {
        User user = new User();
        user.setName("刘明强");
        user.setAge(31);
        user.setManagerId(1088248166370832385L);
        user.setEmail("[email protected]");
        int row = userMapper.insert(user);
        System.out.println("影响记录数："+row);
    }


    @Test
    public void deleteById(){
        int rows = userMapper.deleteById(1171357729945505793L);
        System.out.println("影响行数："+rows);
    }

    @Test
    public void selectById(){
        User user = userMapper.selectById(1171357729945505793L);
        System.out.println(user);
    }

    @Test
    public void updateById(){
        User user = new User();
        user.setAge(32);
        user.setId(1171357729945505793L);
        int rows = userMapper.updateById(user);
        System.out.println("影响行数："+rows);
    }

    @Test
    public void mySelectList(){
        List<User> list = userMapper.mySelectList(
            Wrappers.<User>lambdaQuery()
//                .select(User.class,x->!x.getColumn().equals("deleted"))   //方式1
                .select(User.class,x->!x.isLogicDelete())   //方式2
                .gt(User::getAge, 25)
                .eq(User::getDeleted,0)
        );
        list.forEach(System.out::println);
    }
}

自定义sql，MybatisPlus不会忽略deleted属性，需要我们手动忽略。

自动填充

MybaitsPlus在我们插入数据或者更新数据的时候，为我们提供了自动填充功能。类似MySQL提供的默认值一样。

如果我们需要使用自动填充功能，我们需要在实体类的相应属性上加@TableField注解，并指定什么时候进行自动填充。mybatisPlus为我们提供了三种填充时机，在FieldFill枚举中。

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

设置好之后，我们还需要编写具体的填充规则，具体是编写一个填充类并交给Spring管理，然后实现MetaObjectHandler接口中的insertFill和updateFill方法。

Eg：

插入User对象的时候自动填充插入时间，更新User对象的时候自动填充更新时间。

指定实体类中需要自动填充的字段，并设置填充时机。

@Data
@EqualsAndHashCode(callSuper = false)
public class User extends Model<User> {
    ...
    @TableField(fill = INSERT)
    private LocalDateTime createTime;
    @TableField(fill = UPDATE)
    private LocalDateTime updateTime;
    ...
}

编写填充规则

@Component
public class MyMetaObjHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        if(metaObject.hasSetter("createTime")){
            setInsertFieldValByName("createTime", LocalDateTime.now(),metaObject);
        }
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        if(metaObject.hasSetter("updateTime")){
            setUpdateFieldValByName("updateTime",LocalDateTime.now(),metaObject);
        }
    }
}

解释一下为什么要用if判断是否有对应的属性

mybatisPlus在执行插入或者更新操作的时候，每次都会执行该方法，有些表中是没有设置自动填充字段的，而且有些自动填充字段的值的获取比较消耗系统性能，所以为了不必要的消耗，进行if判断，决定是否需要填充。

有些时候我们已经设置了属性的值。不想让mybatisPlus再自动填充，也就是说我们没有设置属性的值，mybatisPlus进行填充，如果设置了那么就用我们设置的值。这种情况我们只需要在填充类中提前获取默认值，然后使用该默认值就可以了。

@Override
public void updateFill(MetaObject metaObject) {
    if(metaObject.hasSetter("updateTime")){
        Object updateTime = getFieldValByName("updateTime", metaObject);
        if(Objects.nonNull(updateTime)){
            setUpdateFieldValByName("updateTime",updateTime,metaObject);
        }else{
            setUpdateFieldValByName("updateTime",LocalDateTime.now(),metaObject);
        }
    }
}

对 @TableField(fill = FieldFill.INSERT_UPDATE) 理解

并不是有了这个注解就能进到MyMetaObjHandler，更不是注解了1个字段进去1次，注解了2个字段进去2次，并不是的，只要我们实现了MyMetaObjHandler就都可以进去的，而且一次UPDATE OR INSERT操作只会进一次；只是是否对该字段拥有写入权限的问题，只要被标注，就会在自定义的MyMetaObjHandler里进行对该字段有写入权限，否则哪怕set了，也没效果。

乐观锁

乐观锁适用于读多写少的情况，更新数据的时候不使用“锁“而是使用版本号来判断是否可以更新数据。通过不加锁来减小数据更新时间和系统的性能消耗，进而提高数据库的吞吐量。CAS机制就是一种典型的乐观锁的形式。

乐观锁是逻辑存在的一种概念，我们如果使用乐观锁需要手动在表的加上version字段。

mysql使用乐观锁伪代码示例：

update user 
set balabala....
where balabala... and version = xxx

配置类中注入乐观锁插件

@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor(){
    return new OptimisticLockerInterceptor();
}

实体类中的版本字段增加@version注解

@Data
@EqualsAndHashCode(callSuper = false)
public class User extends Model<User> {
    ...
    @Version
    private Integer version;
    ...
}

测试：更新王天风的年龄

@Test
public void testLock(){
    int version = 1;
    User user = new User();
    user.setEmail("[email protected]");
    user.setAge(34);
    user.setId(2345L);
    user.setManagerId(1234L);
    user.setVersion(1);
    userMapper.updateById(user);

}

数据库中的version已经变成2

/**
 * 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
 * 原因：
 *   每应用一次QueryWrapper,都会自动为where子句添加一次version=?，两次应用就会添加两次，
 *   出现形如“where ... and version=2 and version=3”的情况
 * 解决：
 *   重新创建一个QueryWrapper对象
 */
@Test
public void update() throws InterruptedException {
    User user = userMapper.selectById(1171357729945505793L);
    user.setAge(34);

    LambdaQueryWrapper<User> query = Wrappers.<User>lambdaQuery().eq(User::getId, user.getId());

    int rows1 = userMapper.update(user,query);//第一次用query
    System.out.println("影响行数："+rows1);


    user = userMapper.selectById(1171357729945505793L);
    user.setAge(35);
    int rows2 = userMapper.update(user,query);//复用query
    System.out.println("影响行数："+rows2);
}

注意事项

支持的类型只有：int，Integer，long，Long，Date，Timestamp，LocalDateTime
整数类型下 newVerison = oldVersion+1
newVersion会写到entity中
仅支持updateById(id)与update(entity,wrapper)方法
在update(entiry,wrapper)方法下，wrapper不能复用

性能分析

配置类中注入性能分析插件

@Bean
// @Profile({"dev,test"})
public PerformanceInterceptor performanceInterceptor() {
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    // 格式化sql输出
    performanceInterceptor.setFormat(true);
    // 设置sql执行最大时间，单位（ms）
    performanceInterceptor.setMaxTime(5L);

    return performanceInterceptor;
}

执行sql就可以打印sql执行的信息了

开启性能分析会消耗系统的性能，所以性能分析插件要配合@Profile注解执行使用的环境。

依靠第三方插件美化 SQL 输出

https://mp.baomidou.com/guide/p6spy.html

第三方依赖

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.8.5</version>
</dependency>

更改配置文件中的dirver和url

spring:
  datasource:
#    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
#    url: jdbc:mysql://localhost:3306/test?serverTimezone=CTT&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://localhost:3306/test?serverTimezone=CTT&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true

增加spy.properties配置文件

module.log=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,batch,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

测试

打印到文件

开启美化SQL插件会消耗系统的性能，所以插件要配合@Profile注解执行使用的环境。

多租户

常用情景：一条记录操作者的自动赋值！

过滤方式：传统过滤、注解过滤。

过滤维度：表级过滤、SQL语句过滤。

package com.dsf.mp.tenant.dao;

import com.baomidou.mybatisplus.annotation.SqlParser;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.dsf.mp.tenant.entity.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface UserMapper extends BaseMapper<User> {

    //通过注解的方式过滤掉自定义sql方法的sql解析，false-不过滤sql解析，true-过滤sql解析
    @SqlParser(filter = true)
    @Select("select * from user ${ew.customSqlSegment}")
    List<User> mySelectList(@Param(Constants.WRAPPER)Wrapper<User> wrapper);
}

package com.dsf.mp.tenant.configuration;

import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.core.parser.ISqlParserFilter;
import com.baomidou.mybatisplus.core.parser.SqlParserHelper;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantHandler;
import com.baomidou.mybatisplus.extension.plugins.tenant.TenantSqlParser;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;

@Configuration
public class MybatisPlusConf {

    @Bean
    PaginationInterceptor paginationInterceptor(){
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        ArrayList<ISqlParser> sqlParsersList = new ArrayList<>();
        TenantSqlParser tenantSqlParser = new TenantSqlParser();
        tenantSqlParser.setTenantHandler(new TenantHandler() {

            /**
             * 租户ID，通常指公司代码或ID，获取途径包括：session、配置文件、枚举类、cookie、redis
             * 这里的ID是写死的，实际项目中要想办法获取
             */
            @Override
            public Expression getTenantId() {
                return new LongValue(1088248166370832385L);
            }

            /**
             * 指定租户ID的表列名
             */
            @Override
            public String getTenantIdColumn() {
                return "manager_id";
            }

            /**
             * 过滤掉（即不引入）哪些表的多租户功能
             * false-过滤，默认； true-不过滤；
             */
            @Override
            public boolean doTableFilter(String tableName) {
                if("user".equals(tableName)){
                    return false;
                }
                return true;
            }
        });

        sqlParsersList.add(tenantSqlParser);
        paginationInterceptor.setSqlParserList(sqlParsersList);

        /**
         * 过滤掉（即不引入）哪些方法的sql解析（即不进行多租户功能）
         */
        paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
            @Override
            public boolean doFilter(MetaObject metaObject) {
                MappedStatement ms = SqlParserHelper.getMappedStatement(metaObject);
                if("com.dsf.mp.tenant.dao.UserMapper.selectById".equals(ms.getId())){
                    return true;
                }
                return false;
            }
        });

        return paginationInterceptor;
    }
}

package com.dsf.mp.tenant;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.dsf.mp.tenant.dao")
public class TenantApp {
    public static void main(String[] args) {
        SpringApplication.run(TenantApp.class, args);
    }
}

package com.dsf.mp.tenant.dao;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsf.mp.tenant.TenantApp;
import com.dsf.mp.tenant.entity.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;
import static org.junit.Assert.*;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = TenantApp.class)
public class UserMapperTest {
    @Autowired
    UserMapper userMapper;

    /**
     * 测试多租户查询方法
     * 效果：where ... and manager_id=1088248166370832385
     */
    @Test
    public void selectList(){
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }

    /**
     * 测试多租户更新方法
     */
    @Test
    public void updateById(){
        User user = userMapper.selectById(1094592041087729666L);
        user.setAge(34);
        int rows = userMapper.updateById(user);
        System.out.println("受影响的行数："+rows);
    }

    /**
     * 测试多租户插入方法
     */
    @Test
    public void insert(){
        User user = new User();
        user.setName("李国民");
        user.setAge(29);
        user.setEmail("[email protected]");
        int rows = userMapper.insert(user);
        System.out.println("受影响的行数："+rows);
    }


    /**
     * 测试过滤掉内置方法的多租户功能
     */
    @Test
    public void selectById(){
        User user = userMapper.selectById(1094590409767661570L);
        System.out.println(user);
    }

    /**
     * 测试过滤掉自定义方法的多租户功能
     */
    @Test
    public void mySelectList(){
        List<User> list = userMapper.mySelectList(
            Wrappers.<User>lambdaQuery().gt(User::getAge,30)
        );
        list.forEach(System.out::println);
    }
}

# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://testhost:3306/mp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: '#Dsf135246'

# 配置日志
logging:
  level:
    root: warn
    com.dsf.mp.tenant.dao: trace
  pattern:
    console: '%p%m%n'

mybatis-plus:
  mapper-locations: ['classpath:/mapper/*Mapper.xml']
#  global-config.sql-parser-cache: true  #3.1.1以上版本不需要配置该项

动态表名

应用场景：同样的表分表时的操作！

package com.dsf.mp.dynamicTableNameParser.entity;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class User {
    private Long id;

    private String name;

    private Integer age;

    private String email;

    private Long managerId;

    private LocalDateTime createTime;

    private  LocalDateTime updateTime;

    private  Integer version;

    private  Integer deleted;

}


package com.dsf.mp.dynamicTableNameParser.dao;

import com.baomidou.mybatisplus.annotation.SqlParser;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.dsf.mp.dynamicTableNameParser.entity.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface UserMapper extends BaseMapper<User> {

    // 通过注解的方式过滤掉自定义sql方法的sql解析，false-不过滤sql解析，true-过滤sql解析
    @SqlParser(filter = false)
    @Select("select * from user ${ew.customSqlSegment}")
    List<User> mySelectList(@Param(Constants.WRAPPER) Wrapper<User> wrapper);
}

package com.dsf.mp.dynamicTableNameParser.configuration;

import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.core.parser.ISqlParserFilter;
import com.baomidou.mybatisplus.core.parser.SqlParserHelper;
import com.baomidou.mybatisplus.extension.parsers.DynamicTableNameParser;
import com.baomidou.mybatisplus.extension.parsers.ITableNameHandler;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class MybatisPlusConf {
    //user动态表存放对象
    public static ThreadLocal<String> myTableName=new ThreadLocal<>();

    @Bean
    PaginationInterceptor paginationInterceptor(){
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        ArrayList<ISqlParser> sqlParsersList = new ArrayList<>();

        //动态表名解析器
        Map<String, ITableNameHandler> tableNameHandlerMap = new HashMap<>();
        tableNameHandlerMap.put("user", new ITableNameHandler() {
            @Override
            public String dynamicTableName(MetaObject metaObject, String sql, String tableName) {
                return myTableName.get();
            }
        });

        DynamicTableNameParser dynamicTableNameParser = new DynamicTableNameParser();
        dynamicTableNameParser.setTableNameHandlerMap(tableNameHandlerMap);
        sqlParsersList.add(dynamicTableNameParser);

        paginationInterceptor.setSqlParserList(sqlParsersList);

        /**
         * 过滤掉（即不引入）哪些方法的sql解析功能（即不进行动态表名替换）
         */
        paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
            @Override
            public boolean doFilter(MetaObject metaObject) {
                MappedStatement ms = SqlParserHelper.getMappedStatement(metaObject);
                if("com.dsf.mp.dynamicTableNameParser.dao.UserMapper.selectById".equals(ms.getId())){
                    return true;
                }
                return false;
            }
        });

        return paginationInterceptor;
    }
}

# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://testhost:3306/mp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: '#Dsf135246'

# 配置日志
logging:
  level:
    root: warn
    com.dsf.mp.dynamicTableNameParser.dao: trace
  pattern:
    console: '%p%m%n'

mybatis-plus:
  mapper-locations: ['classpath:/mapper/*Mapper.xml']

package com.dsf.mp.dynamicTableNameParser.dao;

import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsf.mp.dynamicTableNameParser.DynamicTableNameParserApp;
import com.dsf.mp.dynamicTableNameParser.configuration.MybatisPlusConf;
import com.dsf.mp.dynamicTableNameParser.entity.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;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DynamicTableNameParserApp.class)
public class UserMapperTest {
    @Autowired
    UserMapper userMapper;

    /**
     * 测试动态表名查询方法
     */
    @Test
    public void selectList(){
        MybatisPlusConf.myTableName.set("user_2019");
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }

    /**
     * 测试动态表名更新方法
     */
    @Test
    public void updateById(){
        MybatisPlusConf.myTableName.set("user_2019");
        User user = userMapper.selectById(1094592041087729666L);
        user.setAge(34);
        int rows = userMapper.updateById(user);
        System.out.println("受影响的行数："+rows);
    }

    /**
     * 测试动态表名插入方法
     */
    @Test
    public void insert(){
        MybatisPlusConf.myTableName.set("user_2019");
        User user = new User();
        user.setName("李国民");
        user.setAge(29);
        user.setEmail("[email protected]");
        int rows = userMapper.insert(user);
        System.out.println("受影响的行数："+rows);
    }


    /**
     * 测试过滤掉内置方法的动态表名
     */
    @Test
    public void selectById(){
        MybatisPlusConf.myTableName.set("user_2019");
        User user = userMapper.selectById(1094590409767661570L);
        System.out.println(user);
    }

    /**
     * 测试过滤掉自定义方法的动态表名
     */
    @Test
    public void mySelectList(){
        MybatisPlusConf.myTableName.set("user_2019");
        List<User> list = userMapper.mySelectList(
            Wrappers.<User>lambdaQuery().gt(User::getAge,30)
        );
        list.forEach(System.out::println);
    }
}

SQL注入器：封装自定义通用SQL

实现步骤

创建定义方法的类
创建注入器
在mapper中加入自定义方法

package com.dsf.mp.sqlInjector.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import java.time.LocalDateTime;

@Data
public class User {
    private Long id;

    private String name;

    @TableField(fill= FieldFill.UPDATE)
    private Integer age;

    private String email;

    private Long managerId;


    private LocalDateTime createTime;

    private  LocalDateTime updateTime;

    private  Integer version;

    @TableLogic
    @TableField(select=false)
    private  Integer deleted;
}

package com.dsf.mp.sqlInjector.component.method;

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 DeleteAllMethod extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        //执行的sql
        String sql = "delete from "+tableInfo.getTableName();

        //mapper接口的方法名
        String method = "deleteAll";

        SqlSource sqlSource = languageDriver.createSqlSource(configuration,sql,modelClass);
        return addDeleteMappedStatement(mapperClass,method,sqlSource);
    }
}

package com.dsf.mp.sqlInjector.dao;

import com.baomidou.mybatisplus.annotation.SqlParser;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.dsf.mp.sqlInjector.entity.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;

public interface UserMapper extends MyBaseMapper<User> {
    @SqlParser(filter = true)
    @Select("select * from user ${ew.customSqlSegment}")
    List<User> mySelectList(@Param(Constants.WRAPPER) Wrapper<User> wrapper);

    //如果只想在本接口中调用自定义的method可以直接写到这里
//    int deleteAll();
}

package com.dsf.mp.sqlInjector.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import java.util.List;

public interface MyBaseMapper<T> extends BaseMapper<T> {

    int deleteAll();

    int insertBatchSomeColumn(List<T> list);

    int deleteByIdWithFill(T t);

    int alwaysUpdateSomeColumnById(@Param((Constants.ENTITY)) T entity);
}

package com.dsf.mp.sqlInjector.component;

import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
import com.baomidou.mybatisplus.extension.injector.methods.additional.AlwaysUpdateSomeColumnById;
import com.baomidou.mybatisplus.extension.injector.methods.additional.InsertBatchSomeColumn;
import com.baomidou.mybatisplus.extension.injector.methods.additional.LogicDeleteByIdWithFill;
import com.dsf.mp.sqlInjector.component.method.DeleteAllMethod;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class MySqlInjector extends DefaultSqlInjector {
    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass) {
        //一定要调用super.getMethodList,否则内置的方法全都不能用了
        List<AbstractMethod> methodList = super.getMethodList(mapperClass);

        //添加自定的方法组件：删除全部
        methodList.add(new DeleteAllMethod());

        //添加选装件：批量插入
//        methodList.add(new InsertBatchSomeColumn(x->!x.isLogicDelete()));
        methodList.add(new InsertBatchSomeColumn(x->!x.isLogicDelete()&&!x.getColumn().equals("age")));//构造器中指定哪些字段插入，哪些不插入

        //添加选装件：逻辑删除并填充
        methodList.add(new LogicDeleteByIdWithFill());

        //添加选装件：根据id更新固定的字段
        methodList.add(new AlwaysUpdateSomeColumnById(x->!x.getColumn().equals("name")));//构造器中指定哪些字段更新，哪些不更新

        return methodList;
    }
}

除了自定义的类，还有一些MP官方自带的选装件。

package com.dsf.mp.sqlInjector.dao;

import com.dsf.mp.sqlInjector.SqlInjectorApp;
import com.dsf.mp.sqlInjector.entity.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;
import static org.junit.Assert.*;

@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SqlInjectorApp.class)
public class UserMapperTest {
    @Autowired
    UserMapper userMapper;

    /**
     * 测试自定义方法组件：删除全部
     */
    @Test
    public void deleteAll(){
        int rows = userMapper.deleteAll();
        System.out.println("受影响的行数："+rows);
    }

    /**
     * 测试选装件：批量删除
     * 如果插入时字段为null，则不管数据库是否设置默认值，插入的数据均是null
     */
    @Test
    public void insertBatchSomeColumn(){
        User user1 = new User();
        user1.setName("李兴华");
        user1.setAge(34);
        user1.setManagerId(1088248166370832385L);

        User user2 = new User();
        user2.setName("杨红");
        user2.setAge(29);
        user2.setManagerId(1088248166370832385L);

        List<User> asList= Arrays.asList(user1,user2);
        int rows = userMapper.insertBatchSomeColumn(asList);
        System.out.println("受影响的行数"+rows);

    }

    /**
     * 测试选装件：逻辑删除并填充
     */
    @Test
    public void deleteByIdWithFill(){
        User user = userMapper.selectById(1171846939462836226L);
//        user.setAge(23);

        int rows = userMapper.deleteByIdWithFill(user);

        System.out.println("受影响的行数"+rows);
    }

    /**
     * 测试选装件：根据id更新固定的字段
     */
    @Test
    public void alwaysUpdateSomeColumnById(){
        User user = userMapper.selectById(1088248166370832385L);
        user.setAge(26);
        user.setName("王地缝");

        int rows = userMapper.alwaysUpdateSomeColumnById(user);

        System.out.println("受影响的行数"+rows);
    }

}