美文网首页Mybatis
借鉴mybatis源码 — 实现SQL动态拼接

借鉴mybatis源码 — 实现SQL动态拼接

作者: 小胖学编程 | 来源:发表于2023-10-07 20:37 被阅读0次

在报表域的设计上,请求对象采用的是元数据格式的请求方式,在平台上只需要配置一些SQL模板。在解析引擎中实现SQL的拼接。那么如何实现SQL的动态拼接呢?

诉求:

  1. 需要支持#{}和${}占位符;
  2. 需要支持<if></if>动态标签;
  3. 需要支持SQL语法(例如in查询)

准备

需要引入QLExpress表达式:

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>QLExpress</artifactId>
            <version>3.3.2</version>
        </dependency>

实现

下面两个方法是Mybatis的源码,其作用就是根据openTokencloseToken来找到占位的代码块,执行handler中的逻辑来完成占位。

解析引擎(处理占位符)

这个方法是关键,用于定义占位符,同时实现多个handler实现类,完成对占位符的替换。

public class GenericTokenParser {

    private final String openToken; //开始标记
    private final String closeToken; //结束标记
    private final TokenHandler handler; //标记处理器

    public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
        this.openToken = openToken;
        this.closeToken = closeToken;
        this.handler = handler;
    }

    /**
     * 解析${}和#{}
     *
     * @param text 待解析的文本
     * @return 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作,并返回最终需要的数据。
     * 其中,解析工作由该方法完成,处理工作是由处理器handler的handleToken()方法来实现
     */
    public String parse(String text) {
        // 验证参数问题,如果是null,就返回空字符串。
        if (text == null || text.isEmpty()) {
            return "";
        }

        // 下面继续验证是否包含开始标签,如果不包含,默认不是占位符,直接原样返回即可,否则继续执行。
        int start = text.indexOf(openToken, 0);
        if (start == -1) {
            return text;
        }

        // 把text转成字符数组src,并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder,
        // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken),如果存在就执行下面代码
        char[] src = text.toCharArray();
        int offset = 0;
        final StringBuilder builder = new StringBuilder();
        StringBuilder expression = null;
        while (start > -1) {
            // 判断如果开始标记前如果有转义字符,就不作为openToken进行处理,否则继续处理
            if (start > 0 && src[start - 1] == '\\') {
                builder.append(src, offset, start - offset - 1).append(openToken);
                offset = start + openToken.length();
            } else {
                //重置expression变量,避免空指针或者老数据干扰。
                if (expression == null) {
                    expression = new StringBuilder();
                } else {
                    expression.setLength(0);
                }
                builder.append(src, offset, start - offset);
                offset = start + openToken.length();
                int end = text.indexOf(closeToken, offset);
                //存在结束标记时
                while (end > -1) {
                    //如果结束标记前面有转义字符时
                    if (end > offset && src[end - 1] == '\\') {
                        // this close token is escaped. remove the backslash and continue.
                        expression.append(src, offset, end - offset - 1).append(closeToken);
                        offset = end + closeToken.length();
                        end = text.indexOf(closeToken, offset);
                    } else {
                        //不存在转义字符,即需要作为参数进行处理
                        expression.append(src, offset, end - offset);
                        offset = end + closeToken.length();
                        break;
                    }
                }
                if (end == -1) {
                    // close token was not found.
                    builder.append(src, start, src.length - start);
                    offset = src.length;
                } else {
                    builder.append(handler.handleToken(expression.toString()));
                    offset = end + closeToken.length();
                }
            }
            start = text.indexOf(openToken, offset);
        }
        if (offset < src.length) {
            builder.append(src, offset, src.length - offset);
        }
        return builder.toString();
    }
}

handler处理器

处理${}占位符

public class ParameterMappingTokenHandler implements TokenHandler {

    private Map<String, String> paramMap;


    public ParameterMappingTokenHandler(Map<String, String> paramMap) {
        this.paramMap = paramMap;
    }

    public String handleToken(String content) {
        return paramMap.get(content);
    }
}

处理#{}占位符

在#{}中,定义了字段的类型,便于处理in语法。

@Getter
public class SafeParameterMappingTokenHandler implements TokenHandler {

    private Map<String, String> paramMap;

    //分隔符
    public static final String SPLIT = ";";

    /**
     * @param paramMap 参数映射对象
     */
    public SafeParameterMappingTokenHandler(Map<String, String> paramMap) {
        this.paramMap = paramMap;
    }

    @Override
    public String handleToken(String content) {
        //传入的格式,先判断是否存在要求的类型
        if (StringUtils.isBlank(content)) {
            return content;
        }
        //获取到数组类型
        String[] param2Type = content.split(SPLIT);
        ParameterType parameterType = getParameterType(param2Type);
        String value = paramMap.get(param2Type[0]);
        switch (parameterType) {
            case STRING:
                return formatString(value);
            case LONG:
                return formatLong(value);
            case LIST_STRING:
                return formatListString(value);
            case LIST_LONG:
                return formatListLong(value);
            default:
                throw BusinessErrorCode.PARAM_ERROR.of();
        }
    }

    private String formatString(String value) {
        value = StringUtils.replace(value, "'", "\\'");
        value = StringUtils.replace(value, "\"", "\\\"");
        value = StringUtils.replace(value, ";", "\\");
        value = StringUtils.replace(value, "%", "\\%");
        value = StringUtils.replace(value, "-", "\\-");
        value = StringUtils.replace(value, "\\", "\\\\");
        value = StringUtils.replace(value, "_", "\\_");
        return String.format("%s%s%s", "'", value, "'");
    }


    private String formatLong(String value) {
        return String.valueOf(Long.valueOf(value));
    }

    private String formatListString(String value) {
        //获取到集合值
        List<String> strings = BaseCollectionUtils.resolveList(value);
        if (strings == null) {
            return null;
        }
        return strings.stream()
                .filter(StringUtils::isNotBlank)
                .map(this::formatString)
                .collect(Collectors.joining(","));
    }

    private String formatListLong(String value) {
        //获取到集合值
        List<String> strings = BaseCollectionUtils.resolveList(value);
        if (strings == null) {
            return null;
        }
        return strings.stream()
                .filter(StringUtils::isNotBlank)
                .map(this::formatLong)
                .collect(Collectors.joining(","));
    }

    private ParameterType getParameterType(String[] param2Type) {
        ParameterType parameterType;
        if (param2Type.length == 1) {
            parameterType = STRING;
        } else {
            parameterType = resolveParameterType(param2Type[1]);
        }
        return parameterType;
    }


    @Getter
    public enum ParameterType {
        STRING("string"), LIST_STRING("listString"), LONG("long"), LIST_LONG("listLong");

        private String type;

        ParameterType(String type) {
            this.type = type;
        }

        public static ParameterType resolveParameterType(String type) {
            for (ParameterType parameterType : values()) {
                if (Objects.equals(parameterType.type, type)) {
                    return parameterType;
                }
            }
            return STRING;
        }
    }

}

处理if标签

使用QLExpress表示式,简化了判null和判0的操作。

public class IfSpanTokenHandler implements TokenHandler {

    private Map<String, String> paramMap;

    public static final ExpressRunner RUNNER = new ExpressRunner();

    static {
        try {
            RUNNER.addFunctionOfClassMethod("notEmpty", IfSpanTokenHandler.class.getName(), "isNotEmpty", new String[] {"String"}, null);
            RUNNER.addFunctionOfClassMethod("notZero", IfSpanTokenHandler.class.getName(), "isNotZero", new String[] {"String"}, null);
        } catch (Exception e) {
            throw BusinessErrorCode.SYSTEM_ERROR.of(e);
        }
    }

    public IfSpanTokenHandler(Map<String, String> paramMap) {
        this.paramMap = paramMap;
    }

    @Override
    public String handleToken(String content) {

        //表达式
        int startIndex = content.indexOf("'");
        int endIndex = content.lastIndexOf("'");
        String substring = content.substring(startIndex + 1, endIndex);
        boolean res = true;
        try {
            DefaultContext<String, Object> context = new DefaultContext<>();
            paramMap.keySet().forEach(k -> {
                context.put(k, paramMap.get(k));
            });
            res = (boolean) RUNNER.execute(substring, context, null, false, false);
        } catch (Exception e) {
            throw BusinessErrorCode.REDIS_LOCK_ERROR.of(e);
        }
        if (res) {
            return content.substring(content.indexOf(">") + 1);
        } else {
            return "";
        }
    }

    public static boolean isNotEmpty(String value) {
        return StringUtils.isNotBlank(value);
    }

    public static boolean isNotZero(String value) {
        return StringUtils.isNotEmpty(value) && Long.parseLong(value) != 0;
    }

}

工具类

public class PlaceholderUtil {

    /**
     * SQL解析器
     */
    public static String parse(String sql, Map<String, String> paramMaps) {
        String finalSql = sql;
        GenericTokenParser ifSpanParser = new GenericTokenParser("<if", "</if>", new IfSpanTokenHandler(paramMaps));
        finalSql = ifSpanParser.parse(finalSql);
        GenericTokenParser parser = new GenericTokenParser("${", "}", new ParameterMappingTokenHandler(paramMaps));
        finalSql = parser.parse(finalSql);
        GenericTokenParser safeParser = new GenericTokenParser("#{", "}", new SafeParameterMappingTokenHandler(paramMaps));
        return safeParser.parse(finalSql);
    }

}

测试

测试类:

    public static void main(String[] args) {
        //  ;listString定义了字段的类型是List<String>在解析的过程中,需要为每一个元素设置''
        String sql = "select * from table where <if 'notEmpty(id)'>id in (#{id;listString}) and </if> name=#{name}";
        System.out.println(parse(sql, Maps.builder().put("id", "123,456").put("name", "tim").build()));
    }

测试结果:

select * from table where id in ('123','456') and  name='tim'

相关文章

  • MyBatis动态sql

    动态sql就是可以对sql语句进行灵活的封装,拼接。通过mybatis语法的判断可以实现动态sql。 1 if标签...

  • MyBatis 动态SQL(*.xml)

    原文参考MyBatis 动态SQL MyBatis的动态SQL大大减少了拼接SQL语句时候的各种格式问题,这里摘录...

  • Mybatis--动态SQL(if,where,trim)

    Mybatis框架的动态SQL技术是一种根据特定条件动态拼接SQL语句的功能,作用是为了解决拼接SQL语句字符串的...

  • mybatis从使用到了解(七)_mybatis动态sql的妙用

    动态SQL 在使用JDBC拼接SQL的时候,经常要确保不能完了必要的空格,对于的逗号,而mybatis的动态SQL...

  • MyBatis动态SQL

    动态 SQL 是 MyBatis 的强大特性之一。根据不同条件拼接 SQL 语句有多痛苦,例如拼接时要确保不能忘记...

  • java基础-day49-Myba03

    一、动态SQL【重点】 MyBatis的映射文件中支持在基础SQL上添加一些逻辑操作,并动态拼接成完整的SQL之后...

  • Mybatis入门(三)之动态sql

    Mybatis入门之动态sql 动态拼接sql语句,在我的理解就是相当于Java中的逻辑控制语句(if,,swit...

  • 动态sql

    一、动态sql mybatis核心对sql语句进行灵活操作,通过表达式进行判断,对sql进行灵活拼接、组装。 if...

  • Mybatis基础实践

    Mybatis特点之——动态SQL mybatis的动态sql 是基于强大的OGNL表达式来实现的,主要是用来解决...

  • 2018-12-23 MyBatis SQL无语法错误出现报错的

    问题描述:MyBatis动态SQl 使用如下语句时,在最终的拼接中产生了 sql语法错误

网友评论

    本文标题:借鉴mybatis源码 — 实现SQL动态拼接

    本文链接:https://www.haomeiwen.com/subject/qpevbdtx.html