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了,所以,就只到此为止了。
虽然放弃了,但是其中在设计及基础构架方面的一些思想及模式,还是值得同学们参考与借鉴的。

你可能感兴趣的:(format)