Java 模板变量更换——字符串更换器（思绪Mybatis的GenericTokenParser）

思绪

模板变量更换无非是探求出字符串（模板）中的特殊标志，用对应的变量举行字符串更换。
提到变量更换，各人第一能遐想到的大概是Mybatis的动态SQL语句的分析，又大概是mybatis.xml设置文件中用于分析"${username:root}"的默认值。
在Mybatis的源码中，这些功能则是通过GenericTokenParser类来实现的，通过查察源码可以很显着的知道GenericTokenParser只是查找指定的占位符，而具体的分析活动会根据其持有的TokenHandler实现的差别而有所差别，这里是采取了计谋模式。
那么接下来我们就使用Mybatis的思绪，试着写一个字符串更换器吧
字符串更换器

GenericTokenParser

1. public class GenericTokenParser {
3.   private final String openToken;
4.   private final String closeToken;
5.   private final TokenHandler handler;
7.   public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
8.     this.openToken = openToken;
9.     this.closeToken = closeToken;
10.     this.handler = handler;
11.   }
13.   public String parse(String text) {
14.     if (text == null || text.isEmpty()) {
15.       return "";
16.     }
17.     // search open token
18.     int start = text.indexOf(openToken, 0);
19.     if (start == -1) {
20.       return text;
21.     }
22.     char[] src = text.toCharArray();
23.     int offset = 0;
24.     final StringBuilder builder = new StringBuilder();
25.     StringBuilder expression = null;
26.     while (start > -1) {
27.       if (start > 0 && src[start - 1] == '\\') {
28.         // this open token is escaped. remove the backslash and continue.
29.         builder.append(src, offset, start - offset - 1).append(openToken);
30.         offset = start + openToken.length();
31.       } else {
32.         // found open token. let's search close token.
33.         if (expression == null) {
34.           expression = new StringBuilder();
35.         } else {
36.           expression.setLength(0);
37.         }
38.         builder.append(src, offset, start - offset);
39.         offset = start + openToken.length();
40.         int end = text.indexOf(closeToken, offset);
41.         while (end > -1) {
42.           if (end > offset && src[end - 1] == '\\') {
43.             // this close token is escaped. remove the backslash and continue.
44.             expression.append(src, offset, end - offset - 1).append(closeToken);
45.             offset = end + closeToken.length();
46.             end = text.indexOf(closeToken, offset);
47.           } else {
48.             expression.append(src, offset, end - offset);
49.             offset = end + closeToken.length();
50.             break;
51.           }
52.         }
53.         if (end == -1) {
54.           // close token was not found.
55.           builder.append(src, start, src.length - start);
56.           offset = src.length;
57.         } else {
58.           builder.append(handler.handleToken(expression.toString()));
59.           offset = end + closeToken.length();
60.         }
61.       }
62.       start = text.indexOf(openToken, offset);
63.     }
64.     if (offset < src.length) {
65.       builder.append(src, offset, src.length - offset);
66.     }
67.     return builder.toString();
68.   }
69. }

复制代码

TokenHandler

1. public interface TokenHandler {
2.   String handleToken(String content);
3. }

复制代码

以上代码是Mybatis的源码，可以直接抄，接下来编写核心的逻辑：
这里的数据使用Map<String,Object>来存储，key是变量名称，value是变量值，value的范例下列代码仅支持了String和List，对应的可以实现直接变量更换和循环变量更换，有其他须要可以在此根本上新增功能，而List的泛型仅支持Map<String,String>，即不支持多层嵌套。
在这个例子中，我使用${变量名}表现平凡变量，<变量名></变量名>表现循环变量，标签内的内容将被循环展示

1. public class ReportGenerator {
3.     public static void main(String[] args) {
4.         String reportTemplate = "这是一份贵司专属总结报告，请查收！\n" +
5.                 "您的订单编号：${firstShowId}，产品名称：${firstProductName}，于${firstOnlineDate}正式生效，今天是贵司正式启用电子签名的第90天，截至今天，您的订单使用情况如下：#{${a}/${b}}\n" +
6.                 "<orders>${orders.productName}，累计消耗${orders.displayConsumeAmount}${orders.units}</orders>" +
7.                 "如对使用情况和数据报告有任何疑问，可随时联系你的客户成功经理。\n" +
8.                 "<contracts>合同编号${contracts.contractId}，合同负责人:${contracts.contractManager}，${name}</contracts>";
10.         Map<String, Object> data = new HashMap<>();
11.         data.put("firstShowId", "123456789");
12.         data.put("firstProductName", "测试产品");
13.         data.put("firstOnlineDate", "2023-01-01");
14.         data.put("productName", "测试产品");
15.         data.put("name", "张三");
16.         data.put("a", "100");
17.         data.put("b", "10");
18.         data.put("c", "10");
20.         List<Map<String, String>> orders = new ArrayList<>();
21.         Map<String, String> param1 = new HashMap<>();
22.         param1.put("productName", "测试产品1");
23.         param1.put("displayConsumeAmount", "100");
24.         param1.put("units", "元");
25.         orders.add(param1);
26.         Map<String, String> param2 = new HashMap<>();
27.         param2.put("productName", "测试产品2");
28.         param2.put("displayConsumeAmount", "200");
29.         param2.put("units", "元");
30.         orders.add(param2);
31.         data.put("orders", orders);
33.         List<Map<String, String>> contracts = new ArrayList<>();
34.         Map<String, String> param3 = new HashMap<>();
35.         param1.put("contractId", "12312543243213");
36.         param1.put("contractManager", "杜甫");
37.         contracts.add(param1);
38.         Map<String, String> param4 = new HashMap<>();
39.         param2.put("contractId", "1234353453");
40.         param2.put("contractManager", "李白");
41.         contracts.add(param2);
42.         data.put("contracts", contracts);
44.         String handler = handler(data, reportTemplate);
46.         // 打印报告
47.         System.out.println(handler);
48.     }
50.     public static String handler(Map<String, Object> data, String templateContent) {
51.         // 循环变量，仅支持一层嵌套
52.         Map<String, List<Map<String, String>>> loopVariables = new HashMap<>();
53.         // 基本参数
54.         Map<String, String> basicVariables = new HashMap<>();
56.         // 分类：循环变量，基本参数，计算参数
57.         for (Map.Entry<String, Object> entry : data.entrySet()) {
58.             String key = entry.getKey();
59.             Object value = entry.getValue();
60.             if (value instanceof List) {
61.                 loopVariables.put(key, (List<Map<String, String>>) value);
62.             } else if (value instanceof String) {
63.                 basicVariables.put(key, (String) value);
64.             }
65.         }
67.         // 处理循环变量
68.         for (Map.Entry<String, List<Map<String, String>>> entry : loopVariables.entrySet()) {
69.             String key = entry.getKey();
70.             List<Map<String, String>> value = entry.getValue();
71.             ForEachTokenParser forEachTokenParser = new ForEachTokenParser(key, value, "\n");
72.             GenericTokenParser genericTokenParser = new GenericTokenParser("<" + key + ">", "</" + key + ">", forEachTokenParser);
73.             templateContent = genericTokenParser.parse(templateContent);
74.         }
76.         // 处理基本参数
77.         VariableTokenParser variableTokenParser = new VariableTokenParser(basicVariables);
78.         GenericTokenParser genericTokenParser = new GenericTokenParser("${", "}", variableTokenParser);
79.         templateContent = genericTokenParser.parse(templateContent);
81.         // // 计算参数
82.         // EquationTokenParser equationTokenParser = new EquationTokenParser();
83.         // GenericTokenParser equationParser = new GenericTokenParser("#{", "}", equationTokenParser);
84.         // templateContent = equationParser.parse(templateContent);
86.         return templateContent;
87.     }
89.     /**
90.      * 循环变量参数
91.      */
92.     static class ForEachTokenParser implements TokenHandler {
94.         private final String variableName;
96.         private final List<Map<String, String>> variables;
98.         private final String separator;
100.         public ForEachTokenParser(String variableName, List<Map<String, String>> variable, String separator) {
101.             this.variableName = variableName;
102.             this.variables= variable;
103.             this.separator = separator;
104.         }
106.         @Override
107.         public String handleToken(String content) {
108.             if (variables == null || variables.isEmpty()) {
109.                 throw new RuntimeException("变量不存在：" + content);
110.             }
111.             StringBuilder builder = new StringBuilder();
112.             for (Map<String, String> variable : variables) {
113.                 VariableTokenParser variableTokenParser = new VariableTokenParser(variable);
114.                 GenericTokenParser genericTokenParser = new GenericTokenParser("${" + variableName + ".", "}", variableTokenParser);
115.                 builder.append(genericTokenParser.parse(content)).append(separator);
116.             }
117.             return builder.toString();
118.         }
119.     }
121.     /**
122.      * 基础变量参数
123.      */
124.     static class VariableTokenParser implements TokenHandler {
126.         private final Map<String, String> variables;
128.         public VariableTokenParser(Map<String, String> variable) {
129.             this.variables= variable;
130.         }
132.         @Override
133.         public String handleToken(String content) {
134.             String value = variables.get(content);
135.             if (value == null) {
136.                 throw new RuntimeException("变量不存在：" + content);
137.             }
138.             return value;
139.         }
140.     }
142.     /**
143.      * 计算参数
144.      * 目前仅支持除法运算：#{100/10}
145.      */
146.     // static class EquationTokenParser implements TokenHandler {
147.     //
148.     //     @Override
149.     //     public String handleToken(String content) {
150.     //         return String.valueOf(evaluateExpression(content));
151.     //     }
152.     //
153.     //     private static double evaluateExpression(String expression) {
154.     //         String[] parts = expression.split("/");
155.     //         if (parts.length == 2) {
156.     //             BigDecimal numerator = new BigDecimal(parts[0].trim());
157.     //             BigDecimal denominator = new BigDecimal(parts[1].trim());
158.     //             return numerator.divide(denominator, 2, RoundingMode.HALF_UP).doubleValue();
159.     //         }
160.     //         return 0;
161.     //     }
162.     // }
163. }

复制代码