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<String> 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<Interceptor> 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 ;
    }
}

重點關注

以上方法在關鍵字中包含有\可能會失效，失效的原因是由於查詢的關鍵字的數據庫字段排序規則爲utf8_unicode_ci，如下圖

要想不失效，查詢的關鍵字的排序規則必須爲utf8_general_ci，如下圖

或者統一全部數據庫字符集與排序規則分別爲：utf8mb4與utf8mb4_general_ci，如下圖

---

關注Github：1/2極客

關注博客：御前提筆小書童

關注網站：HuMingfeng

關注公衆號：開發者的花花世界