MyBatis-Plus - 论自定义 BaseMapper 方法『逻辑删』失效解决方案

本文主要是介绍MyBatis-Plus - 论自定义 BaseMapper 方法『逻辑删』失效解决方案，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

问题描述

在上一篇我们讲过 MyBatis-Plus - 论 1 个实体类被 N 个DAO 类绑定，导致 MP 特性（逻辑删）失效的解决方案-CSDN博客

所以在这个基础上，我们可以很好定位到源码的分析位置。

但是今天这个问题就更奇怪了，已经确保 1 个实体类只被 1 个 DAO 类绑定，可还是『逻辑删』失效啊~

于是，又开始苦逼的 Debug Mybatis-Plus 源码……

原因分析

再分析源码前，我们先得出几个现象级的结论

因为我们采用了 Allinone 的架构，所以才发现的问题
我们单独启动 A 服务是不会逻辑删失效，但是再加入个 B 服务，用 standalone 模式启动就失效了

先上一张关键图，我们看到红框这个在一开始的时候是 false，后来经过一顿操作变成了 true，以至于逻辑删生效，所以我们只需要关注这个 logicDelete 的变化逻辑是我们重点观察的对象

源码分析

无可厚非，这个 TableInfoHelper 类还是我们分析的重点

/** Copyright (c) 2011-2020, baomidou (jobob@qq.com).* <p>* Licensed under the Apache License, Version 2.0 (the "License"); you may not* use this file except in compliance with the License. You may obtain a copy of* the License at* <p>* https://www.apache.org/licenses/LICENSE-2.0* <p>* Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the* License for the specific language governing permissions and limitations under* the License.*/
package com.baomidou.mybatisplus.core.metadata;import com.baomidou.mybatisplus.annotation.*;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
import com.baomidou.mybatisplus.core.toolkit.*;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.builder.StaticSqlSource;
import org.apache.ibatis.executor.keygen.KeyGenerator;
import org.apache.ibatis.executor.keygen.SelectKeyGenerator;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.reflection.Reflector;
import org.apache.ibatis.reflection.ReflectorFactory;
import org.apache.ibatis.session.Configuration;
import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import static java.util.stream.Collectors.toList;/*** <p>* 实体类反射表辅助类* </p>** @author hubin sjy* @since 2016-09-09*/
public class TableInfoHelper {private static final Log logger = LogFactory.getLog(TableInfoHelper.class);/*** 储存反射类表信息*/private static final Map<Class<?>, TableInfo> TABLE_INFO_CACHE = new ConcurrentHashMap<>();/*** 默认表主键名称*/private static final String DEFAULT_ID_NAME = "id";/*** <p>* 获取实体映射表信息* </p>** @param clazz 反射实体类* @return 数据库表反射信息*/public static TableInfo getTableInfo(Class<?> clazz) {if (clazz == null|| ReflectionKit.isPrimitiveOrWrapper(clazz)|| clazz == String.class) {return null;}// https://github.com/baomidou/mybatis-plus/issues/299TableInfo tableInfo = TABLE_INFO_CACHE.get(ClassUtils.getUserClass(clazz));if (null != tableInfo) {return tableInfo;}//尝试获取父类缓存Class<?> currentClass = clazz;while (null == tableInfo && Object.class != currentClass) {currentClass = currentClass.getSuperclass();tableInfo = TABLE_INFO_CACHE.get(ClassUtils.getUserClass(currentClass));}if (tableInfo != null) {TABLE_INFO_CACHE.put(ClassUtils.getUserClass(clazz), tableInfo);}return tableInfo;}/*** <p>* 获取所有实体映射表信息* </p>** @return 数据库表反射信息集合*/@SuppressWarnings("unused")public static List<TableInfo> getTableInfos() {return new ArrayList<>(TABLE_INFO_CACHE.values());}/*** <p>* 实体类反射获取表信息【初始化】* </p>** @param clazz 反射实体类* @return 数据库表反射信息*/public synchronized static TableInfo initTableInfo(MapperBuilderAssistant builderAssistant, Class<?> clazz) {TableInfo tableInfo = TABLE_INFO_CACHE.get(clazz);if (tableInfo != null) {if (builderAssistant != null) {tableInfo.setConfiguration(builderAssistant.getConfiguration());}return tableInfo;}/* 没有获取到缓存信息,则初始化 */tableInfo = new TableInfo(clazz);GlobalConfig globalConfig;if (null != builderAssistant) {tableInfo.setCurrentNamespace(builderAssistant.getCurrentNamespace());tableInfo.setConfiguration(builderAssistant.getConfiguration());globalConfig = GlobalConfigUtils.getGlobalConfig(builderAssistant.getConfiguration());} else {// 兼容测试场景globalConfig = GlobalConfigUtils.defaults();}/* 初始化表名相关 */final String[] excludeProperty = initTableName(clazz, globalConfig, tableInfo);List<String> excludePropertyList = excludeProperty != null && excludeProperty.length > 0 ? Arrays.asList(excludeProperty) : Collections.emptyList();/* 初始化字段相关 */initTableFields(clazz, globalConfig, tableInfo, excludePropertyList);/* 放入缓存 */TABLE_INFO_CACHE.put(clazz, tableInfo);/* 缓存 lambda */LambdaUtils.installCache(tableInfo);/* 自动构建 resultMap */tableInfo.initResultMapIfNeed();return tableInfo;}/*** <p>* 初始化 表数据库类型,表名,resultMap* </p>** @param clazz        实体类* @param globalConfig 全局配置* @param tableInfo    数据库表反射信息* @return 需要排除的字段名*/private static String[] initTableName(Class<?> clazz, GlobalConfig globalConfig, TableInfo tableInfo) {/* 数据库全局配置 */GlobalConfig.DbConfig dbConfig = globalConfig.getDbConfig();TableName table = clazz.getAnnotation(TableName.class);String tableName = clazz.getSimpleName();String tablePrefix = dbConfig.getTablePrefix();String schema = dbConfig.getSchema();boolean tablePrefixEffect = true;String[] excludeProperty = null;if (table != null) {if (StringUtils.isNotBlank(table.value())) {tableName = table.value();if (StringUtils.isNotBlank(tablePrefix) && !table.keepGlobalPrefix()) {tablePrefixEffect = false;}} else {tableName = initTableNameWithDbConfig(tableName, dbConfig);}if (StringUtils.isNotBlank(table.schema())) {schema = table.schema();}/* 表结果集映射 */if (StringUtils.isNotBlank(table.resultMap())) {tableInfo.setResultMap(table.resultMap());}tableInfo.setAutoInitResultMap(table.autoResultMap());excludeProperty = table.excludeProperty();} else {tableName = initTableNameWithDbConfig(tableName, dbConfig);}String targetTableName = tableName;if (StringUtils.isNotBlank(tablePrefix) && tablePrefixEffect) {targetTableName = tablePrefix + targetTableName;}if (StringUtils.isNotBlank(schema)) {targetTableName = schema + StringPool.DOT + targetTableName;}tableInfo.setTableName(targetTableName);/* 开启了自定义 KEY 生成器 */if (null != dbConfig.getKeyGenerator()) {tableInfo.setKeySequence(clazz.getAnnotation(KeySequence.class));}return excludeProperty;}/*** 根据 DbConfig 初始化 表名** @param className 类名* @param dbConfig  DbConfig* @return 表名*/private static String initTableNameWithDbConfig(String className, GlobalConfig.DbConfig dbConfig) {String tableName = className;// 开启表名下划线申明if (dbConfig.isTableUnderline()) {tableName = StringUtils.camelToUnderline(tableName);}// 大写命名判断if (dbConfig.isCapitalMode()) {tableName = tableName.toUpperCase();} else {// 首字母小写tableName = StringUtils.firstToLowerCase(tableName);}return tableName;}/*** <p>* 初始化 表主键,表字段* </p>** @param clazz        实体类* @param globalConfig 全局配置* @param tableInfo    数据库表反射信息*/public static void initTableFields(Class<?> clazz, GlobalConfig globalConfig, TableInfo tableInfo, List<String> excludeProperty) {/* 数据库全局配置 */GlobalConfig.DbConfig dbConfig = globalConfig.getDbConfig();ReflectorFactory reflectorFactory = tableInfo.getConfiguration().getReflectorFactory();//TODO @咩咩 有空一起来撸完这反射模块.Reflector reflector = reflectorFactory.findForClass(clazz);List<Field> list = getAllFields(clazz);// 标记是否读取到主键boolean isReadPK = false;// 是否存在 @TableId 注解boolean existTableId = isExistTableId(list);List<TableFieldInfo> fieldList = new ArrayList<>(list.size());for (Field field : list) {if (excludeProperty.contains(field.getName())) {continue;}/* 主键ID 初始化 */if (existTableId) {TableId tableId = field.getAnnotation(TableId.class);if (tableId != null) {if (isReadPK) {throw ExceptionUtils.mpe("@TableId can't more than one in Class: \"%s\".", clazz.getName());} else {isReadPK = initTableIdWithAnnotation(dbConfig, tableInfo, field, tableId, reflector);continue;}}} else if (!isReadPK) {isReadPK = initTableIdWithoutAnnotation(dbConfig, tableInfo, field, reflector);if (isReadPK) {continue;}}/* 有 @TableField 注解的字段初始化 */if (initTableFieldWithAnnotation(dbConfig, tableInfo, fieldList, field)) {continue;}/* 无 @TableField 注解的字段初始化 */fieldList.add(new TableFieldInfo(dbConfig, tableInfo, field));}/* 检查逻辑删除字段只能有最多一个 */Assert.isTrue(fieldList.parallelStream().filter(TableFieldInfo::isLogicDelete).count() < 2L,String.format("@TableLogic can't more than one in Class: \"%s\".", clazz.getName()));/* 字段列表,不可变集合 */tableInfo.setFieldList(Collections.unmodifiableList(fieldList));/* 未发现主键注解，提示警告信息 */if (!isReadPK) {logger.warn(String.format("Can not find table primary key in Class: \"%s\".", clazz.getName()));}}/*** <p>* 判断主键注解是否存在* </p>** @param list 字段列表* @return true 为存在 @TableId 注解;*/public static boolean isExistTableId(List<Field> list) {return list.stream().anyMatch(field -> field.isAnnotationPresent(TableId.class));}/*** <p>* 主键属性初始化* </p>** @param dbConfig  全局配置信息* @param tableInfo 表信息* @param field     字段* @param tableId   注解* @param reflector Reflector*/private static boolean initTableIdWithAnnotation(GlobalConfig.DbConfig dbConfig, TableInfo tableInfo,Field field, TableId tableId, Reflector reflector) {boolean underCamel = tableInfo.isUnderCamel();final String property = field.getName();if (field.getAnnotation(TableField.class) != null) {logger.warn(String.format("This \"%s\" is the table primary key by @TableId annotation in Class: \"%s\",So @TableField annotation will not work!",property, tableInfo.getEntityType().getName()));}/* 主键策略（ 注解 > 全局 ） */// 设置 Sequence 其他策略无效if (IdType.NONE == tableId.type()) {tableInfo.setIdType(dbConfig.getIdType());} else {tableInfo.setIdType(tableId.type());}/* 字段 */String column = property;if (StringUtils.isNotBlank(tableId.value())) {column = tableId.value();} else {// 开启字段下划线申明if (underCamel) {column = StringUtils.camelToUnderline(column);}// 全局大写命名if (dbConfig.isCapitalMode()) {column = column.toUpperCase();}}tableInfo.setKeyRelated(checkRelated(underCamel, property, column)).setKeyColumn(column).setKeyProperty(property).setKeyType(reflector.getGetterType(property));return true;}/*** <p>* 主键属性初始化* </p>** @param tableInfo 表信息* @param field     字段* @param reflector Reflector* @return true 继续下一个属性判断，返回 continue;*/private static boolean initTableIdWithoutAnnotation(GlobalConfig.DbConfig dbConfig, TableInfo tableInfo,Field field, Reflector reflector) {final String property = field.getName();if (DEFAULT_ID_NAME.equalsIgnoreCase(property)) {if (field.getAnnotation(TableField.class) != null) {logger.warn(String.format("This \"%s\" is the table primary key by default name for `id` in Class: \"%s\",So @TableField will not work!",property, tableInfo.getEntityType().getName()));}String column = property;if (dbConfig.isCapitalMode()) {column = column.toUpperCase();}tableInfo.setKeyRelated(checkRelated(tableInfo.isUnderCamel(), property, column)).setIdType(dbConfig.getIdType()).setKeyColumn(column).setKeyProperty(property).setKeyType(reflector.getGetterType(property));return true;}return false;}/*** <p>* 字段属性初始化* </p>** @param dbConfig  数据库全局配置* @param tableInfo 表信息* @param fieldList 字段列表* @return true 继续下一个属性判断，返回 continue;*/private static boolean initTableFieldWithAnnotation(GlobalConfig.DbConfig dbConfig, TableInfo tableInfo,List<TableFieldInfo> fieldList, Field field) {/* 获取注解属性，自定义字段 */TableField tableField = field.getAnnotation(TableField.class);if (null == tableField) {return false;}fieldList.add(new TableFieldInfo(dbConfig, tableInfo, field, tableField));return true;}/*** <p>* 判定 related 的值* </p>** @param underCamel 驼峰命名* @param property   属性名* @param column     字段名* @return related*/public static boolean checkRelated(boolean underCamel, String property, String column) {if (StringUtils.isNotColumnName(column)) {// 首尾有转义符,手动在注解里设置了转义符,去除掉转义符column = column.substring(1, column.length() - 1);}String propertyUpper = property.toUpperCase(Locale.ENGLISH);String columnUpper = column.toUpperCase(Locale.ENGLISH);if (underCamel) {// 开启了驼峰并且 column 包含下划线return !(propertyUpper.equals(columnUpper) ||propertyUpper.equals(columnUpper.replace(StringPool.UNDERSCORE, StringPool.EMPTY)));} else {// 未开启驼峰,直接判断 property 是否与 column 相同(全大写)return !propertyUpper.equals(columnUpper);}}/*** <p>* 获取该类的所有属性列表* </p>** @param clazz 反射类* @return 属性集合*/public static List<Field> getAllFields(Class<?> clazz) {List<Field> fieldList = ReflectionKit.getFieldList(ClassUtils.getUserClass(clazz));return fieldList.stream().filter(field -> {/* 过滤注解非表字段属性 */TableField tableField = field.getAnnotation(TableField.class);return (tableField == null || tableField.exist());}).collect(toList());}public static KeyGenerator genKeyGenerator(String baseStatementId, TableInfo tableInfo, MapperBuilderAssistant builderAssistant) {IKeyGenerator keyGenerator = GlobalConfigUtils.getKeyGenerator(builderAssistant.getConfiguration());if (null == keyGenerator) {throw new IllegalArgumentException("not configure IKeyGenerator implementation class.");}Configuration configuration = builderAssistant.getConfiguration();//TODO 这里不加上builderAssistant.getCurrentNamespace()的会导致com.baomidou.mybatisplus.core.parser.SqlParserHelper.getSqlParserInfo越(chu)界(gui)String id = builderAssistant.getCurrentNamespace() + StringPool.DOT + baseStatementId + SelectKeyGenerator.SELECT_KEY_SUFFIX;ResultMap resultMap = new ResultMap.Builder(builderAssistant.getConfiguration(), id, tableInfo.getKeyType(), new ArrayList<>()).build();MappedStatement mappedStatement = new MappedStatement.Builder(builderAssistant.getConfiguration(), id,new StaticSqlSource(configuration, keyGenerator.executeSql(tableInfo.getKeySequence().value())), SqlCommandType.SELECT).keyProperty(tableInfo.getKeyProperty()).resultMaps(Collections.singletonList(resultMap)).build();configuration.addMappedStatement(mappedStatement);return new SelectKeyGenerator(mappedStatement, true);}
}

我们先看到这一行代码，经测试发现，经过了它 logicDelete 配置正确的前提下，此时会首次发生改变为 true（默认值：false）

/* 初始化字段相关 */
initTableFields(clazz, globalConfig, tableInfo, excludePropertyList);/**
* <p>
* 初始化 表主键,表字段
* </p>
*
* @param clazz        实体类
* @param globalConfig 全局配置
* @param tableInfo    数据库表反射信息
*/
public static void initTableFields(Class<?> clazz, GlobalConfig globalConfig, TableInfo tableInfo, List<String> excludeProperty) {// .../* 字段列表,不可变集合 */tableInfo.setFieldList(Collections.unmodifiableList(fieldList));// ...
}

紧接着这里要关注另一个重点类——TableInfo

/** Copyright (c) 2011-2020, baomidou (jobob@qq.com).* <p>* Licensed under the Apache License, Version 2.0 (the "License"); you may not* use this file except in compliance with the License. You may obtain a copy of* the License at* <p>* https://www.apache.org/licenses/LICENSE-2.0* <p>* Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the* License for the specific language governing permissions and limitations under* the License.*/
package com.baomidou.mybatisplus.core.metadata;import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.core.toolkit.sql.SqlScriptUtils;
import lombok.AccessLevel;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.apache.ibatis.mapping.ResultFlag;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.mapping.ResultMapping;
import org.apache.ibatis.session.Configuration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import static java.util.stream.Collectors.joining;/*** 数据库表反射信息** @author hubin* @since 2016-01-23*/
@Data
@Setter(AccessLevel.PACKAGE)
@Accessors(chain = true)
public class TableInfo implements Constants {/*** 实体类型*/private Class<?> entityType;/*** 表主键ID 类型*/private IdType idType = IdType.NONE;/*** 表名称*/private String tableName;/*** 表映射结果集*/private String resultMap;/*** 是否是需要自动生成的 resultMap*/private boolean autoInitResultMap;/*** 是否是自动生成的 resultMap*/private boolean initResultMap;/*** 主键是否有存在字段名与属性名关联* <p>true: 表示要进行 as</p>*/private boolean keyRelated;/*** 表主键ID 字段名*/private String keyColumn;/*** 表主键ID 属性名*/private String keyProperty;/*** 表主键ID 属性类型*/private Class<?> keyType;/*** 表主键ID Sequence*/private KeySequence keySequence;/*** 表字段信息列表*/private List<TableFieldInfo> fieldList;/*** 命名空间 (对应的 mapper 接口的全类名)*/private String currentNamespace;/*** MybatisConfiguration 标记 (Configuration内存地址值)*/@Getterprivate MybatisConfiguration configuration;/*** 是否开启逻辑删除*/@Setter(AccessLevel.NONE)private boolean logicDelete;/*** 是否开启下划线转驼峰*/private boolean underCamel;/*** 缓存包含主键及字段的 sql select*/@Setter(AccessLevel.NONE)@Getter(AccessLevel.NONE)private String allSqlSelect;/*** 缓存主键字段的 sql select*/@Setter(AccessLevel.NONE)@Getter(AccessLevel.NONE)private String sqlSelect;/*** 表字段是否启用了插入填充** @since 3.3.0*/@Getter@Setter(AccessLevel.NONE)private boolean withInsertFill;/*** 表字段是否启用了更新填充** @since 3.3.0*/@Getter@Setter(AccessLevel.NONE)private boolean withUpdateFill;/*** 表字段是否启用了乐观锁** @since 3.3.1*/@Getter@Setter(AccessLevel.NONE)private boolean withVersion;/*** 乐观锁字段** @since 3.3.1*/@Getter@Setter(AccessLevel.NONE)private TableFieldInfo versionFieldInfo;public TableInfo(Class<?> entityType) {this.entityType = entityType;}/*** 获得注入的 SQL Statement** @param sqlMethod MybatisPlus 支持 SQL 方法* @return SQL Statement*/public String getSqlStatement(String sqlMethod) {return currentNamespace + DOT + sqlMethod;}/*** 设置 Configuration*/void setConfiguration(Configuration configuration) {Assert.notNull(configuration, "Error: You need Initialize MybatisConfiguration !");this.configuration = (MybatisConfiguration) configuration;this.underCamel = configuration.isMapUnderscoreToCamelCase();}/*** 是否有主键** @return 是否有*/public boolean havePK() {return StringUtils.isNotBlank(keyColumn);}/*** 获取主键的 select sql 片段** @return sql 片段*/public String getKeySqlSelect() {if (sqlSelect != null) {return sqlSelect;}if (havePK()) {sqlSelect = keyColumn;if (keyRelated) {sqlSelect += (" AS " + keyProperty);}} else {sqlSelect = EMPTY;}return sqlSelect;}/*** 获取包含主键及字段的 select sql 片段** @return sql 片段*/public String getAllSqlSelect() {if (allSqlSelect != null) {return allSqlSelect;}allSqlSelect = chooseSelect(TableFieldInfo::isSelect);return allSqlSelect;}/*** 获取需要进行查询的 select sql 片段** @param predicate 过滤条件* @return sql 片段*/public String chooseSelect(Predicate<TableFieldInfo> predicate) {String sqlSelect = getKeySqlSelect();String fieldsSqlSelect = fieldList.stream().filter(predicate).map(TableFieldInfo::getSqlSelect).collect(joining(COMMA));if (StringUtils.isNotBlank(sqlSelect) && StringUtils.isNotBlank(fieldsSqlSelect)) {return sqlSelect + COMMA + fieldsSqlSelect;} else if (StringUtils.isNotBlank(fieldsSqlSelect)) {return fieldsSqlSelect;}return sqlSelect;}/*** 获取 insert 时候主键 sql 脚本片段* <p>insert into table (字段) values (值)</p>* <p>位于 "值" 部位</p>** @return sql 脚本片段*/public String getKeyInsertSqlProperty(final String prefix, final boolean newLine) {final String newPrefix = prefix == null ? EMPTY : prefix;if (havePK()) {if (idType == IdType.AUTO) {return EMPTY;}return SqlScriptUtils.safeParam(newPrefix + keyProperty) + COMMA + (newLine ? NEWLINE : EMPTY);}return EMPTY;}/*** 获取 insert 时候主键 sql 脚本片段* <p>insert into table (字段) values (值)</p>* <p>位于 "字段" 部位</p>** @return sql 脚本片段*/public String getKeyInsertSqlColumn(final boolean newLine) {if (havePK()) {if (idType == IdType.AUTO) {return EMPTY;}return keyColumn + COMMA + (newLine ? NEWLINE : EMPTY);}return EMPTY;}/*** 获取所有 insert 时候插入值 sql 脚本片段* <p>insert into table (字段) values (值)</p>* <p>位于 "值" 部位</p>** <li> 自动选部位,根据规则会生成 if 标签 </li>** @return sql 脚本片段*/public String getAllInsertSqlPropertyMaybeIf(final String prefix) {final String newPrefix = prefix == null ? EMPTY : prefix;return getKeyInsertSqlProperty(newPrefix, true) + fieldList.stream().map(i -> i.getInsertSqlPropertyMaybeIf(newPrefix)).filter(Objects::nonNull).collect(joining(NEWLINE));}/*** 获取 insert 时候字段 sql 脚本片段* <p>insert into table (字段) values (值)</p>* <p>位于 "字段" 部位</p>** <li> 自动选部位,根据规则会生成 if 标签 </li>** @return sql 脚本片段*/public String getAllInsertSqlColumnMaybeIf() {return getKeyInsertSqlColumn(true) + fieldList.stream().map(TableFieldInfo::getInsertSqlColumnMaybeIf).filter(Objects::nonNull).collect(joining(NEWLINE));}/*** 获取所有的查询的 sql 片段** @param ignoreLogicDelFiled 是否过滤掉逻辑删除字段* @param withId              是否包含 id 项* @param prefix              前缀* @return sql 脚本片段*/public String getAllSqlWhere(boolean ignoreLogicDelFiled, boolean withId, final String prefix) {final String newPrefix = prefix == null ? EMPTY : prefix;String filedSqlScript = fieldList.stream().filter(i -> {if (ignoreLogicDelFiled) {return !(isLogicDelete() && i.isLogicDelete());}return true;}).map(i -> i.getSqlWhere(newPrefix)).filter(Objects::nonNull).collect(joining(NEWLINE));if (!withId || StringUtils.isBlank(keyProperty)) {return filedSqlScript;}String newKeyProperty = newPrefix + keyProperty;String keySqlScript = keyColumn + EQUALS + SqlScriptUtils.safeParam(newKeyProperty);return SqlScriptUtils.convertIf(keySqlScript, String.format("%s != null", newKeyProperty), false)+ NEWLINE + filedSqlScript;}/*** 获取所有的 sql set 片段** @param ignoreLogicDelFiled 是否过滤掉逻辑删除字段* @param prefix              前缀* @return sql 脚本片段*/public String getAllSqlSet(boolean ignoreLogicDelFiled, final String prefix) {final String newPrefix = prefix == null ? EMPTY : prefix;return fieldList.stream().filter(i -> {if (ignoreLogicDelFiled) {return !(isLogicDelete() && i.isLogicDelete());}return true;}).map(i -> i.getSqlSet(newPrefix)).filter(Objects::nonNull).collect(joining(NEWLINE));}/*** 获取逻辑删除字段的 sql 脚本** @param startWithAnd 是否以 and 开头* @param isWhere      是否需要的是逻辑删除值* @return sql 脚本*/public String getLogicDeleteSql(boolean startWithAnd, boolean isWhere) {if (logicDelete) {TableFieldInfo field = fieldList.stream().filter(TableFieldInfo::isLogicDelete).findFirst().orElseThrow(() -> ExceptionUtils.mpe("can't find the logicFiled from table {%s}", tableName));String logicDeleteSql = formatLogicDeleteSql(field, isWhere);if (startWithAnd) {logicDeleteSql = " AND " + logicDeleteSql;}return logicDeleteSql;}return EMPTY;}/*** format logic delete SQL, can be overrided by subclass* github #1386** @param field   TableFieldInfo* @param isWhere true: logicDeleteValue, false: logicNotDeleteValue* @return*/private String formatLogicDeleteSql(TableFieldInfo field, boolean isWhere) {final String value = isWhere ? field.getLogicNotDeleteValue() : field.getLogicDeleteValue();if (isWhere) {if (NULL.equalsIgnoreCase(value)) {return field.getColumn() + " IS NULL";} else {return field.getColumn() + EQUALS + String.format(field.isCharSequence() ? "'%s'" : "%s", value);}}final String targetStr = field.getColumn() + EQUALS;if (NULL.equalsIgnoreCase(value)) {return targetStr + NULL;} else {return targetStr + String.format(field.isCharSequence() ? "'%s'" : "%s", value);}}/*** 自动构建 resultMap 并注入(如果条件符合的话)*/void initResultMapIfNeed() {if (autoInitResultMap && null == resultMap) {String id = currentNamespace + DOT + MYBATIS_PLUS + UNDERSCORE + entityType.getSimpleName();List<ResultMapping> resultMappings = new ArrayList<>();if (havePK()) {ResultMapping idMapping = new ResultMapping.Builder(configuration, keyProperty, keyColumn, keyType).flags(Collections.singletonList(ResultFlag.ID)).build();resultMappings.add(idMapping);}if (CollectionUtils.isNotEmpty(fieldList)) {fieldList.forEach(i -> resultMappings.add(i.getResultMapping(configuration)));}ResultMap resultMap = new ResultMap.Builder(configuration, id, entityType, resultMappings).build();configuration.addResultMap(resultMap);this.resultMap = id;}}void setFieldList(List<TableFieldInfo> fieldList) {this.fieldList = fieldList;fieldList.forEach(i -> {if (i.isLogicDelete()) {this.logicDelete = true;}if (i.isWithInsertFill()) {this.withInsertFill = true;}if (i.isWithUpdateFill()) {this.withUpdateFill = true;}if (i.isVersion()) {this.withVersion = true;this.versionFieldInfo = i;}});}
}

经删减，我们看到这——setFieldList，离赋值 true 真相越来越近

void setFieldList(List<TableFieldInfo> fieldList) {this.fieldList = fieldList;fieldList.forEach(i -> {if (i.isLogicDelete()) {this.logicDelete = true;}if (i.isWithInsertFill()) {this.withInsertFill = true;}if (i.isWithUpdateFill()) {this.withUpdateFill = true;}if (i.isVersion()) {this.withVersion = true;this.versionFieldInfo = i;}});
}

这两个值判空有没印象，就是我们 application.yml 全局配置 globalConfig 配置的时候赋上的噢~

/*** 是否启用了逻辑删除*/
public boolean isLogicDelete() {return StringUtils.isNotBlank(logicDeleteValue) && StringUtils.isNotBlank(logicNotDeleteValue);
}

到这里，才是我们搞清楚首次 logicDelete = true 的基本逻辑，离真相还需要进一步探索……

继续猜想，既然已经为 true 了，而且在 Allinone 架构中，由于多个服务在同一内存里，这个引用地址变量是不可能中途有变动的，所以排查这种情况。

那么到底是什么导致这个逻辑删失效呢？（logicDelete == false）

此时，我们再引入一个源码类——AbstractSqlInjector

/** Copyright (c) 2011-2020, baomidou (jobob@qq.com).* <p>* Licensed under the Apache License, Version 2.0 (the "License"); you may not* use this file except in compliance with the License. You may obtain a copy of* the License at* <p>* https://www.apache.org/licenses/LICENSE-2.0* <p>* Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the* License for the specific language governing permissions and limitations under* the License.*/
package com.baomidou.mybatisplus.core.injector;import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.GlobalConfigUtils;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.List;
import java.util.Set;/*** SQL 自动注入器** @author hubin* @since 2018-04-07*/
public abstract class AbstractSqlInjector implements ISqlInjector {private static final Log logger = LogFactory.getLog(AbstractSqlInjector.class);@Overridepublic 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(mapperClass);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);}}}/*** <p>* 获取 注入的方法* </p>** @param mapperClass 当前mapper* @return 注入的方法集合* @since 3.1.2 add  mapperClass*/public abstract List<AbstractMethod> getMethodList(Class<?> mapperClass);/*** 提取泛型模型,多泛型的时候请将泛型T放在第一位** @param mapperClass mapper 接口* @return mapper 泛型*/protected Class<?> extractModelClass(Class<?> mapperClass) {Type[] types = mapperClass.getGenericInterfaces();ParameterizedType target = null;for (Type type : types) {if (type instanceof ParameterizedType) {Type[] typeArray = ((ParameterizedType) type).getActualTypeArguments();if (ArrayUtils.isNotEmpty(typeArray)) {for (Type t : typeArray) {if (t instanceof TypeVariable || t instanceof WildcardType) {break;} else {target = (ParameterizedType) type;break;}}}break;}}return target == null ? null : (Class<?>) target.getActualTypeArguments()[0];}
}

我们接着重点来看这个方法——inspectInject

public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {// ...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.");}// ...
}

是不是很熟悉，对的，这就是我们调用之前一直讲的 initTableInfo 方法的入口，为什么要讲这个类呢？我们经过测试分析发现，这行代码执行完的时候，logicDelete 还是为 true 但是……

TableInfoHelper.initTableInfo(builderAssistant, modelClass);

当这行代码执行完之后，logicDelete 首次发生反转为 false，那这个方法我们仔细看会发现，他在做一件事情就是将 BaseMapper 里的所有方法生成模板 SQL

// 循环注入自定义方法
methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));

那么现在，这个要回到我们文章标题，既然说明了自定义 BaseMapper ，那我们看下我们自定义的 BaseMapper 搞了些啥？！

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import java.lang.reflect.Field;
import java.util.Objects;public interface DBaseMapper<T> extends BaseMapper<T> {/*** 根据 entity 条件, 删除记录(物理删除)** @param wrapper 实体对象封装操作类(可以为 null)*/int deletePhysically(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
}

继续来看 deletePhysically 方法

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;
import java.lang.reflect.Field;/*** @author Lux Sun* @date 2022/1/14*/
public class DeletePhysically extends AbstractMethod {@Overridepublic MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {// (1) DELETE FROM %s WHERE %s// (2) DELETE FROM t_test WHERE test_del=0 AND (id = ? AND test_del = ?)DSqlMethod dSqlMethod = DSqlMethod.DELETE;// 反射修改 logicDelete = false 否则生成 (2) 代码try {Field logicDelete = tableInfo.getClass().getDeclaredField("logicDelete");logicDelete.setAccessible(true);logicDelete.set(tableInfo, false);} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}// 生成 SQLString sql = String.format(dSqlMethod.getSql(), tableInfo.getTableName(),sqlWhereEntityWrapper(true, tableInfo),sqlComment());SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);// 第 2 个参数必须和 XxxMapper 的自定义方法名一致return this.addDeleteMappedStatement(mapperClass, dSqlMethod.getMethod(), sqlSource);}
}

看到这行，此时此刻的心情，恍然大悟

logicDelete.set(tableInfo, false);

灵魂拷问：为啥 A 服务单独启动并没有失效呢？而伴随 B 服务一起启动的时候失效了！

答案：因为 A 服务注入这个自定义方法的时候，是排在最后（如图所示），导致哪怕它最后 logicDelete 被改为 false 了也不会影响什么，但是 B 服务跟在 A 服务后面启动的时候，因为 DAO 是公共类，又再一次被扫描的时候，B 服务在执行以下源码的时候，因为 logicDelete 在上一个 A 服务最后被赋值为 false，导致此时所有的方法都失去了『逻辑删』特性

public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {// ...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.");}// ...
}

解决方案

因为这行代码是根据 tablinfo 的配置信息来生产最终的模板 SQL，所以只要在用完了之后，马上把原先的 logicDelete 还原即可

// 生成 SQL
String sql = String.format(dSqlMethod.getSql(), tableInfo.getTableName(),sqlWhereEntityWrapper(true, tableInfo),sqlComment());

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;
import java.lang.reflect.Field;/*** @author Lux Sun* @date 2022/1/14*/
public class DeletePhysically extends AbstractMethod {@Overridepublic MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {// (1) DELETE FROM %s WHERE %s// (2) DELETE FROM t_test WHERE test_del=0 AND (id = ? AND test_del = ?)DSqlMethod dSqlMethod = DSqlMethod.DELETE;// 反射修改 logicDelete = false 否则生成 (2) 代码try {boolean oriLogicDelete = tableInfo.isLogicDelete();Field logicDelete = tableInfo.getClass().getDeclaredField("logicDelete");logicDelete.setAccessible(true);logicDelete.set(tableInfo, false);// 生成 SQLString sql = String.format(dSqlMethod.getSql(), tableInfo.getTableName(),sqlWhereEntityWrapper(true, tableInfo),sqlComment());SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);// 还原原来的逻辑删配置logicDelete.set(tableInfo, oriLogicDelete);// 第 2 个参数必须和 XxxMapper 的自定义方法名一致return this.addDeleteMappedStatement(mapperClass, dSqlMethod.getMethod(), sqlSource);} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return null;}
}

这篇关于MyBatis-Plus - 论自定义 BaseMapper 方法『逻辑删』失效解决方案的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！