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

时间： 2024-08-26 03:41:22

Tiny Formater的相关文章

Tiny Core Linux 显示中文的方法

Tiny Core Linux的下载地址: http://www.tinycorelinux.net/downloads.html 当前的版本为:4.7.5 每个人的需求都不一样,我选择 Tiny Core Linux 的原因很简单--因为体积小.建立这个系统的目的就是看看网页,所以只要让网页浏览器能正常显示出中文即可. 一.利用ISO文件启动计算机,启动后安装"tc-install.tcz",这个程序是部署系统的GUI工具. 二.运行"Tiny Core Installat

Crash Google Chrome with one tiny URL

http://www.theregister.co.uk/2015/09/20/chrome_url_crash/ Crash Google Chrome with one tiny URL: We cram a probe in this bug How clicking on or even rolling your mouse over it will knacker browser Twitter 317 Facebook 94 G+ linkedin 67 20 Sep 2015 at

CSAPP Tiny web server源代码分析及搭建执行

1. Web基础 webclient和server之间的交互使用的是一个基于文本的应用级协议HTTP(超文本传输协议). 一个webclient(即浏览器)打开一个到server的因特网连接,而且请求某些内容.server响应所请求的内容,然后关闭连接.浏览器读取这些内容.并把它显示在屏幕上. 对于webclient和server而言.内容是与一个MIME类型相关的字节序列. 常见的MIME类型: MIME类型 描写叙述 text/html HTML页面 text/plain 无格式文本 ima

You-Get , A Tiny Downloader,视频下载小工具

You-Get    You-Get is a tiny command-line utility to download media contents (videos, audios, images) from the Web, in case there is no other handy way to do it. Here's how you use you-get to download a video from this web page: 1 you-get -o E:/Deskt

CSAPP Tiny web 服务器源码分析及搭建运行

1. Web基础 web客户端和服务器之间的交互使用的是一个基于文本的应用级协议HTTP(超文本传输协议).一个web客户端(即浏览器)打开一个到服务器的因特网连接,并且请求某些内容.服务器响应所请求的内容,然后关闭连接.浏览器读取这些内容,并把它显示在屏幕上. 对于web客户端和服务器而言,内容是与一个MIME类型相关的字节序列.常见的MIME类型: MIME类型 描述 text/html HTML页面 text/plain 无格式文本 image/gif GIF格式编码的二进制图像 imag

Tiny server:小型Web服务器

一.背景 csapp的网络编程粗略的介绍了关于网络编程的一些知识,在最后的一节主要就实现了一个小型的Webserver.这个server名叫Tiny,它是一个小型的可是功能齐全的Webserver.在短短300行左右的代码中,结合了很多思想,比如,进程控制,unix I/O.套接字.HTTP等,令人兴奋的是,它能够为Web浏览器提供静态和动态的内容,也就是说在浏览器中要打开的HTML之类的文件能够直接通过Tiny直接显示在窗体. 我一直想要学习网络编程,这或许就是第一个做成的东西吧,想想都让人兴

Tiny PXE Server简介

Tiny PXE Server简介Tiny PXE Server是一款小巧而功能强大的网启软件.支持DHCP TFTP HTTP BINL DNS等多个协议,支持grub4dos,pxelinux,ipxe等多个引导器,支持从PXE/gPXE/IPXE启动,最新版居然能够直接从互联网通过http协议启动,实在逆天.Tiny PXE Server下载地址:http://erwan.labalec.fr/tinypxeserver/pxesrv.zip1.启动IPXETiny PXE Server可

推荐使用Tiny Framework web开发UI组件

TINY FRAMEWORK 基于组件化的J2EE开发框架,from:http://www.tinygroup.org/ 名字 Tiny名称的来历 取名Tiny是取其微不足道,微小之意. Tiny的构建者认为,一个J2EE开发框架是非常复杂的,只有把框架分解成非常细小.可控的部分,并且对每个细小.可控的部分都有一个最优解或相对最优解, 那么整个方案也就可以非常不错的落地. 策略 Tiny框架的构建策略 Think big, start small, scale fast. 想法要宏伟,但是要从小

编译原理学习：TINY语言词法扫描程序实现

最近对解释型程序(类似python或者是linux里的bc计算器)非常感兴趣,就开始学习一下编译原理.今天自己实现了TINY语言的词法扫描程序.大部分参考<编译原理及实践>一书.但是我做了一些小小的改进. 先说一下TINY语言: 1.注释:放在一对大括号内.书上的注释不能嵌套,我做了一点改进,允许嵌套. 2.关键字:read write if end repeat until else 3.类型:只支持整型和布尔型. 4.计算:+ - * / ( ) < = :=,其中:=为赋值运算,=