/**
 * 特殊字符轉(zhuǎn)換 like 查詢
 * 參數(shù)中的特殊查詢字符  _  %  \
 * 注意事項 ：
 * 1. 必須是在 分頁攔截器之前執(zhí)行 [注意攔截器的順序]
 * 2. 當(dāng)數(shù)據(jù)庫字段排序規(guī)則為utf8_unicode_ci時，對于特殊符號的模糊查詢失效，
 * 所以，必須設(shè)置數(shù)據(jù)庫字段排序規(guī)則為utf8_general_ci或utf8mb4_general_ci
 *
 */
@Intercepts(@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class,
        RowBounds.class, ResultHandler.class}))
public class SpecialCharacterConversionLikeInnerInterceptor implements Interceptor {
    @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) {

    }

    public 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;
        }
        // 獲取關(guān)鍵字的個數(shù)（去重）
        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);
            }
        }
        // 對關(guān)鍵字進(jìn)行特殊字符“清洗”，如果有特殊字符的，在特殊字符前添加轉(zhuǎn)義字符（\）
        for (String keyName : keyNames) {
            HashMap parameter = (HashMap) parameterObject;
            if (keyName.contains("ew.paramNameValuePairs.") && sql.toLowerCase().contains(" like ?")) {
                // 第一種情況：在業(yè)務(wù)層進(jìn)行條件構(gòu)造產(chǎn)生的模糊查詢關(guān)鍵字
                AbstractWrapper wrapper = (AbstractWrapper) parameter.get("ew");

                parameter = (HashMap) wrapper.getParamNameValuePairs();

                String[] keyList = keyName.split("\\.");
                // ew.paramNameValuePairs.MPGENVAL1，截取字符串之后，獲取第三個，即為參數(shù)名
                Object a = parameter.get(keyList[2]);
                if (a instanceof String && (a.toString().contains("_") || a.toString().contains("\\") || a.toString()
                        .contains("%"))) {
                    parameter.put(keyList[2],
                            "%" + escapeChar(a.toString().substring(1, a.toString().length() - 1)) + "%");
                }
            } else if (!keyName.contains("ew.paramNameValuePairs.") && sql.toLowerCase().contains(" like ?")) {
                // 第二種情況：未使用條件構(gòu)造器，但是在service層進(jìn)行了查詢關(guān)鍵字與模糊查詢符`%`手動拼接
                Object a = parameter.get(keyName);
                if (a instanceof String && (a.toString().contains("_") || a.toString().contains("\\") || a.toString()
                        .contains("%"))) {
                    parameter.put(keyName,
                            "%" + escapeChar(a.toString().substring(1, a.toString().length() - 1)) + "%");
                }
            } else {
                // 第三種情況：在Mapper類的注解SQL中進(jìn)行了模糊查詢的拼接
                updateValue(parameter, keyName);
            }
        }
        return sql;
    }

    public String escapeChar(String str) {
        if (!StringUtils.isEmpty(str)) {
            str = str.replaceAll("\\\\", "\\\\\\\\");
            str = str.replaceAll("_", "\\\\_");
            str = str.replaceAll("%", "\\\\%");
        }
        return str;
    }

    /**
     * 從參數(shù)字典中取值
     * 取出keyName對應(yīng)的value
     *
     * @param parameter 參數(shù)字典
     * @param keyName   key名稱
     * @return value
     */
    private void updateValue(HashMap parameter, String keyName) {
        String v = "";
        List<String> sub_keys = Arrays.asList(keyName.split("\\."));
        if (sub_keys.size() == 1 && parameter.containsKey(keyName)) {
            v = parameter.get(keyName).toString();
            if ((v.contains("_") || v.contains("\\") || v.contains("%"))) {
                parameter.put(keyName, escapeChar(v));
            }
        } else if (sub_keys.size() == 2 && parameter.containsKey(sub_keys.get(0))) {
            HashMap bean = (HashMap) BeanUtil.beanToMap(parameter.get(sub_keys.get(0)));
            if (bean.containsKey(sub_keys.get(1))) {
                v = (String) bean.get(sub_keys.get(1));
                if ((v.contains("_") || v.contains("\\") || v.contains("%"))) {
                    v = escapeChar(v);
                }
                bean.put(sub_keys.get(1), v);
                parameter.put(sub_keys.get(0), bean);
            }
        } else {
            // 暫不支持復(fù)雜的Bean
            return;
        }
    }
}

@Configuration
public class MybatisPlusConfig {
    /**
     * 模糊查詢攔截器
     *
     * @return
     */
    @Bean
    public SpecialCharacterConversionLikeInnerInterceptor myInterceptor() {
        return new SpecialCharacterConversionLikeInnerInterceptor();
    }
}