MyBatis-Plus模糊查询特殊字符串转义的实现

/**
 * 特殊字符转换 like 查询
 * 参数中的特殊查询字符  _  %  \
 * 注意事项 ：
 * 1. 必须是在 分页拦截器之前执行 [注意拦截器的顺序]
 * 2. 当数据库字段排序规则为utf8_unicode_ci时，对于特殊符号的模糊查询失效，
 * 所以，必须设置数据库字段排序规则为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;
        }
        // 获取关键字的个数（去重）
        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 ?")) {
                // 第一种情况：在业务层进行条件构造产生的模糊查询关键字
                abstractwrapper wrapper = (abstractwrapper) 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],
                            "%" + 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,
                            "%" + escapechar(a.tostring().substring(1, a.tostring().length() - 1)) + "%");
                }
            } else {
                // 第三种情况：在mapper类的注解sql中进行了模糊查询的拼接
                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;
    }

    /**
     * 从参数字典中取值
     * 取出keyname对应的value
     *
     * @param parameter 参数字典
     * @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 {
            // 暂不支持复杂的bean
            return;
        }
    }
}

@configuration
public class mybatisplusconfig {
    /**
     * 模糊查询拦截器
     *
     * @return
     */
    @bean
    public specialcharacterconversionlikeinnerinterceptor myinterceptor() {
        return new specialcharacterconversionlikeinnerinterceptor();
    }
}