一个小BUG引发的对Mybatis-Plus的模糊查询的思考
前言
在 MySQL 中，模糊查询主要通过LIKE操作符与通配符配合使用来实现。其中，通配符%代表任意数量（包含零个）的字符，无论是数字、字母还是特殊字符，都能被它匹配。
比如，执行SELECT * FROM users WHERE username LIKE 'potter%';，这条 SQL 语句会从users表中查询出所有用户名以potter开头的记录，不管john后面跟着多少个字符。而通配符_则代表任意一个单独的字符，不论字符类型是什么。当执行SELECT * FROM users WHERE username LIKE '_p%';，该语句将查找出users表中所有用户名第二个字符为p的记录 ，至于p后面跟着多少个字符都不影响查询结果。
BUG产生原因：用户输入的查询条件就是通配符
当用户输入的查询条件中包含通配符%和_时，问题就出现了。假设我们有一个用户信息表users，表中有username字段。现在用户想要查询用户名中包含%字符的数据，比如用户名可能是 p%potter。如果直接将用户输入的 p%potter 作为模糊查询条件，SQL 语句可能会写成SELECT * FROM users WHERE username LIKE '%p%potter%'; ，此时 MySQL 会将条件中的%按照通配符的规则进行解析，它会尝试匹配包含 p 和 potter 的字符串，而不是我们期望的精确匹配 p%potter，这就导致查询结果与预期不符。
这种情况就是由于通配符在 SQL 语句中被错误解析，没有将其作为普通字符处理，从而引发了通配符转义问题。
如果当用户传递的查询参数就是%时，我们的SQL语句就会变成SELECT * FROM users WHERE username LIKE '%%%';，这样的查询结果并不会查询出username包含%的字符串，而是会查询出所有记录，如下：
解决方案：自定义MyBatis-Plus拦截器解决通配符转义问题
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.AbstractWrapper;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.lang.Nullable;import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.*;/*** 转义模糊查询参数中的特殊字符** @author potter*/
@Slf4j
public class EscapeLikeSqlInterceptor implements InnerInterceptor {/*** 点*/public static final String DOT = ".";/*** 按?分割字符串表达式*/public static final String PLACEHOLDER_REGEX = "\\?";/*** 按.分割字符串表达式*/public static final String DOT_REGEX = "\\.";/*** like操作通配符*/public static final char LIKE_WILDCARD_CHARACTER = '%';/*** like操作通常会存在的占位符形式*/public static final String PLACEHOLDER = "?";/*** 条件构造器生成sql特有的参数名前缀*/public static final String WRAPPER_PARAMETER_PROPERTY = "ew.paramNameValuePairs.";/*** like语句在sql中的字符串*/private final String LIKE_SQL = " like ";//private static final String SQL_SPECIAL_CHARACTER = "_%*@|&()[]\"'\\";// 达梦数据库不需要转义 ： * @ | & ( ) [ ] " ' \private static final String SQL_SPECIAL_CHARACTER = "_%";/*** 不应用此拦截器的参数名,方法参数中有此名称的参数则不应用此拦截器*/private final String IGNORE = "EscapeLikeSqlIgnore";private static final String PARAM_PREFIX = "__frch_";@Overridepublic void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {if (parameter instanceof Map) {Map<?, ?> parameterMap = (Map<?, ?>) parameter;if (parameterMap.containsKey(IGNORE)){return;}}if (needEscape(boundSql.getSql())) {return;}escapeSql(boundSql, true);}@Overridepublic void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {if (parameter instanceof Map) {Map<?, ?> parameterMap = (Map<?, ?>) parameter;if (parameterMap.containsKey(IGNORE)){return;}}BoundSql boundSql = ms.getBoundSql(parameter);if (needEscape(boundSql.getSql())) {return;}escapeSql(boundSql, false);}/*** sql是否需要转义*/private boolean needEscape(String sql) {return !containLike(sql) || !containPlaceholder(sql);}/*** sql是否包含like语句*/private boolean containLike(String sql) {return StrUtil.containsIgnoreCase(sql, LIKE_SQL);}/*** sql是否包含占位符*/private boolean containPlaceholder(String sql) {return StrUtil.containsIgnoreCase(sql, PLACEHOLDER);}/*** 参数名是否是条件构造器生成*/private boolean containWrapper(String property) {return StrUtil.contains(property, WRAPPER_PARAMETER_PROPERTY);}/*** 参数名是否是对象的嵌套表达式*/private boolean cascadeParameter(String property) {return StrUtil.contains(property, DOT);}/*** 转义sql语句中的特殊字符*/@SuppressWarnings("unchecked")private void escapeSql(BoundSql boundSql, boolean flag) {String[] split = boundSql.getSql().split(PLACEHOLDER_REGEX);Object parameter = boundSql.getParameterObject();Set<String> processedProperty = new HashSet<>();for (int i = 0; i < split.length; i++) {// like 通常在末尾if (StrUtil.lastIndexOfIgnoreCase(split[i], LIKE_SQL) > -1) {if (parameter instanceof Map) {// 拿到此位置的"?"对应的参数名String property = boundSql.getParameterMappings().get(i).getProperty();// 防止重复转义if (processedProperty.contains(property)){continue;}Map<Object, Object> parameterMap = (Map<Object, Object>) parameter;if (containWrapper(property)) {// 条件构造器构造sql方式handlerWrapperEscape(property, parameterMap);} else {// 自主写sql方式handlerOriginalSqlEscape(boundSql, property, parameterMap);}processedProperty.add(property);} else if (parameter instanceof String) {// 单条件&&不通过条件构造器&&直接写sql&&mapper不写@Param注解,会导致parameter直接为参数值而不是map
// BeanUtil.setFieldValue(boundSql, "parameterObject", SqlUtil.addSalashes((String) parameter));// 强行反射设置属性,暂不清楚为什么更改parameterObject无效BeanUtil.setFieldValue(boundSql.getParameterObject(), "value", addSplashes(((String) parameter)).toCharArray());}}}}/*** 处理通过条件构造器构造sql的转义** @param property 参数名* @param parameterObject 此条sql的参数map*/private void handlerWrapperEscape(String property, Map<?, ?> parameterObject) {String[] keys = property.split(DOT_REGEX);Object ew = parameterObject.get(keys[0]);if (ew instanceof AbstractWrapper) {Map<String, Object> paramNameValuePairs = ((AbstractWrapper<?, ?, ?>) ew).getParamNameValuePairs();// 拿到参数值Object paramValue = paramNameValuePairs.get(keys[2]);if (paramValue instanceof String && ((String) paramValue).startsWith("%") && ((String) paramValue).endsWith("%")) {// 去除首尾%并转义后再拼上%paramNameValuePairs.put(keys[2], String.format("%%%s%%", addSplashes((String) paramValue, LIKE_WILDCARD_CHARACTER)));}}}/*** 处理自己写sql的转义** @param property 参数名* @param parameterObject 此条sql的参数map*/private void handlerOriginalSqlEscape(BoundSql boundSql, String property, Map<Object, Object> parameterObject) {if (cascadeParameter(property)) {// 级联形式的参数,比如参数是对象中的某个字段的值:filter.nameString[] keys = property.split(DOT_REGEX, 2);Object parameterBean = parameterObject.get(keys[0]);Object parameterValue = BeanUtil.getProperty(parameterBean, keys[1]);if (parameterValue instanceof String) {BeanUtil.setProperty(parameterBean, keys[1], addSplashes((CharSequence) parameterValue));}} else if(property.startsWith(PARAM_PREFIX)){Object additionalParameter = boundSql.getAdditionalParameter(property);if(additionalParameter instanceof String){boundSql.setAdditionalParameter(property, addSplashes((CharSequence) additionalParameter));} else if (additionalParameter instanceof Collection) {boundSql.setAdditionalParameter(property,lists(additionalParameter));}}else {parameterObject.computeIfPresent(property, (key, value) -> {if (value instanceof String) {return addSplashes((CharSequence) value);}return value;});}}private List<?> lists(Object value) {List<?> list = (List<?>)value;List<Object> objects = new ArrayList<>();for (Object o : list) {if(o instanceof Collection){Object lists = lists(o);objects.add(lists);}else if(o instanceof String){String s = addSplashes(o.toString());objects.add(s);}else {objects.add(o);}}return objects;}private static String addSplashes(CharSequence content){return getString(content);}@Nullableprivate static String getString(CharSequence content) {if (StrUtil.isEmpty(content)) {return StrUtil.str(content);}StringBuilder sb = new StringBuilder();for (int i = 0; i < content.length(); i++) {char c = content.charAt(i);if (StrUtil.contains(SQL_SPECIAL_CHARACTER, c)) {sb.append('\\');}sb.append(c);}return sb.toString();}private static String addSplashes(String content){return getString(content);}private static String addSplashes(CharSequence content, char trimFix){if (content.charAt(0) == trimFix){content = content.subSequence(1,content.length());}if (content.charAt(content.length() - 1) == trimFix){content = content.subSequence(0,content.length() - 1);}return addSplashes(content);}}
配置拦截器, 在 Spring Boot 的配置类中注册自定义拦截器，代码如下@Configuration
public class CustomMybatisAutoConfiguration {@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();// 添加特殊字符转义拦截 注：mybatis-plus特殊字符转义要在分页拦截之前mybatisPlusInterceptor.addInnerInterceptor(new EscapeLikeSqlInterceptor());// 基于limit关键字分页mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 分页插件return mybatisPlusInterceptor;}
}
在上述配置类中，CustomMybatisAutoConfiguration类使用@Configuration注解声明为一个配置类。通过@Bean注解创建了MybatisPlusInterceptor实例，并将自定义拦截器EscapeLikeSqlInterceptor添加到MybatisPlusInterceptor中。这样，当 Spring Boot 应用启动时，自定义拦截器就会被注册到 MyBatis-Plus 的拦截器链中，在 SQL 查询执行前对参数进行通配符转义处理。