import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
public boolean render(RequestWeb req, View view)
{
  String viewName = view.name();

  if (! viewName.endsWith(".jetx")) {
    return false;
  }

  try {
    JetTemplate template = _engine.getTemplate(viewName);
    JetContext ctx = new JetContext();
    ctx.putAll(view.map());

    req.type("text/html; charset=utf-8");

    template.render(ctx, req.writer());

    req.ok();
  }
  catch (Exception e) {
    req.fail(e);
  }

  return true;
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
public void render(Response response, Request request, Object retVal) throws AppRenderException {
    Long start = System.currentTimeMillis();
    String charsetEncoding = engine.getConfig().getOutputEncoding().name();
    response.setCharacterEncoding(charsetEncoding);
    if (response.getContentType() == null) {
        response.setContentType("text/html; charset=" + charsetEncoding);
    }

    try {
        JetTemplate template = engine.getTemplate(retVal.toString());
        JetWebContext context = new JetWebContext(request, response);
        template.render(context, response.getOutputStream());
    } catch (IOException e) {
        throw new IllegalStateException(e);
    }
    LOGGER.debug("end jetbrick template render : {}", System.currentTimeMillis() - start);
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
public void render(HttpServletRequest request, HttpServletResponse response, String viewPath) {
	if (JetWebEngineLoader.unavailable()) {
		JetWebEngineLoader.setServletContext(request.getSession().getServletContext());
	}
	JetContext context = new JetWebContext(request, response);
	if(!view.endsWith(Const.VIEW_EXT)){
		view += Const.VIEW_EXT;
	}
	if(view.endsWith("/" + Const.VIEW_EXT) ){
		return;
	}
	JetTemplate template = JetWebEngineLoader.getJetEngine().getTemplate(view);
	try {
		template.render(context, response.getOutputStream());
	} catch (IOException e) {
		throw ExceptionUtils.uncheck(e);
	}
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
protected void doExecute(String location, ActionInvocation ai) throws Exception {
    Map<String, Object> model = ai.getStack().getContext();
    HttpServletRequest request = (HttpServletRequest) model.get(ServletActionContext.HTTP_REQUEST);
    HttpServletResponse response = (HttpServletResponse) model.get(ServletActionContext.HTTP_RESPONSE);

    if (JetWebEngineLoader.unavailable()) {
        ServletContext servletContext = (ServletContext) model.get(ServletActionContext.SERVLET_CONTEXT);
        JetWebEngineLoader.setServletContext(servletContext);
    }

    JetContext context = new JetWebContext(request, response, null);
    context.put("action", ai.getAction());
    context.put("valueStack", model);
    JetTemplate template = JetWebEngineLoader.getJetEngine().getTemplate(location);
    template.render(context, response.getOutputStream());
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
public void processView(ViewEngineContext context) throws ViewEngineException {
	try {
		JetTemplate template = jetEngine.getTemplate(resolveView(context));
		Writer writer = context.getResponse().getWriter();
		template.render(context.getModels(), writer);
	} catch (TemplateException | IOException e) {
		throw new ViewEngineException(e);
	}
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
public String render(ModelAndView modelAndView) {
    JetTemplate template = jetEngine.getTemplate(modelAndView.getViewName());
    Object model = modelAndView.getModel();
    if (model instanceof Map) {
        Map<String, Object> modelMap = (Map<String, Object>) model;
        JetContext context = new JetContext(modelMap.size());
        context.putAll(modelMap);
        StringWriter writer = new StringWriter();
        template.render(context, writer);
        return writer.toString();
    } else {
        throw new IllegalArgumentException("modelAndView.getModel() must return a java.util.Map");
    }
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
public void render(HttpServletRequest req, HttpServletResponse resp, Object obj) throws Throwable {
    JetContext context = new JetWebContext(req, resp);
    JetTemplate template = JetWebEngineLoader.getJetEngine().getTemplate(evalPath(req, obj));
    try {
        template.render(context, resp.getOutputStream());
    } catch (IOException e) {
        throw Lang.wrapThrow(e);
    }
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
public static void asInclude(JetPageContext ctx, String relativeName, Map<String, Object> parameters) {
    if (relativeName == null || relativeName.length() == 0) {
        throw new IllegalArgumentException("argument relativeName is null or empty.");
    }
    String file = ctx.getAbsolutionName(relativeName);
    JetTemplate template = ctx.getEngine().getTemplate(file);
    JetContext context = new JetContext(ctx.getContext(), parameters);
    JetWriter writer = ctx.getWriter();
    template.render(context, writer);
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
public static String asIncludeContent(JetPageContext ctx, String relativeName, Map<String, Object> parameters) {
    if (relativeName == null || relativeName.length() == 0) {
        throw new IllegalArgumentException("argument relativeName is null or empty.");
    }
    String file = ctx.getAbsolutionName(relativeName);
    JetTemplate template = ctx.getEngine().getTemplate(file);
    JetContext context = new JetContext(ctx.getContext(), parameters);

    UnsafeCharArrayWriter os = new UnsafeCharArrayWriter();
    template.render(context, os);
    return os.toString();
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
public static void main(String[] args) {
    Properties config = new Properties();
    //config.put(JetConfig.COMPILE_TOOL, JdtCompiler.class.getName());
    JetEngine engine = JetEngine.create(config);

    JetTemplate template = engine.createTemplate("是否登录");
    StringWriter out = new StringWriter();
    template.render(new HashMap<String, Object>(), out);
    System.out.println(out.toString());
}
 

import jetbrick.template.JetTemplate; //导入依赖的package包/类
@Override
protected void renderMergedTemplateModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
    JetContext context = new JetWebContext(request, response, model);
    JetTemplate template = JetWebEngineLoader.getJetEngine().getTemplate(getUrl());
    template.render(context, response.getOutputStream());
}