在报表域的设计上，请求对象采用的是元数据格式的请求方式，在平台上只需要配置一些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的源码，其作用就是根据openToken和closeToken来找到占位的代码块，执行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'