freemarker.template.Version#freemarker.core.Environment源码实例Demo

@Override
public void execute(Environment environment, Map map, TemplateModel[] templateModels, TemplateDirectiveBody templateDirectiveBody) throws TemplateException, IOException {
    final DefaultObjectWrapperBuilder builder = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_25);
    if (map.containsKey(METHOD_KEY)) {
        String method = map.get(METHOD_KEY).toString();
        switch (method) {
            case "postsCount":
                environment.setVariable("postsCount", builder.build().wrap(postService.findPostByStatus(PostStatusEnum.PUBLISHED.getCode(), PostTypeEnum.POST_TYPE_POST.getDesc()).size()));
                break;
            case "archives":
                environment.setVariable("archives", builder.build().wrap(postService.findPostGroupByYearAndMonth()));
                break;
            case "archivesLess":
                environment.setVariable("archivesLess", builder.build().wrap(postService.findPostGroupByYear()));
                break;
            case "hotPosts":
                environment.setVariable("hotPosts", builder.build().wrap(postService.hotPosts()));
                break;
            default:
                break;
        }
    }
    templateDirectiveBody.render(environment.getOut());
}
 

@Override
public void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body) throws TemplateException, IOException {
	String insertPrefix = getInsertPrefix(params);
	List<String> trimPrefixs = getTrimPrefixs(params);
	List<String> trimSuffixs = getTrimSuffixs(params);
	
	StringWriter writer = new StringWriter();
	body.render(writer);
	
	StringBuilder buffer = new StringBuilder(writer.toString().trim());
	if (StringUtils.isBlank(buffer)) {
		return ;
	}

	final String sql = buffer.toString().toLowerCase();
	
	trimPrefixs(buffer, sql, trimPrefixs);
	trimSuffixs(buffer, sql, trimSuffixs);
	
	buffer.insert(0, " ");
	buffer.insert(0, insertPrefix);
	env.getOut().append(buffer);
}
 

private static Map<String, Object> handleException(Exception e, String exMode, Environment env) throws TemplateModelException {
    int dashIndex = exMode.indexOf('-');
    if (dashIndex > 0) {
        exMode = exMode.substring(0, dashIndex);
    }
    if ("null".equals(exMode)) {
        return null;
    } else if ("empty".equals(exMode)) {
        return new HashMap<>(); // Use new map, just in case (not performance-sensitive): Collections.emptyMap();
    } else if ("throw".equals(exMode)) {
        throw new TemplateModelException(e);
    } else {
        Map<String, Object> result = "error".equals(exMode) ? ServiceUtil.returnError(e.getMessage()) : new HashMap<>();
        result.put("errorEx", e);
        result.put("errorMessageEx", e.getMessage());
        return result;
    }
}
 

public void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body) throws TemplateException, IOException {
    if(!params.containsKey("with")) {
        throw new RuntimeException("\"with\" param was not provided");
    }

    String withArgument = params.get("with").toString();

    StringWriter innerContent = new StringWriter();
    body.render(innerContent);        

    SimpleHash envValues = getHash(env);
    envValues.putAll(params);
    envValues.put("page_content", innerContent.toString());
    for(Object key : params.keySet()) {
        if(key.toString().equals("with")) {
            continue;
        } else {
            envValues.put(key.toString(), params.get(key));
        }
    }

    String path = getTemplatePath(env.getTemplate().getName(), withArgument);
    Template template = env.getConfiguration().getTemplate(path + ".ftl");
    template.process(envValues, env.getOut());
}
 

@SuppressWarnings("rawtypes")
public void execute(Environment env, Map params, TemplateModel[] loopVars,
		TemplateDirectiveBody body) throws TemplateException, IOException {
	DefaultObjectWrapperBuilder builder = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_25);
	// 获取页面的参数
	Long questionId = null;
	
	@SuppressWarnings("unchecked")
	Map<String, TemplateModel> paramWrap = new HashMap<String, TemplateModel>(params);
	for(String str:paramWrap.keySet()){ 
		if("questionId".equals(str)){
			questionId = Long.parseLong(paramWrap.get(str).toString());
		}
	}
	// 获取文件的分页
	Answer answer = answerService.findNewestAnswerById(questionId);
	env.setVariable("answer", builder.build().wrap(answer));
	body.render(env.getOut());
}
 

@Override
public void execute(Environment environment, Map map, TemplateModel[] templateModels, TemplateDirectiveBody templateDirectiveBody) throws TemplateException, IOException {
    this.verifyParameters(map);
    String funName = getMethod(map);
    Method method = null;
    Class clazz = classBucket.get(clazzPath);
    try {
        if (clazz != null && (method = clazz.getDeclaredMethod(funName, Map.class)) != null) {
            // 核心处理，调用子类的具体方法，获取返回值
            Object res = method.invoke(this, map);
            environment.setVariable(funName, getModel(res));
        }
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        log.error("无法获取[{}]的方法，或者调用[{}]方法发生异常", clazzPath, method, e);
    }
    templateDirectiveBody.render(environment.getOut());
}
 

protected void handleTemplateExceptionDebug(TemplateException te, Environment env, Writer out) throws TemplateException {
    StringWriter tempWriter = new StringWriter();
    PrintWriter pw = new PrintWriter(tempWriter, true);
    te.printStackTrace(pw);
    String stackTrace = tempWriter.toString();

    UtilCodec.SimpleEncoder simpleEncoder = FreeMarkerWorker.getWrappedObject("simpleEncoder", env);
    if (simpleEncoder != null) {
        stackTrace = simpleEncoder.encode(stackTrace);
    }
    try {
        out.write(stackTrace);
    } catch (IOException e) {
        Debug.logError(e, module);
    }
}
 

@Override
public ObjectWrapper getWrapper(Environment env) {
    ObjectWrapper curr = env.getObjectWrapper();
    if (curr instanceof ScipioExtendedObjectWrapper) {
        if (curr instanceof ScipioBeansWrapper) {
            if (((BeansWrapper) curr).isSimpleMapWrapper()) {
                return FreeMarkerWorker.getDefaultOfbizSimpleMapWrapper();
            } else {
                return FreeMarkerWorker.getDefaultOfbizWrapper();
            }
        } else {
            return FreeMarkerWorker.getDefaultOfbizSimpleMapWrapper();
        }
    } else {
        return curr;
    }
}
 

@Override
public void execute(Environment env,
                    Map params, TemplateModel[] loopVars,
                    TemplateDirectiveBody body) throws TemplateException, IOException {

    TemplateDirectiveBodyOverrideWraper current = (TemplateDirectiveBodyOverrideWraper) env.getVariable(DirectiveUtils.OVERRIDE_CURRENT_NODE);
    if (current == null) {
        throw new TemplateException("<@super/> direction must be child of override", env);
    }
    TemplateDirectiveBody parent = current.parentBody;
    if (parent == null) {
        throw new TemplateException("not found parent for <@super/>", env);
    }
    parent.render(env.getOut());

}
 

/**
 * Tries to get appropriate location-based UtilCache in use for templates being rendered.
 * <p>
 * FIXME: WARNING: massive limitations here, we do not have access to all the Configuration instances
 * we'd need to test to implement this, and a host of problems...
 * as a result I am creating a new two-layer cache system that first keys on the Configuration instances.
 */
public static UtilCache<String, Template> getTemplateLocationCacheForConfig(Configuration config, Environment env) throws TemplateModelException {
    Map<Configuration, UtilCache<String, Template>> configTmplLocCaches = TemplateSource.configTmplLocCaches;

    UtilCache<String, Template> cache = configTmplLocCaches.get(config);
    if (cache == null) {
        // double-locking idiom, with configTmplLocCaches as unmodifiable
        synchronized(TemplateSource.class) {
            configTmplLocCaches = TemplateSource.configTmplLocCaches;
            cache = configTmplLocCaches.get(config);
            if (cache == null) {
                Map<Configuration, UtilCache<String, Template>> newConfigCacheMap = new HashMap<>(configTmplLocCaches);
                cache = UtilCache.createUtilCache("templatesource.ftl.location." + (configTmplLocCaches.size() + 1),
                            0, configTmplCacheExpireTime, false);
                newConfigCacheMap.put(config, cache);

                TemplateSource.configTmplLocCaches = newConfigCacheMap;
            }
        }
    }
    return cache;
}
 

/**
 * Method providing support for a stack structure having request scope, with fallback to globals.
 * <p>
 * <strong>Do not access underlying structure directly.</strong>
 *
 * @see #setRequestVar
 */
static void pushRequestStack(String name, Object value, boolean setLast, HttpServletRequest request,
        Map<String, Object> context, Environment env) throws TemplateModelException {
    // NOTE: There is no value wrapping or unwrapping in these methods anymore; we just store them and all wrapping/unwrapping
    // is left to caller unless absolutely necessary (and in those cases, he specifies the objectWrapper for behavior).
    //if (value instanceof TemplateModel) {
    //    value = FtlTransformUtil.unwrapPermissive((TemplateModel) value);
    //}
    // if env.setGlobalVariable:
    if (request != null) {
        updateStack(getRequestVarMapFromReqAttribs(request), name, value, setLast, "request attributes");
    }
    else {
        Map<String, Object> globalContext = getGlobalContext(context, env);
        if (globalContext != null) {
            updateStack(getRequestVarMapFromGlobalContext(globalContext), name, value, setLast, "globalContext");
        }
        else if (env != null) {
            updateStack(getRequestVarMapFromFtlGlobals(env), name, value, setLast, "FTL globals");
        }
        else {
            throw new IllegalArgumentException("No request, context or ftl environment to push request scope stack (name: " + name + ")");
        }
    }
}
 

@SuppressWarnings("rawtypes")
@Override
public void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body) throws TemplateException, IOException {
	Properties properties = propertiesRepository.findByCode("app.logo");
	Text text = textService.loadById(properties.getValue());
	if(text == null){
		Logger.error("logo图标信息为空");
		env.getOut().write("");
	}
	String logoBase64Code = text.getText();
	if (!Strings.empty(logoBase64Code)) {
		env.getOut().write(logoBase64Code);
	}else{
		Logger.error("logo图标没有初始化，请到后台配置");
	}
}
 

public static TemplateModel getVariable(Environment env, String name, boolean throwIfError){
	TemplateModel model = null;
	try {
		model = env.getVariable(name);
	} catch (Exception e) {
		if(throwIfError)
			throw new BaseException("get variable["+name+"] error: " + e.getMessage(), e);
	}
	return model;
}
 

@Override
public void execute(Environment environment, Map map, TemplateModel[] templateModels, TemplateDirectiveBody templateDirectiveBody) throws TemplateException, IOException {
    System.out.println("=================解析自定义tag=================" + map);
    DefaultObjectWrapperBuilder builder = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_25);
    if (map.containsKey(METHOD_KEY)) {
        String method = map.get(METHOD_KEY).toString();
        switch (method) {
            case "availableMenus":
                // 获取所有可用的菜单资源
                environment.setVariable("availableMenus", builder.build().wrap(resourcesService.listAllAvailableMenu()));
                break;
            case "menus":
                Integer userId = null;
                if (map.containsKey("userId")) {
                    String userIdStr = map.get("userId").toString();
                    if (StringUtils.isEmpty(userIdStr)) {
                        return;
                    }
                    userId = Integer.parseInt(userIdStr);
                }
                Map<String, Object> params = new HashMap<>(2);
                params.put("type", "menu");
                params.put("userId", userId);
                environment.setVariable("menus", builder.build()
                        .wrap(resourcesService.listUserResources(params)));
                break;
            default:
                break;
        }
    }
    templateDirectiveBody.render(environment.getOut());
}
 

@Override
public void execute(Environment env,
                    Map params,
                    TemplateModel[] loopVars,
                    TemplateDirectiveBody body)
        throws TemplateException, IOException {

    TemplateModel dataModel = env.getDataModel().get("this");
    if (!(dataModel instanceof ContentNodeHashModel)) {
        throw new TemplateModelException(
                "Data model is not a ContentNodeHashModel");
    }
    ContentNode node = ((ContentNodeHashModel) dataModel).getContentNode();
    if (node == null) {
        throw new TemplateModelException("'this' has a null content-node");
    }

    Object page = node.getDocument().getAttribute("page");
    if (page == null || !(page instanceof Page)) {
        throw new TemplateModelException("Unable to get page instance");
    }

    if (body == null) {
        throw new TemplateModelException("Body is null");
    }
    StringWriter writer = new StringWriter();
    body.render(writer);
    bindings.put(((Page) page).getSourcePath(), writer.toString());
}
 

@Override
public void render(Environment env, Map params, TemplateDirectiveBody body) throws IOException, TemplateException {
    boolean show = showBody(getName(params));
    if (show) {
        renderBody(env, body);
    }
}
 

protected void executeTyped(Environment env, Map<String, TemplateModel> params, TemplateModel[] loopVars, TemplateDirectiveBody body)
        throws TemplateException, IOException {
    Writer writer = env.getOut();

    // NOTE: this can only work if we already had a RenderWriter.
    // if not, don't even bother trying.
    if (writer instanceof RenderWriter) {
        Map<String, Object> context = ContextFtlUtil.getContext(env);
        WidgetRenderTargetState renderTargetState = WidgetRenderTargetExpr.getRenderTargetState(context);
        if (renderTargetState.isEnabled()) {
            String name = TransformUtil.getStringNonEscapingArg(params, "name");
            String containsExpr = TransformUtil.getStringNonEscapingArg(params, "contains");
            String location = "unknown-location"; // FIXME
            ModelFtlWidget widget = new ModelVirtualSectionFtlWidget(name, location, containsExpr);

            WidgetRenderTargetState.ExecutionInfo execInfo = renderTargetState.handleShouldExecute(widget, writer, context, null);
            if (!execInfo.shouldExecute()) {
                return;
            }
            try {
                if (body != null) {
                    body.render((Writer) execInfo.getWriterForElementRender());
                }
            } finally {
                execInfo.handleFinished(context); // SCIPIO: return logic
            }
            return;
        }
    }

    body.render(writer);
}
 

/**
 * Performs the logical raw string operation on multiple values, concatenating the result.
 */
public static TemplateScalarModel toRawString(Collection<TemplateModel> values, Environment env) throws TemplateModelException {
    StringBuilder sb = new StringBuilder();
    for(TemplateModel value: values) {
        if (value instanceof TemplateScalarModel) {
            sb.append(getAsStringNonEscaping((TemplateScalarModel) value));
        } else {
            sb.append(execStringBuiltIn(value, env).getAsString());
        }
    }
    return new SimpleScalar(sb.toString());
}
 

@Override
protected void execute(boolean hasPermission, Environment env, TemplateDirectiveBody body)
    throws TemplateException, IOException {
  if (hasPermission) {
    body.render(env.getOut());
  }
}
 

@Override
public void handleTemplateException(TemplateException te, Environment e, Writer writer) throws TemplateException {
    if (exceptions == null) {
        exceptions = new ArrayList<TemplateException>();
    }
    exceptions.add(te);
    try {
        writer.append(te.getLocalizedMessage());
    } catch (IOException ioex) {
        Exceptions.printStackTrace(ioex);
    }
}
 

public static TemplateModel getRequiredVariable(Environment env, String name, String msg){
	TemplateModel model = getVariable(env, name, true);
	if(model==null){
		if(StringUtils.isBlank(msg)){
			throw new BaseException("the variable["+name+"] can not be null!");
		}
	}
	return model;
}
 

@Override
public void render(Environment env, Map params, TemplateDirectiveBody body) throws IOException, TemplateException {
    if (getSubject() != null && getSubject().getPrincipal() != null) {
        log.debug("Subject has known identity (aka 'principal'). Tag body will be evaluated.");
        renderBody(env, body);
    } else {
        log.debug("Subject does not exist or have a known identity (aka 'principal'). Tag body will not be evaluated.");
    }
}
 

@Override
public void execute(Environment env, @SuppressWarnings("rawtypes") Map args, TemplateModel[] loopVars, TemplateDirectiveBody body)
        throws TemplateException, IOException {
    Map<String, Object> ctx = UtilGenerics.checkMap(FreeMarkerWorker.getWrappedObject("context", env), String.class, Object.class);
    String wrappedFTL = FreeMarkerWorker.getArg(UtilGenerics.checkMap(args, String.class, Object.class), "wrappedFTL", ctx);
    if (UtilValidate.isNotEmpty(wrappedFTL)) {
        env.getOut().write(wrappedFTL);
    } else {
        if (Debug.verboseOn()) {
            Debug.logVerbose("wrappedFTL was empty. skipping write.", module);
        }
    }
}
 

@Override
public void execute(Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body) throws TemplateException, IOException {
	String file = DirectivesUtils.getParameterByString(params, PARAMS_FILE, DEFAULT_LAYOUT);
	
	String template = env.toFullTemplateName("/", getActaulFile(params, file));
	if(!template.contains(".")){
		template += FTL;
	}
	body.render(env.getOut());
	env.include(template, DirectivesUtils.ENCODING, true);
}
 

@Override
public Object exec(@SuppressWarnings("rawtypes") List args) throws TemplateModelException {
    if (args == null || args.size() < 1 || args.size() > 3 ) {
        throw new TemplateModelException("Invalid number of arguments (expected: 1-3)");
    }
    Environment env = CommonFtlUtil.getCurrentEnvironment();
    TemplateModel object = (TemplateModel) args.get(0);

    String wrapperStr = null;
    String modeStr = null;
    if (args.size() >= 2) {
        TemplateScalarModel wrapperModel = (TemplateScalarModel) args.get(1);
        if (wrapperModel != null) {
            wrapperStr = wrapperModel.getAsString();
        }

        if (args.size() >= 3) {
            TemplateScalarModel modeModel = (TemplateScalarModel) args.get(2);
            if (modeModel != null) {
                modeStr = modeModel.getAsString();
            }
        }
    }

    Object res = LangFtlUtil.rewrapObject(object, WrappingOptions.makeOptions(wrapperStr, modeStr, env), env);
    return res;
}
 

@Override
public void execute(Environment env,
					Map params, TemplateModel[] loopVars,
					TemplateDirectiveBody body) throws TemplateException, IOException {
	String name = DirectiveUtils.getRequiredParam(params, "name");
	TemplateDirectiveBodyOverrideWraper overrideBody = DirectiveUtils.getOverrideBody(env, name);
	if(overrideBody == null) {
		if(body != null) {
			body.render(env.getOut());
		}
	}else {
		DirectiveUtils.setTopBodyForParentBody(env, new TemplateDirectiveBodyOverrideWraper(body,env), overrideBody);
		overrideBody.render(env.getOut());
	}
}
 

protected Object execPush(@SuppressWarnings("rawtypes") List args, boolean setLast) throws TemplateModelException {
    if (args == null || args.size() != 2) {
        throw new TemplateModelException("Invalid number of arguments (expected: 2)");
    }
    TemplateModel nameModel = (TemplateModel) args.get(0);
    if (!(nameModel instanceof TemplateScalarModel)) {
        throw new TemplateModelException("First argument not an instance of TemplateScalarModel (string)");
    }
    TemplateModel valueModel = (TemplateModel) args.get(1);

    Environment env = CommonFtlUtil.getCurrentEnvironment();
    ContextFtlUtil.pushRequestStack(LangFtlUtil.getAsStringNonEscaping(((TemplateScalarModel) nameModel)), valueModel, setLast, env);

    return new SimpleScalar("");
}
 

private void executeMacro(Appendable writer, String macro) throws IOException, TemplateException {
    Environment environment = getEnvironment(writer);
    Reader templateReader = new StringReader(macro);
    macroCount++;
    String templateName = toString().concat("_") + macroCount;
    Template template = new Template(templateName, templateReader, FreeMarkerWorker.getDefaultOfbizConfig());
    templateReader.close();
    FreeMarkerWorker.includeTemplate(template, environment); // SCIPIO: use FreeMarkerWorker instead of Environment
}
 

/**
 * Returns the contextPathPrefix from the environment or request
 * or null if not found. May be empty string.
 * @throws TemplateModelException
 */
public static String getContentPathPrefix(boolean nonEscaping, Environment env) throws TemplateModelException {
    TemplateModel model = TransformUtil.getFtlContextGlobalVar("contentPathPrefix", env);
    if (model instanceof TemplateScalarModel) {
        return LangFtlUtil.getAsString((TemplateScalarModel) model, nonEscaping);
    }
    HttpServletRequest request = ContextFtlUtil.getRequest(env);
    if (request != null) {
        Object res = request.getAttribute("contentPathPrefix");
        if (res instanceof String) {
            return (String) res;
        }
    }
    return null;
}
 

/**
 * Executes an arbitrary FTL function - non-abstracted version (for optimization only!).
 */
public static TemplateModel execFunction(Template functionCall, TemplateModel[] args, Environment env) throws TemplateModelException {
    final int argCount = (args != null) ? args.length : 0;
    for(int i=0; i < argCount; i++) {
        env.setVariable("_scpEfnArg"+i, args[i]);
    }
    execFtlCode(functionCall, env);
    return env.getVariable("_scpEfnRes");
}