beetl调用java方法_Beetl通过JAVA接口获取JAVA中的变量

标签：

模板语言绑定变量都是程序主动绑定到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}");

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

}

}

}

标签：