模板语言绑定变量都是程序主动绑定到beetl，经过努力现在在beetl上实现了模板语言主动发出请求，来执行绑定。
最近做项目用到beetl，因为模板需要用到的变量很多，如果直接绑定，系统消耗很大。
产生了一个想法，当beetl解析不到变量的时候，通过JAVA接口直接获取对象返回给BEETL继续进行解析。
最终实现了Beetl主动发起绑定变量的功能。
修改的代码见最后。
调用时的代码如下：
StringTemplateResourceLoader resourceLoader = new StringTemplateResourceLoader();
Configuration conf = Configuration.defaultConfiguration();
conf.setEngine("org.koron.ebs.permission.beetl.MyEngine");//这里是改写过的引擎
GroupTemplate gt = new GroupTemplate(resourceLoader, conf);
Template t = gt.getTemplate("${sdf.name}<%for(u in user){print(u);}%>");
t.binding("user",new String[]{"IBM","GOOGLE"});
t.binding("VAR_NOT_DEFINED",new VarListener() {//绑定一个全局变量用来解析变量未定义变量
@Override
public Object parse(String var) {
if(java.util.regex.Pattern.compile("sdf\\.?").matcher(var).find())
{
POJO pj = new POJO();
pj.name="我试试";
pj.id="1111";
return pj;
}
return null;
}
});
t.renderTo(System.out);
package org.koron.ebs.permission.beetl;
import java.util.EventListener;
public interface VarListener extends EventListener{//用来解析变量用
/**
* 解析变量成一个实例，为NULL时，表示不解析
* @param var 变量名
* @return 实例
*/
public Object parse(String var);
}
第一次实现由模板语言主动调JAVA方法，感觉不错：）
修改的代码：
package org.koron.ebs.permission.beetl;
import java.io.Reader;
import java.util.Map;
import java.util.Stack;
import org.beetl.core.*;
import org.beetl.core.engine.FastRuntimeEngine;
import org.beetl.core.engine.FilterProgram;
import org.beetl.core.engine.StatementParser;
import org.beetl.core.exception.BeetlException;
import org.beetl.core.statement.*;
public class MyEngine extends FastRuntimeEngine {
/*
* (non-Javadoc)
*
* @see org.beetl.core.engine.DefaultTemplateEngine#createProgram(org.beetl
* .core.Resource, java.io.Reader, java.util.Map, java.lang.String,
* org.beetl.core.GroupTemplate)
*/
@Override
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;
}
private void modifyStatemetn(Resource resource, Program program, GroupTemplate gt) {
Statement[] sts = program.metaData.statements;
StatementParser parser = new StatementParser(sts, gt, resource.getId());
parser.addListener(VarRef.class, new VarRefListener());
parser.parse();
}
class VarRefListener implements Listener {
@Override
public Object onEvent(Event e) {
Stack<?> stack = (Stack<?>) e.getEventTaget();
Object o = stack.peek();
if (o instanceof VarRef)
return new MyVarRef((VarRef) o);
return null;
}
}
class MyVarRef extends VarRef implements IVarIndex {
private GrammarToken firstToken;
private VarRef var;
public MyVarRef(VarRef var) {
this(var.attributes, var.hasSafe, var.safe, var.token);
this.var = var;
this.varIndex = var.getVarIndex();
}
private MyVarRef(VarAttribute[] attributes, boolean hasSafe, Expression safe, GrammarToken token) {
this(attributes, hasSafe, safe, token, token);
}
private MyVarRef(VarAttribute[] attributes, boolean hasSafe, Expression safe, GrammarToken token, GrammarToken firstToken) {
super(attributes, hasSafe, safe, token, firstToken);
}
@Override
public Object evaluate(Context ctx) {
Object value = ctx.vars[varIndex];
if (value == Context.NOT_EXIST_OBJECT) {
if (hasSafe) {
return safe == null ? null : safe.evaluate(ctx);
} else {
Object o = ctx.globalVar.get("VAR_NOT_DEFINED");
if (o == null || !(o instanceof VarListener)) {
BeetlException ex = new BeetlException(BeetlException.VAR_NOT_DEFINED);
ex.pushToken(firstToken);
throw ex;
}
o = ((VarListener) o).parse(var.token.text);
if (o != null) {
ctx.vars[varIndex] = o;
value = ctx.vars[varIndex];
} else {
BeetlException ex = new BeetlException(BeetlException.VAR_NOT_DEFINED);
ex.pushToken(firstToken);
throw ex;
}
}
}
if (value == null) {
if (hasSafe) {
return safe == null ? null : safe.evaluate(ctx);
}
}
if (attributes.length == 0) {
return value;
}
for (int i = 0; i < attributes.length; i++) {
VarAttribute attr = attributes[i];
if (value == null) {
if (hasSafe) {
return safe == null ? null : safe.evaluate(ctx);
} else {
BeetlException be = new BeetlException(BeetlException.NULL, "空指针");
if (i == 0) {
be.pushToken(this.firstToken);
} else {
be.pushToken(attributes[i - 1].token);
}
throw be;
}
}
try {
value = attr.evaluate(ctx, value);
} catch (BeetlException ex) {
ex.pushToken(attr.token);
throw ex;
} catch (RuntimeException ex) {
BeetlException be = new BeetlException(BeetlException.ATTRIBUTE_INVALID, "属性访问出错", ex);
be.pushToken(attr.token);
throw be;
}
}
if (value == null && hasSafe) {
return safe == null ? null : safe.evaluate(ctx);
} else {
return value;
}
}
@Override
public void setVarIndex(int index) {
this.varIndex = index;
}
@Override
public int getVarIndex() {
return this.varIndex;
}
@Override
public void infer(InferContext inferCtx) {
Type type = inferCtx.types[this.varIndex];
Type lastType = type;
Type t = null;
for (VarAttribute attr : attributes) {
inferCtx.temp = lastType;
attr.infer(inferCtx);
t = lastType;
lastType = attr.type;
attr.type = t;
}
this.type = lastType;
if (safe != null) {
safe.infer(inferCtx);
if (!safe.type.equals(this.type)) {
this.type = Type.ObjectType;
}
}
}
/**
* @return 获取#{bare_field_comment}
*/
public GrammarToken getFirstToken() {
return firstToken;
}
}
}