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, 'boss@163.com', NULL, '2019-10-02 10:08:02', '2019-10-02 10:08:05', 1, 0);
INSERT INTO `user` VALUES (2345, '王天风', 25, 'wtf@163.com', 1234, '2019-10-02 10:09:07', '2019-10-02 10:09:10', 1, 0);
INSERT INTO `user` VALUES (2346, '李艺伟', 28, 'lyw@163.com', 2345, '2019-10-02 10:10:09', '2019-10-02 10:10:12', 1, 0);
INSERT INTO `user` VALUES (3456, '张雨绮', 31, 'zyq@163.com', 2345, '2019-10-02 10:10:54', '2019-10-02 10:10:58', 1, 0);
INSERT INTO `user` VALUES (4566, '刘雨红', 32, 'lyh@163.com', 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: 0logic-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;@TableLogicprivate 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 {@AutowiredUserMapper userMapper;@Testpublic void insert() {User user = new User();user.setName("刘明强");user.setAge(31);user.setManagerId(1088248166370832385L);user.setEmail("lmq@baomidou.com");int row = userMapper.insert(user);System.out.println("影响记录数："+row);}@Testpublic void deleteById(){int rows = userMapper.deleteById(1171357729945505793L);System.out.println("影响行数："+rows);}@Testpublic void selectById(){User user = userMapper.selectById(1171357729945505793L);System.out.println(user);}@Testpublic void updateById(){User user = new User();user.setAge(32);user.setId(1171357729945505793L);int rows = userMapper.updateById(user);System.out.println("影响行数："+rows);}@Testpublic 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方法。

插入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 {@Overridepublic void insertFill(MetaObject metaObject) {if(metaObject.hasSetter("createTime")){setInsertFieldValByName("createTime", LocalDateTime.now(),metaObject);}}@Overridepublic 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> {...@Versionprivate Integer version;...
}

测试：更新王天风的年龄

@Test
public void testLock(){int version = 1;User user = new User();user.setEmail("wtf@163.com");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);//第一次用querySystem.out.println("影响行数："+rows1);user = userMapper.selectById(1171357729945505793L);user.setAge(35);int rows2 = userMapper.update(user,query);//复用querySystem.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.Driverusername: rootpassword: root
#    url: jdbc:mysql://localhost:3306/test?serverTimezone=CTT&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=truedriver-class-name: com.p6spy.engine.spy.P6SpyDriverurl: 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 {@BeanPaginationInterceptor paginationInterceptor(){PaginationInterceptor paginationInterceptor = new PaginationInterceptor();ArrayList<ISqlParser> sqlParsersList = new ArrayList<>();TenantSqlParser tenantSqlParser = new TenantSqlParser();tenantSqlParser.setTenantHandler(new TenantHandler() {/*** 租户ID，通常指公司代码或ID，获取途径包括：session、配置文件、枚举类、cookie、redis* 这里的ID是写死的，实际项目中要想办法获取*/@Overridepublic Expression getTenantId() {return new LongValue(1088248166370832385L);}/*** 指定租户ID的表列名*/@Overridepublic String getTenantIdColumn() {return "manager_id";}/*** 过滤掉（即不引入）哪些表的多租户功能* false-过滤，默认； true-不过滤；*/@Overridepublic boolean doTableFilter(String tableName) {if("user".equals(tableName)){return false;}return true;}});sqlParsersList.add(tenantSqlParser);paginationInterceptor.setSqlParserList(sqlParsersList);/*** 过滤掉（即不引入）哪些方法的sql解析（即不进行多租户功能）*/paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {@Overridepublic 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 {@AutowiredUserMapper userMapper;/*** 测试多租户查询方法* 效果：where ... and manager_id=1088248166370832385*/@Testpublic void selectList(){List<User> list = userMapper.selectList(null);list.forEach(System.out::println);}/*** 测试多租户更新方法*/@Testpublic void updateById(){User user = userMapper.selectById(1094592041087729666L);user.setAge(34);int rows = userMapper.updateById(user);System.out.println("受影响的行数："+rows);}/*** 测试多租户插入方法*/@Testpublic void insert(){User user = new User();user.setName("李国民");user.setAge(29);user.setEmail("lgm@baomidou.com");int rows = userMapper.insert(user);System.out.println("受影响的行数："+rows);}/*** 测试过滤掉内置方法的多租户功能*/@Testpublic void selectById(){User user = userMapper.selectById(1094590409767661570L);System.out.println(user);}/*** 测试过滤掉自定义方法的多租户功能*/@Testpublic 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.Driverurl: jdbc:mysql://testhost:3306/mp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghaiusername: rootpassword: '#Dsf135246'# 配置日志
logging:level:root: warncom.dsf.mp.tenant.dao: tracepattern: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<>();@BeanPaginationInterceptor paginationInterceptor(){PaginationInterceptor paginationInterceptor = new PaginationInterceptor();ArrayList<ISqlParser> sqlParsersList = new ArrayList<>();//动态表名解析器Map<String, ITableNameHandler> tableNameHandlerMap = new HashMap<>();tableNameHandlerMap.put("user", new ITableNameHandler() {@Overridepublic 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() {@Overridepublic 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.Driverurl: jdbc:mysql://testhost:3306/mp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghaiusername: rootpassword: '#Dsf135246'# 配置日志
logging:level:root: warncom.dsf.mp.dynamicTableNameParser.dao: tracepattern: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 {@AutowiredUserMapper userMapper;/*** 测试动态表名查询方法*/@Testpublic void selectList(){MybatisPlusConf.myTableName.set("user_2019");List<User> list = userMapper.selectList(null);list.forEach(System.out::println);}/*** 测试动态表名更新方法*/@Testpublic void updateById(){MybatisPlusConf.myTableName.set("user_2019");User user = userMapper.selectById(1094592041087729666L);user.setAge(34);int rows = userMapper.updateById(user);System.out.println("受影响的行数："+rows);}/*** 测试动态表名插入方法*/@Testpublic void insert(){MybatisPlusConf.myTableName.set("user_2019");User user = new User();user.setName("李国民");user.setAge(29);user.setEmail("lgm@baomidou.com");int rows = userMapper.insert(user);System.out.println("受影响的行数："+rows);}/*** 测试过滤掉内置方法的动态表名*/@Testpublic void selectById(){MybatisPlusConf.myTableName.set("user_2019");User user = userMapper.selectById(1094590409767661570L);System.out.println(user);}/*** 测试过滤掉自定义方法的动态表名*/@Testpublic 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 {@Overridepublic MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {//执行的sqlString 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 {@Overridepublic 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 {@AutowiredUserMapper userMapper;/*** 测试自定义方法组件：删除全部*/@Testpublic void deleteAll(){int rows = userMapper.deleteAll();System.out.println("受影响的行数："+rows);}/*** 测试选装件：批量删除* 如果插入时字段为null，则不管数据库是否设置默认值，插入的数据均是null*/@Testpublic 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);}/*** 测试选装件：逻辑删除并填充*/@Testpublic void deleteByIdWithFill(){User user = userMapper.selectById(1171846939462836226L);
//        user.setAge(23);int rows = userMapper.deleteByIdWithFill(user);System.out.println("受影响的行数"+rows);}/*** 测试选装件：根据id更新固定的字段*/@Testpublic void alwaysUpdateSomeColumnById(){User user = userMapper.selectById(1088248166370832385L);user.setAge(26);user.setName("王地缝");int rows = userMapper.alwaysUpdateSomeColumnById(user);System.out.println("受影响的行数"+rows);}}