mybatis转义反斜杠_MyBatis Plus之like模糊查询中包含有特殊字符（_、\、%）

解决思路：自定义一个拦截器，当有模糊查询时，模糊查询的关键字中包含有上述特殊字符时，在该特殊字符前添加\进行转义处理。

一、问题提出

使用MyBatis中的模糊查询时，当查询关键字中包括有_、\、%时，查询关键字失效。

二、问题分析

1、当like中包含_时，查询仍为全部，即 like '%_%'查询出来的结果与like '%%'一致，并不能查询出实际字段中包含有_特殊字符的结果条目

2、like中包括%时，与1中相同

3、like中包含\时，带入查询时，%\%无法查询到包含字段中有\的条目

特殊字符

未处理

处理后

_

like '%_%'

like '%\_%'

%

like '%%%'

like '%\%%'

\

like '%\%'

`like '%\%'

ESCAPE '/'必须加在SQL的最后。

like '%\_%'效果与like concat('%', '\_', '%')相同

三、问题解决

1、自定义拦截器方法类

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.keyidea.boss.utils.EscapeUtil;

import org.apache.ibatis.executor.Executor;

import org.apache.ibatis.mapping.BoundSql;

import org.apache.ibatis.mapping.MappedStatement;

import org.apache.ibatis.plugin.*;

import org.apache.ibatis.session.ResultHandler;

import org.apache.ibatis.session.RowBounds;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Properties;

import java.util.Set;

/**

* 自定义拦截器方法，处理模糊查询中包含特殊字符(_、%、\)

*/

@Intercepts(@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,

RowBounds.class, ResultHandler.class}))

public class MyInterceptor implements Interceptor {

Logger LOGGER = LoggerFactory.getLogger(MyInterceptor.class);

@Override

public Object intercept(Invocation invocation) throws Throwable {

// 拦截sql

Object[] args = invocation.getArgs();

MappedStatement statement = (MappedStatement)args[0];

Object parameterObject = args[1];

BoundSql boundSql = statement.getBoundSql(parameterObject);

String sql = boundSql.getSql();

// 处理特殊字符

modifyLikeSql(sql, parameterObject, boundSql);

// 返回

return invocation.proceed();

}

@Override

public Object plugin(Object target) {

return Plugin.wrap(target, this);

}

@Override

public void setProperties(Properties properties) {

}

@SuppressWarnings("unchecked")

public static String modifyLikeSql(String sql, Object parameterObject, BoundSql boundSql) {

if (parameterObject instanceof HashMap) {

} else {

return sql;

}

if (!sql.toLowerCase().contains(" like ") || !sql.toLowerCase().contains("?")) {

return sql;

}

// 获取关键字的个数(去重)

String[] strList = sql.split("\\?");

Set keyNames = new HashSet<>();

for (int i = 0; i < strList.length; i++) {

if (strList[i].toLowerCase().contains(" like ")) {

String keyName = boundSql.getParameterMappings().get(i).getProperty();

keyNames.add(keyName);

}

}

// 对关键字进行特殊字符“清洗”，如果有特殊字符的，在特殊字符前添加转义字符(\)

for (String keyName : keyNames) {

HashMap parameter = (HashMap)parameterObject;

if (keyName.contains("ew.paramNameValuePairs.") && sql.toLowerCase().contains(" like ?")) {

// 第一种情况：在业务层进行条件构造产生的模糊查询关键字

QueryWrapper wrapper = (QueryWrapper)parameter.get("ew");

parameter = (HashMap)wrapper.getParamNameValuePairs();

String[] keyList = keyName.split("\\.");

// ew.paramNameValuePairs.MPGENVAL1，截取字符串之后，获取第三个，即为参数名

Object a = parameter.get(keyList[2]);

if (a instanceof String && (a.toString().contains("_") || a.toString().contains("\\") || a.toString()

.contains("%"))) {

parameter.put(keyList[2],

"%" + EscapeUtil.escapeChar(a.toString().substring(1, a.toString().length() - 1)) + "%");

}

} else if (!keyName.contains("ew.paramNameValuePairs.") && sql.toLowerCase().contains(" like ?")) {

// 第二种情况：未使用条件构造器，但是在service层进行了查询关键字与模糊查询符`%`手动拼接

Object a = parameter.get(keyName);

if (a instanceof String && (a.toString().contains("_") || a.toString().contains("\\") || a.toString()

.contains("%"))) {

parameter.put(keyName,

"%" + EscapeUtil.escapeChar(a.toString().substring(1, a.toString().length() - 1)) + "%");

}

} else {

// 第三种情况：在Mapper类的注解SQL中进行了模糊查询的拼接

Object a = parameter.get(keyName);

if (a instanceof String && (a.toString().contains("_") || a.toString().contains("\\") || a.toString()

.contains("%"))) {

parameter.put(keyName, EscapeUtil.escapeChar(a.toString()));

}

}

}

return sql;

}

}

2、在配置类中添加自定义拦截器

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;

import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;

import com.baomidou.mybatisplus.core.config.GlobalConfig;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;

import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;

import org.apache.ibatis.plugin.Interceptor;

import org.apache.ibatis.session.SqlSessionFactory;

import org.mybatis.spring.annotation.MapperScan;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

import java.util.ArrayList;

import java.util.List;

/**

* MyBatis配置数据源、sqlSessionFactory、事务管理器、分页插件、自定义拦截器等

*/

@Configuration

@MapperScan(basePackages = {"com.keyidea.boss.mapper"}, sqlSessionFactoryRef = "masterSqlSessionFactory")

public class MybatisPlusConfig {

@Autowired

private MybatisPlusProperties properties;

// 使用MyBatis中的分页插件

@Bean

public PaginationInterceptor paginationInterceptor() {

PaginationInterceptor page = new PaginationInterceptor();

return page;

}

// 自定义拦截器实现模糊查询中的特殊字符处理

@Bean

public MyInterceptor myInterceptor() {

MyInterceptor sql = new MyInterceptor();

return sql;

}

// 数据源配置

@Bean(name = "masterDataSource")

@ConfigurationProperties("spring.datasource")

@Primary

public DataSource masterDataSource() {

return DruidDataSourceBuilder.create().build();

}

// 配置sqlSessionFactory

@Bean(name = "masterSqlSessionFactory")

@Primary

public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource,

PaginationInterceptor paginationInterceptor, MyInterceptor myInterceptor) throws Exception {

final MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();

sessionFactory.setDataSource(dataSource);

if (this.properties.getConfigurationProperties() != null) {

sessionFactory.setConfigurationProperties(this.properties.getConfigurationProperties());

}

GlobalConfig globalConfig = this.properties.getGlobalConfig();

sessionFactory.setGlobalConfig(globalConfig);

// 设置MyBatis的插件/拦截器列表

List interceptors = new ArrayList<>();

interceptors.add(paginationInterceptor);

interceptors.add(myInterceptor);

sessionFactory.setPlugins(interceptors.toArray(new Interceptor[1]));

return sessionFactory.getObject();

}

// 设置事务管理器，在需要事务的service层使用如下注解进行事务管理

// @Transactional(transactionManager = "masterTransactionManager", rollbackFor = Exception.class)

@Bean(name = "masterTransactionManager")

public DataSourceTransactionManager masterTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) {

return new DataSourceTransactionManager(dataSource);

}

}

由于框架中使用多个数据源配置，因此使用数据库事务时，优先使用该事务时，需要在该方法上显著的添加@Primary注解

3、工具类：特殊字符转义

import org.apache.commons.lang3.StringUtils;

public class EscapeUtil {

//mysql的模糊查询时特殊字符转义

public static String escapeChar(String before){

if(StringUtils.isNotBlank(before)){

before = before.replaceAll("\\\\", "\\\\\\\\");

before = before.replaceAll("_", "\\\\_");

before = before.replaceAll("%", "\\\\%");

}

return before ;

}

}

4、引入依赖包，以下为参考项

build.gradle文件中的依赖如下

dependencies {

implementation 'org.springframework.boot:spring-boot-starter-web'

testImplementation 'org.springframework.boot:spring-boot-starter-test'

implementation 'org.springframework.boot:spring-boot-starter-aop'

implementation 'com.baomidou:mybatis-plus-boot-starter:3.1.0'

implementation 'com.alibaba:druid-spring-boot-starter:1.1.10'

implementation 'mysql:mysql-connector-java'

implementation 'org.apache.commons:commons-lang3:3.4'

implementation 'org.jeecg:easypoi-base:2.1.3'

implementation 'org.jeecg:easypoi-annotation:2.1.3'

implementation 'org.springframework.boot:spring-boot-starter-mail'

compile 'org.apache.httpcomponents:httpclient:4.3.1'

compile 'net.sf.json-lib:json-lib:2.4:jdk15'

}

四、重点关注

以上方法在关键字中包含有\可能会失效，失效的原因是由于查询的关键字的数据库字段排序规则为utf8_unicode_ci，如下图

字段排序规则为：utf8_unicode_ci

要想不失效，查询的关键字的排序规则必须为utf8_general_ci，如下图

字段排序规则为：utf8_general_ci

或者统一全部数据库字符集与排序规则分别为：utf8mb4与utf8mb4_general_ci，如下图

字段排序规则为：utf8mb4_general_ci

【END】

文章参考

特殊字符查询

动态修改SQL语句

排序规则参考

注解