3.1. 配置GroupTemplate
Beetl建议通过配置文件配置配置GroupTemplate，主要考虑到未来可能IDE插件会支持Beetl模板，模板的属性，和函数等如果能通过配置文件获取，将有助于IDE插件识别。 配置GroupTemplate有俩种方法
-
配置文件： 默认配置在/org/beetl/core/beetl-default.properties 里，Beetl首先加载此配置文件，然后再加载classpath里的beetl.properties,并用后者覆盖前者。配置文件通过Configuration类加载，因此加载完成后，也可以通过此类API来修改配置信息
-
通过调用GroupTemplate提供的方法来注册函数，格式化函数，标签函数等
配置文件分为三部分，第一部分是基本配置，在第一节讲到过。第二部分是资源类配置，可以在指定资源加载类，以及资源加载器的属性，如下
1
2
3
4
5
6
|
RESOURCE_LOADER=org.beetl.core.resource.ClasspathResourceLoader
#资源配置，resource后的属性只限于特定ResourceLoader
#classpath 根路径
RESOURCE.root= /
#是否检测文件变化
RESOURCE.autouCheck= true
|
第一行指定了类加载器，第二行指定了模板根目录的路径，此处/ 表示位于classpath 根路径下，第三行是否自动检测模板变化，默认为true，开发环境下自动检测模板是否更改。关于如何如何自定义ResouceLoader，请参考下一章
配置文件第三部分是扩展部分，如方法，格式化函数等
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
##### 扩展 ##############
## 内置的方法
FN.date = org.beetl.ext.fn.DateFunction
FN.nvl = org.beetl.ext.fn.NVLFunction
.................
##内置的功能包
FNP.strutil = org.beetl.ext.fn.StringUtil
##内置的格式化函数
FT.dateFormat = org.beetl.ext.format.DateFormat
FT.numberFormat = org.beetl.ext.format.NumberFormat
.................
##内置的默认格式化函数
FTC.java.util.Date = org.beetl.ext.format.DateFormat
FTC.java.sql.Date = org.beetl.ext.format.DateFormat
## 标签类
TAG.include= org.beetl.ext.tag.IncludeTag
TAG.includeFileTemplate= org.beetl.ext.tag.IncludeTag
TAG.layout= org.beetl.ext.tag.LayoutTag
TAG.htmltag= org.beetl.ext.tag.HTMLTagSupportWrapper
|
FN前缀表示Function，FNP前缀表示FunctionPackage，FT表示format函数，FTC表示类的默认Format函数，TAG表示标签类。Beetl强烈建议通过配置文件加载扩展。以便随后IDE插件能识别这些注册函数
3.2. 自定义方法
3.2.1. 实现Function
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class Print implements Function
{
public String call(Object[] paras, Context ctx)
{
Object o = paras[0];
if (o != null)
{
try
{
ctx.byteWriter.write(o.toString());
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
return "";
}
|
call方法有俩个参数，第一个是数组，这是由模板传入的，对应着模板的参数，第二个是Context，包含了模板的上下文，主要提供了如下属性
-
byteWriter 输出流
-
template 模板本身
-
gt GroupTemplate
-
globalVar 该模板对应的全局变量
-
byteOutputMode 模板的输出模式，是字节还是字符
-
safeOutput 模板当前是否处于安全输出模式
-
其他属性建议不熟悉的开发人员不要乱动
3.2.2. 使用普通的java类
尽管实现Function对于模板引擎来说，是效率最高的方式，但考虑到很多系统只有util类，这些类里的方法仍然可以注册为模板函数。其规则很简单，就是该类的所有public方法。如果需还要Context 变量，则需要在方法最后一个参数加上Context即可，如
1
2
3
4
5
6
7
8
|
public class util
{
public String print(Object a, Context ctx)
{
...............
}
|
注意
3.2.3. 使用模板文件作为方法
可以不用写java代码，模板文件也能作为一个方法。默认情况下，需要将模板文件放到Root的functions目录下，且扩展名为.html(可以配置文件属性来修改此俩默认值) 方法参数分别是para0,para1…..
如下root/functions/page.fn
1
2
3
4
5
|
<%
//para0,para1 由函数调用传入
var current = para0,total = para1,style=para2!'simple'
%>
当前页面 ${current},总共${total}
|
则在模板中
1
2
3
|
<%
page(current,total);
%>
|
允许使用return 表达式返回一个变量给调用者，如模板文件functions ow.html
1
2
3
|
<%
return date();
%>
|
在任何模板里都可以调用：
1
|
hello time is ${now(),‘yyyy-MM-dd’}
|
也可以在functions建立子目录，这样function则具有namespace，其值就是文件夹名
3.3. 自定义格式化函数
需要实现Format接口
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
|
public class DateFormat implements Format
{
public Object format(Object data, String pattern)
{
if (data == null)
return null;
if (Date.class.isAssignableFrom(data.getClass()))
{
SimpleDateFormat sdf = null;
if (pattern == null)
{
sdf = new SimpleDateFormat();
}
else
{
sdf = new SimpleDateFormat(pattern);
}
return sdf.format((Date) data);
}
else
{
throw new RuntimeException("Arg Error:Type should be Date");
}
}
|
data 参数表示需要格式化的对象，pattern表示格式化模式，开发时候需要考虑pattern为null的情况
也可以实现ContextFormat 类抽象方法，从而得到Context，获取外的格式化信息。
1
|
public abstract Object format(Object data,String pattern,Context ctx);
|
3.4. 自定义标签
标签形式有俩种，一种是标签函数，第二种是html tag。第二种实际上在语法解析的时候会转化成第一种，其实现是HTMLTagSupportWrapper，此类将会寻找root/htmltag目录下同名的标签文件作为模板来执行。类似普通模板一样，在此就不详细说了
3.4.1. 标签函数
标签函数类似jsp2.0的实现方式，需要实现Tag类的render方法即可
1
2
3
4
5
6
7
8
9
10
11
12
|
public class DeleteTag extends Tag
{
@Override
public void render()
{
// do nothing,just ignore body
ctx.byteWriter.write("被删除了，付费可以看")
}
}
|
如上一个最简单的Tag，将忽略tag体，并输出内容
1
2
3
4
5
6
7
8
9
10
11
|
public class XianDeDantengTag extends Tag
{
@Override
public void render()
{
doBodyRender();
}
}
|
此类将调用父类方法doBodyRender，渲染tag body体
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class CompressTag extends Tag
{
@Override
public void render()
{
BodyContent content = getBodyContent();
String content = content.getBody();
String zip = compress(conent);
ctx.byteWriter.write(zip);
}
}
|
此类将调用父类方法getBodyContent ，获得tag body后压缩输出
tag类提供了如下属性和方法供使用
-
args 传入标签的参数
-
gt GroupTemplate
-
ctx Context
-
bw 当前的输出流
-
bs 标签体对应的语法树，不熟悉勿动
3.5. 自定义虚拟属性
可以为特定类注册一个虚拟属性，也可以为一些类注册虚拟属性
-
public void registerVirtualAttributeClass(Class cls, VirtualClassAttribute virtual) 实现VirtualClassAttribute方法可以为特定类注册一个需要属性，如下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
gt.registerVirtualAttributeClass(User.class, new VirtualClassAttribute() {
@Override
public String eval(Object o, String attributeName, Context ctx)
{
User user = (User) o;
if(attributeName.equals("ageDescritpion")){
if (user.getAge() < 10)
{
return "young";
}
else
{
return "old";
}
}
}
});
|
User类的所有虚拟属性将执行eval方法，此方法根据年纪属性来输出对应的描述。
-
public void registerVirtualAttributeEval(VirtualAttributeEval e) 为一些类注册需要属性，VirtualAttributeEval.isSupport方法将判断是否应用虚拟属性到此类
如下是虚拟属性类的定义
1
2
3
4
5
6
7
8
9
10
11
12
|
public interface VirtualClassAttribute
{
public Object eval(Object o, String attributeName, Context ctx);
}
public interface VirtualAttributeEval extends VirtualClassAttribute
{
public boolean isSupport(Class c, String attributeName);
}
|
3.6. 使用额外的资源加载器
某些情况下，模板来源不止一处，GroupTemplate配置了一个默认的资源加载器，如果通过gt.getTemplate(key),将调用默认的ResourceLoader，获取模板内容，然后转化为beetl脚本放入到缓存里。你也可以传入额外的资源管理器加载模板，通过调用gt.getTemplate(key,otherLoader)来完成;
1
2
3
4
5
6
7
8
9
10
11
|
GroupTemplate gt = new GroupTemplate(conf,fileLoader)
//自定义，参考下一节
MapResourceLoader dbLoader = new MapResourceLoader(getData());
Template t = gt.getTemplate("db:1", dbLoader);
private Map getData()
{
Map data = new HashMap();
data.put("db:1", "${a}");
return data;
}
|
对于更复杂的模板资源来源，也可以自定义一个资源加载来完成，参考下一节
3.7. 自定义资源加载器
如果模板资源来自其他地方，如数据库，或者混合了数据库和物理文件，或者模板是加密的，则需要自定义一个资源加载器。资源加载器需要实现ResourceLoader类。如下：
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
|
public interface ResourceLoader
{
/**
* 根据key获取Resource
*
* @param key
* @return
*/
public Resource getResource(String key);
/** 检测模板是否更改，每次渲染模板前，都需要调用此方法，所以此方法不能占用太多时间，否则会影响渲染功能
* @param key
* @return
*/
public boolean isModified(Resource key);
/**
* 关闭ResouceLoader，通常是GroupTemplate关闭的时候也关闭对应的ResourceLoader
*/
public void close();
/** 一些初始化方法
* @param gt
*/
public void init(GroupTemplate gt);
/** 用于include，layout等根据相对路径计算资源实际的位置.
* @param resource 当前资源
* @param key
* @return
*/
public String getResourceId(Resource resource, String key);
}
|
如下是一个简单的内存ResourceLoader
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
|
public class MapResourceLoader implements ResourceLoader
{
Map data;
public MapResourceLoader(Map data)
{
this.data = data;
}
@Override
public Resource getResource(String key)
{
String content = (String) data.get(key);
if (content == null)
return null;
return new StringTemplateResource(content, this);
}
@Override
public boolean isModified(Resource key)
{
return false;
}
@Override
public boolean exist(String key)
{
return data.contain(key);
}
@Override
public void close()
{
}
@Override
public void init(GroupTemplate gt)
{
}
@Override
public String getResourceId(Resource resource, String id)
{
//不需要计算相对路径
return id;
}
}
|
init方法可以初始化GroupTemplate，比如读取配置文件的root属性，autoCheck属性，字符集属性，以及加载functions目录下的所有模板方法 如FileResourceLoader 的 init方法
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
|
@Override
public void init(GroupTemplate gt)
{
Map<String, String> resourceMap = gt.getConf().getResourceMap();
if (this.root == null)
{
this.root = resourceMap.get("root");
}
if (this.charset == null)
{
this.charset = resourceMap.get("charset");
}
if (this.functionSuffix == null)
{
this.functionSuffix = resourceMap.get("functionSuffix");
}
this.autoCheck = Boolean.parseBoolean(resourceMap.get("autoCheck"));
File root = new File(this.root, this.functionRoot);
this.gt = gt;
if (root.exists())
{
readFuntionFile(root, "", "/".concat(functionRoot).concat("/"));
}
}
|
readFuntionFile 方法将读取functions下的所有模板，并注册为方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
protected void readFuntionFile(File funtionRoot, String ns, String path)
{
String expected = ".".concat(this.functionSuffix);
File[] files = funtionRoot.listFiles();
for (File f : files)
{
if (f.isDirectory())
{
//读取子目录
readFuntionFile(f, f.getName().concat("."), path.concat(f.getName()).concat("/"));
}
else if (f.getName().endsWith(functionSuffix))
{
String resourceId = path + f.getName();
String fileName = f.getName();
fileName = fileName.substring(0, (fileName.length() - functionSuffix.length() - 1));
String functionName = ns.concat(fileName);
FileFunctionWrapper fun = new FileFunctionWrapper(resourceId);
gt.registerFunction(functionName, fun);
}
}
}
|
Resource类需要实现OpenReader方法，以及isModified方法。对于模板内容存储在数据库中，openReader返回一个Clob，isModified 则需要根据改模板内容对应的lastUpdate（通常数据库应该这么设计）来判断模板是否更改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public abstract class Resource
{
/**
* 打开一个新的Reader
*
* @return
*/
public abstract Reader openReader();
/**
* 检测资源是否改变
*
* @return
*/
public abstract boolean isModified();
|
参考例子可以参考beetl自带的ResourceLoader
3.8. 使用CompositeResourceLoader
组合加载器，可以包含多个已有的ResourceLoader，如下代码创建一个包含俩个文件和内存的ResourceLoader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
FileResourceLoader fileLoader1 = new FileResourceLoader(path1);
FileResourceLoader fileLoader2 = new FileResourceLoader(path2);
Map data = getData();
// 根据id加载
MapResourceLoader mapLoader = new MapResourceLoader(data);
CompositeResourceLoader loader = new CompositeResourceLoader();
loader.addResourceLoader(new StartsWithMatcher("http:").withoutPrefix(), fileLoader2);
loader.addResourceLoader(new StartsWithMatcher("db:"), mapLoader);
loader.addResourceLoader(new AllowAllMatcher(), fileLoader1);
GroupTemplate gt = new GroupTemplate(loader, conf);
Template t = gt.getTemplate("/xxx.html");
|
如上例子，groupTemplate从CompositeResourceLoader里加载/xxx.html，由于http:和db:前缀都不匹配，因此，将实际采用fileLoader1加载path1+/xxx.html，如下是xxx.html文件内容
1
2
3
4
|
<%
include("/xxx2.html"){}
include("http:/xxx.html"){}
%>
|
第2行仍然是由fileLoader1加载，但第3行以http:前缀开头，因此将fileLoader2加载path2+/xxx.html.xxx.html内容如下
1
2
3
|
<%
include("db:1"){}
%>
|
因为以db:开头，因此会采用MapResourceLoader加载，内容是key为db:1对模板
3.9. 自定义错误处理器
错误处理器需要实现ErrorHandler接口的processExcption(BeetlException beeExceptionos, Writer writer);
-
beeExceptionos，模板各种异常
-
writer 模板使用的输出流。系统自带的并未采用此Writer，而是直接输出到控制台
自定义错误处理可能是有多个原因，比如
1 想将错误输出到页面而不是控制台
2 错误输出美化一下，而不是自带的格式
3 错误输出的内容做调整，如不输出错误行的模板内容，而仅仅是错误提示
4 错误输出到日志系统里
5 不仅仅输出日志，还抛出异常。默认自带的不会抛出异常，ReThrowConsoleErrorHandler 继承了ConsoleErrorHandler方法，打印异常后抛出
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class ReThrowConsoleErrorHandler extends ConsoleErrorHandler
{
@Override
public void processExcption(BeetlException ex, Writer writer)
{
super.processExcption(ex, writer);
throw ex;
}
}
|
beetl 提供 ErrorInfo类来wrap BeetlException，转化为较为详细的提示信息，他具有如下信息
-
type 一个简单的中文描述
-
errorCode 内部使用的错误类型标识
-
errorTokenText 错误发生的节点文本
-
errorTokenLine 错误行
-
msg 错误消息，有可能没有，因为有时候errorCode描述的已经很清楚了
-
cause 错误的root 异常，也可能没有。
BeetlException 也包含了一个关键信息就是 resourceId，即出错所在的模板文件
3.10. 自定义安全管理器
所有模板的本地调用都需要通过安全管理器校验，默认需要实现NativeSecurityManager 的public boolean permit(String resourceId, Class c, Object target, String method) 方法
如下是默认管理器的实现方法
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
|
public class DefaultNativeSecurityManager implements NativeSecurityManager
{
@Override
public boolean permit(String resourceId, Class c, Object target, String method)
{
if (c.isArray())
{
//允许调用，但实际上会在在其后调用中报错。不归此处管理
return true;
}
String name = c.getSimpleName();
String pkg = c.getPackage().getName();
if (pkg.startsWith("java.lang"))
{
if (name.equals("Runtime") || name.equals("Process") || name.equals("ProcessBuilder")
|| name.equals("System"))
{
return false;
}
}
return true;
}
}
|
3.11. 注册全局共享变量
groupTemplate.setSharedVars(Map<String, Object> sharedVars)
3.12. 布局
布局可以通过Beetl提供的include,layout 以及模板变量来完成。模板变量能完成复杂的布局
-
采用layout include
1
2
3
4
5
6
|
<%
//content.html内容如下：
layout("/inc/layout.html"){%>
this is 正文
..........
<%}%>
|
如上一个子页面将使用layout布局页面，layout 页面内容如下
1
2
3
|
<%include("/inc/header.html"){} %>
this is content:${layoutContent}
this is footer:
|
layoutContent 是默认变量，也可以改成其他名字，具体请参考layout标签函数
全局变量总是能被布局用的页面所使用，如果布局页面需要临时变量，则需要显示的传入，如：
1
2
3
|
<%
var user= model.user;
include("/inc/header.html",{title:'这是一个测试页面',user:user}){} %>
|
这样，title和user成为全局变量，能被header.html 及其子页面引用到
-
继承布局：采用模板变量和include
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<%
var jsPart = {
%>
web页面js部分
<%};%>
<%
var htmlPart = {
%>
web页面html部分
<%};
include("/inc/layout.html",{jsSection:jsPart,htmlSection:htmlPart}){}
%>
|
layout.html页面如下：
1
2
3
4
5
6
7
8
|
<body>
<head>
${jsSection}
</head>
<body>
.......
${htmlSection}
</body>
|
3.13. 性能优化
Beetl性能已经很快了，有些策略能更好提高性能
-
使用二进制输出，此策略可以使模板在语法分析的时候将静态文本转化为二进制，省去了运行时刻编码时间，这是主要性能提高方式。但需要注意，此时需要提供一个二进制输出流，而不是字符流，否则性能反而下降
-
使用FastRuntimeEngine，默认配置。 此引擎能对语法树做很多优化，从而提高运行性能，如生成字节码来访问属性而不是传统的反射访问。关于引擎，可能在新的版本推出更好的引擎，请随时关注。
-
通过@type 来申明全局变量类型，这不能提高运行性能，但有助于模板维护
-
自定义ResourceLoader的isModified必须尽快返回，因此每次渲染模板的时候都会调用此方法
为什么Beetl性能这么好…………(待续)
3.14. 分布式缓存模板
Beetl模板引擎模板在同一个虚拟机里缓存Beetl 脚本。也可以将缓存脚本到其他地方，只要实现Cache接口，并设置ProgramCacheFactory.cache即可，这样GroupTemplate将从你提供的Cache中存取Beetl脚本
3.15. 定制输出
占位符输出允许定制。如所有日期类型都按照某个格式化输出，而不需要显示的使用格式化输出，或者为了防止跨脚本站点攻击，需要对类型为String的值做检查等，不必使用格式化函数，可以直接对占位符输出进行定制，代码如下
1
2
3
4
5
6
7
8
9
10
|
PlaceholderST.output = new PlaceholderST.Output(){
@Override
public void write(Context ctx, Object value) throws IOException {
//定制输出
ctx.byteWriter.writeString("ok"+value!=null?value.toString:"");
}
};
|
如果PlaceholderST静态变量output 不为null，将使用output 来输出
3.16. 定制模板引擎
Beetl在线体验（http://ibeetl.com:8080/beetlonline/）面临一个挑战，允许用户输入任何脚本做练习或者分享代码。但又需要防止用户输入恶意的代码，如
1
2
3
4
5
|
<%
for(var i=0;i<10000000;i++){
//其他代码
}
%>
|
此时，需要定制模板引擎，遇到for循环的时候，应该限制循环次数，譬如，在线体验限制最多循5次，这是通过定义替换GeneralForStatement类来完成的，这个类对应了for(exp;exp;exp) ，我们需要改成如下样子：
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
78
79
80
81
82
83
84
85
86
87
|
class RestrictForStatement extends GeneralForStatement
{
public RestrictForStatement(GeneralForStatement gf)
{
super(gf.varAssignSeq, gf.expInit, gf.condtion, gf.expUpdate, gf.forPart, gf.elseforPart, gf.token);
}
public void execute(Context ctx)
{
if (expInit != null)
{
for (Expression exp : expInit)
{
exp.evaluate(ctx);
}
}
if (varAssignSeq != null)
{
varAssignSeq.execute(ctx);
}
boolean hasLooped = false;
int i = 0;
for (; i < 5; i++)
{
boolean bool = (Boolean) condtion.evaluate(ctx);
if (bool)
{
hasLooped = true;
forPart.execute(ctx);
switch (ctx.gotoFlag)
{
case IGoto.NORMAL:
break;
case IGoto.CONTINUE:
ctx.gotoFlag = IGoto.NORMAL;
continue;
case IGoto.RETURN:
return;
case IGoto.BREAK:
ctx.gotoFlag = IGoto.NORMAL;
return;
}
}
else
{
break;
}
if (this.expUpdate != null)
{
for (Expression exp : expUpdate)
{
exp.evaluate(ctx);
}
}
}
if (i >= 5)
{
try
{
ctx.byteWriter.writeString("--Too may Data in loop，Ignore the left Data for Online Engine--");
ctx.byteWriter.flush();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@Override
public void infer(InferContext inferCtx)
{
super.infer(inferCtx);
}
}
|
尽管上面代码很复杂，但实际上是改写了原来的GeneralForStatement，将原来的24行while(true) 替换成for (; i < 5; i++) 用来控制最大循环，并且62行检测如果循环退出后，i等于5，则提示Too Many Data in Loop.
现在需要将此类替换原有的GeneralForStatement，
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class OnlineTemplateEngine extends DefaultTemplateEngine
{
public Program createProgram(Resource resource, Reader reader, Map<Integer, String> textMap, String cr,
GroupTemplate gt)
{
Program program = super.createProgram(resource, reader, textMap, cr, gt);
modifyStatemetn(resource,program,gt);
return program;
}
private void modifyStatemetn(Resource resource,Program program,GroupTemplate gt){
Statement[] sts = program.metaData.statements;
StatementParser parser = new StatementParser(sts, gt, resource.getId());
parser.addListener(WhileStatement.class, new RestrictLoopNodeListener());
parser.addListener(GeneralForStatement.class, new RestrictLoopNodeListener());
parser.parse();
}
}
|
继承FastRuntimeEngine有所不同，因为改引擎会copy出一个脚本做分析优化，因此，俩个脚本都需要做修改
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class OnlineTemplateEngine extends FastRuntimeEngine
{
public Program createProgram(Resource resource, Reader reader, Map<Integer, String> textMap, String cr,
GroupTemplate gt)
{
FilterProgram program = (FilterProgram)super.createProgram(resource, reader, textMap, cr, gt);
modifyStatemetn(resource,program,gt);
modifyStatemetn(resource,program.getCopy(),gt);
return program;
}
}
|
-
StatementParser 是关键类，他允许对模板的Program进行解析，并替换其中的Statement。parser.addListener 方法接受俩个参数，第一个是需要找的类，第二个是执行的监听器。
-
可以参考在线体验的源码：http://git.oschina.net/xiandafu/beetlonline/blob/master/src/org/bee/tl/online/OnlineTemplateEngine.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class RestrictLoopNodeListener implements Listener
{
@Override
public Object onEvent(Event e)
{
Stack stack = (Stack) e.getEventTaget();
Object o = stack.peek();
if (o instanceof GeneralForStatement)
{
GeneralForStatement gf = (GeneralForStatement) o;
RestrictForStatement rf = new RestrictForStatement(gf);
return rf;
}
else
{
return null;
}
}
|
该监听器返回一个新的RestrictForStatement 类，用来替换来的GeneralForStatement。如果返回null，则不需替换。这通常发生在你仅仅通过修改该类的某些属性就可以的场景
完成这些代码后，在配置文件中申明使用新的引擎
1
|
ENGINE=org.bee.tl.online.OnlineTemplateEngine
|
这样就完成了模板引擎定制。
3.17. 直接运行Beetl脚本
Beetl模板本质上会转化为Beetl脚本来执行，这点跟jsp转为servlet来执行类似。GroupTemplate提供方法可以直接执行Beetl脚本
-
public Map runScript(String key, Map<String, Object> paras) throws ScriptEvalError
-
public Map runScript(String key, Map<String, Object> paras, Writer w) throws ScriptEvalError
-
public Map runScript(String key, Map<String, Object> paras, Writer w, ResourceLoader loader) throws ScriptEvalError
key为资源名，paras为脚本的全局变量，w可选参数，如果执行脚本有输出，则输出到w里,loader参数可选，如果指定，则使用此laoder加载脚本
执行脚本完毕后，返回到Map里的值可能包含如下：
-
模板的顶级的临时变量,key为临时变量名
-
return 值将返回到map里 ，key为return
如下脚本（此时就不需要脚本定界符了）
1
2
3
4
|
var a = 1;
var b = date();
var c = '2';
return a+1;
|
调用runScript后，map里将返回key分别为a,b,c，return。 值分别为1，当前日期，字符串'2，以及3.