Tiny Formater / iVAN

格式化提供者，用于对字符串进行转换：

public interface FormatProvider {

/**

* 把指定的值进行处理后返回

*

* @param string

* 要进行格式化的值

* @return 格式化好的值

* @throws FormatException

*/

String format(Context context, String string) throws FormatException;

}

接口方法只有一个，输入有两个参数，一个是上下文，一个是要进行格式的串，返回的值是格式化处理好的串。

当然，我也担心，一些串可能会与我们的点位符有冲突，因此期望能由用户自行指定点位符，因此设定了下面的接口：

/**

* 模式匹配处理接口

*

* @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();

}

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

格式化接口如下：

/**

* 格式化的接口

*

* @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一个一个的增加出来。

好的，接口的事情就搞定了，我们来看看具体的实现类：

默认的格式化实现类：

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的格式串：

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;

}

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

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);

}

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

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

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;

}

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

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类：

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;

}

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

/**

* 测试不存在任何标记情况

*

* @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了，所以，就只到此为止了。

虽然放弃了，但是其中在设计及基础构架方面的一些思想及模式，还是值得同学们参考与借鉴的。

时间： 2024-09-14 18:38:17

Tiny Formater

Tiny Formater的相关文章

使用TinySpider实战抓取自己博客中的内容

Tiny框架启动过程日志

悠然乱弹：“最好的模板引擎”Beetl 剖析及与Tiny模板引擎对比

Tiny模板引擎(Velocity Plus)应用示例

Tiny快速入门之Web界面快速开发实践

从应用示例来认识Tiny框架

TINY框架FAQ汇集

构建Tiny生态圈

Tiny开发框架PPT介绍