Tiny Formater

昨天看了@Brin想写程序 的文章 几行Java代码实现的简单模板（不是引擎），呵呵，就非常想去掏掏偶滴小兜兜，果然发现一个类似的东西，因为东西太小，没有准备怎么写，但是看到@Brin想写程序的文章，就想着也发篇文章，说一下当时我的想法与思路。
格式化提供者，用于对字符串进行转换：

1
2
3
4
5
6
7
8
9
10
11
12		 public interface FormatProvider {
    /**
     * 把指定的值进行处理后返回
     * 
     * @param string
     *            要进行格式化的值
     * @return 格式化好的值
     * @throws FormatException
     */
    String format(Context context, String string) throws FormatException;

}




接口方法只有一个，输入有两个参数，一个是上下文，一个是要进行格式的串，返回的值是格式化处理好的串。
当然，我也担心，一些串可能会与我们的点位符有冲突，因此期望能由用户自行指定点位符，因此设定了下面的接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65		 /**
* 模式匹配处理接口
* 
* @author luoguo
* 
*/
public interface PatternDefine {
    /**
     * 返回正则匹配
     * 
     * @return
     */
    Pattern getPattern();

    /**
     * 设置前缀
     * 
     * @param prefixPatternString
     */
    void setPrefixPatternString(String prefixPatternString);

    /**
     * 设置后缀
     * 
     * @param postfixPatternString
     */
    void setPostfixPatternString(String postfixPatternString);

    /**
     * 设置正则表达式中间部分
     * 
     * @param patternString
     */
    void setPatternString(String patternString);

    /**
     * 返回正文部分
     * 
     * @param string
     * @return
     */
    String getPureMatchText(String string);

    /**
     * 根据正文返回完整部分
     * 
     * @param string
     * @return
     */
    String getFullMatchText(String string);

    /**
     * 设置域分隔符
     * 
     * @return
     */
    void setSplitChar(char splitChar);

    /**
     * 返回分隔符
     * 
     * @return
     */
    char getSplitChar();
}




当然上面的接口如果是固定一个的话，框架内部已经提供，不必另行进行扩展。

格式化接口如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30		 /**
* 格式化的接口
* 
* @author luoguo
* 
*/
public interface Formater extends FormatProvider {

    /**
     * 设置正则表达式,如果不想用默认正则表达式，可以通过此方法自行定义
     * 
     * @param patternHandle
     */
    void setPatternHandle(PatternDefine patternHandle);

    /**
     * 设置格式化提供者
     * 
     * @param formatProviders
     *            Key为匹配范围符
     */
    void setFormatProviders(Map<String, FormatProvider> formatProviders);

    /**
     * 添加格式化提供者
     * @param prefix 前缀
     * @param formatProvider
     */
    void addFormatProvider(String prefix, FormatProvider formatProvider);
}




三个方法， setPatternHandle用于设定格式话模式，setFormatProviders用于设定格式化提供者，由于是一个map，key值是前缀，value是对应的格式化处理器。当然也可以通过addFormatProvider一个一个的增加出来。
好的，接口的事情就搞定了，我们来看看具体的实现类：
默认的格式化实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51		 public class DefaultPatternDefine implements PatternDefine {

    private static final String DEFAULT_PATTERN_STRING = "([$]+[{]+[a-zA-Z0-9[.[_[:[/[#]]]]]]+[}])";
    private static final String DEFAULT_POSTFIX_PATTERN_STRING = "}";
    private static final String DEFAULT_PREFIX_PATTERN_STRING = "${";
    private static final char DEFAULT_SPLIT_CHAR = ':';
    private String prefixPatternString = DEFAULT_PREFIX_PATTERN_STRING;// 前缀
    private String postfixPatternString = DEFAULT_POSTFIX_PATTERN_STRING;// 后缀
    private String patternString = DEFAULT_PATTERN_STRING;// 中间部分
    private Pattern pattern;
    private char splitChar = DEFAULT_SPLIT_CHAR;// 域分隔符

    public Pattern getPattern() {
        if (pattern == null) {
            pattern = Pattern.compile(patternString);
        }
        return pattern;
    }

    public void setPrefixPatternString(String prefixPatternString) {
        this.prefixPatternString = prefixPatternString;
    }

    public void setPostfixPatternString(String postfixPatternString) {
        this.postfixPatternString = postfixPatternString;
    }

    public void setPatternString(String patternString) {
        this.patternString = patternString;
    }

    public String getPureMatchText(String string) {
        int startPos = prefixPatternString.length();
        int endPos = string.length() - postfixPatternString.length();
        return string.substring(startPos, endPos);
    }

    public String getFullMatchText(String string) {
        return String.format("%s%s%s", prefixPatternString, string,
                postfixPatternString);
    }

    public void setSplitChar(char splitChar) {
        this.splitChar = splitChar;
    }

    public char getSplitChar() {
        return splitChar;
    }

}




下面是一个针对Context的格式串：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23		 public class ContextFormater implements FormatProvider {

    public String format(Context context, String string) throws FormatException {
        Object obj = context.get(string);
        if (obj != null) {
            return obj.toString();
        }
        int index = string.indexOf('.');
        if (index > 0) {
            String name = string.substring(0, index);
            obj = context.get(name);
            if (obj != null) {
                String property = string.substring(index + 1);
                try {
                    return BeanUtils.getProperty(obj, property).toString();
                } catch (Exception e) {
                    throw new FormatException(e);
                }
            }
        }
        return null;
    }
}




下面是核心的格式化算法了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77		 public class FormaterImpl implements Formater {

    private Map<String, FormatProvider> formatProviders;
    private PatternDefine patternDefine = new DefaultPatternDefine();

    /**
     * 构造函数 使用默认的配置加载器
     */
    public FormaterImpl() {
    }

    /**
     * 格式化找到的内容，其余内容不变，如果找不到内容，则原样保留
     * 
     * @throws FormatException
     */
    public String format(Context context, String source) throws FormatException {
        Matcher matcher = patternDefine.getPattern().matcher(source);
        StringBuffer buf = new StringBuffer();
        int curpos = 0;
        while (matcher.find()) {
            String replaceStr = patternDefine.getPureMatchText(matcher.group());
            buf.append(source.substring(curpos, matcher.start()));
            curpos = matcher.end();
            String str = formatSingle(context, replaceStr);
            if (str != null) {
                buf.append(str);
            }
            continue;
        }
        buf.append(source.substring(curpos));
        return buf.toString();
    }

    /**
     * 格式化字符串
     * 
     * @param string
     *            String
     * @return String
     * @throws FormatException
     * @throws Exception
     */
    private String formatSingle(Context context, String string)
            throws FormatException {
        String s[] = string.split(patternDefine.getSplitChar() + "");
        if (s.length >= 2) {
            FormatProvider o = (FormatProvider) formatProviders.get(s[0]);
            if (o != null) {
                return o.format(context, s[1]);
            }
        } else {
            FormatProvider o = (FormatProvider) formatProviders.get("");
            if (o != null) {
                return o.format(context, string);
            }
        }
        return patternDefine.getFullMatchText(string);
    }

    public void setFormatProviders(Map<String, FormatProvider> formatProviders) {
        this.formatProviders = formatProviders;
    }

    public void setPatternHandle(PatternDefine patternHandle) {
        this.patternDefine = patternHandle;

    }

    public void addFormatProvider(String prefix, FormatProvider formatProvider) {
        if (formatProviders == null) {
            formatProviders = new HashMap<String, FormatProvider>();
        }
        formatProviders.put(prefix, formatProvider);
    }

}




好吧，还有一些配置相关的类，由于不是关键性的，就不在这里讲了，那么接下来看示例：

增加一个常量格式化提供者:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16		 public class ConstFormatProvider implements FormatProvider {
    Map<String, String> constMap = new HashMap<String, String>();

    public String format(Context context, String key) {
        return constMap.get(key);
    }

    public Map<String, String> getConstMap() {
        return constMap;
    }

    public void setConstMap(Map<String, String> constMap) {
        this.constMap = constMap;
    }

}




再增加一个日期格式化提供者：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16		 public class DateFormatProvider implements FormatProvider {
    Map<String, String> constMap = new HashMap<String, String>();

    public String format(Context context, String key) {
        return constMap.get(key);
    }

    public Map<String, String> getConstMap() {
        return constMap;
    }

    public void setConstMap(Map<String, String> constMap) {
        this.constMap = constMap;
    }

}




再增加一个用于测试的POJO类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29		 public class User {
    String name;
    int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User() {

    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}




好吧，我承认，前面都是做铺垫，跑龙套的，真正的秀场下面开始：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44		 /**
     * 测试不存在任何标记情况
     * 
     * @throws FormatException
     */
    public void testFormatNotPlaceholder() throws FormatException {
        assertEquals("this is test", formater.format(context, "this is test"));
    }

    /**
     * 测试存在标记，且有处理提供者处理的情况
     * 
     * @throws FormatException
     */
    public void testFormatExistPlaceholderProvider() throws FormatException {
        Context context = new ContextImpl();
        assertEquals("this is v1 test",
                formater.format(context, "this is ${const:1} test"));
    }

    /**
     * 测试存在标记，且没有处理提供者处理的情况
     * 
     * @throws FormatException
     */

    public void testFormatExistPlaceholderNoProvider() throws FormatException {
        assertEquals("this is ${abc:2} test",
                formater.format(context, "this is ${abc:2} test"));
    }

    /**
     * 测试存在标记，且是bean的情况
     * 
     * @throws FormatException
     */

    public void testFormatBean() throws FormatException {
        User user = new User("aa", 123);
        context.put("user", user);
        assertEquals("this is aa test 123",
                formater.format(context, "this is ${context:user.name} test ${context:user.age}"));

    }




下面总结一下：
上面的格式化占位符方式是${...}方式的，中间的...可以是aa:bb的方式，或者直接是bb的方式，冒号前面实际是一个区域的概念，表示由对应的区域处理器进行处理。这样就可以由开发人员不断的扩展格式化处理器的处理能力。由于占位匹配器也是可以进行扩展的，因此，可以自行定义自己的格式化占位方式。
对于对象的属性可以无限向下“.”下去，当然也可以添加其它的处理方式，比如：数组之类的。
所以从功能及定位来说，与@Brin想写程序 是一样的。
剧透一下：当时我本来是想写模板语言的，后来直接选择复用Velocity了，所以，就只到此为止了。
虽然放弃了，但是其中在设计及基础构架方面的一些思想及模式，还是值得同学们参考与借鉴的。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/j2eetop/p/4612575.html