Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 1997-2013, www.tinygroup.org (luo_guo@icloud.com).

Licensed under the GPL, Version 3.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.gnu.org/licenses/gpl.html

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

 
 package org.tinygroup.template.impl;
 
 
 import java.io.Writer;
 import java.util.List;
 import java.util.Map;

模板引擎实现类 Created by luoguo on 2014/6/6.
 
 public class TemplateEngineDefault implements TemplateEngine {
 
     private static final String DEFAULT = "default";
 
     private String encode = "UTF-8";
     private I18nVisitor i18nVisitor;
     private boolean cacheEnabled = false;
     private List<StringmacroLibraryList = new ArrayList<String>();
     private String engineId;
 
 
     public boolean isSafeVariable() {
         return U.isSafeVariable();
     }
 
     public void setSafeVariable(boolean safeVariable) {
         U.setSafeVariable(safeVariable);
     }
 
     public boolean isCompactMode() {
         return .;
     }
 
     public void setCompactMode(boolean compactMode) {
         . = compactMode;
     }
 
     public boolean isCacheEnabled() {
         return ;
     }
 
     public TemplateEngine setCacheEnabled(boolean cacheEnabled) {
         this. = cacheEnabled;
         return this;
     }
 
     public void registerMacroLibrary(String paththrows TemplateException {
         registerMacroLibrary(getMacroLibrary(path));
     }
 
 
     public void registerMacro(Macro macrothrows TemplateException {
         .put(macro.getName(), macro);
     }
 
     public void registerMacroLibrary(Template templatethrows TemplateException {
         for (Map.Entry<StringMacroentry : template.getMacroMap().entrySet()) {
             registerMacro(entry.getValue());
         }
     }
 
     public TemplateEngineDefault(String engineId) {
         this();
         if (engineId != null) {
             this. = engineId;
         }
     }
 
    public TemplateEngineDefault() {
        //添加一个默认的加载器
        this. = "default";
        addTemplateFunction(new CallMacroFunction());
        addTemplateFunction(new GetFunction());
    }
        return ;
    }
    public TemplateEngine setEncode(String encode) {
        this. = encode;
        return this;
    }
    public TemplateEngine setI18nVisitor(I18nVisitor i18nVistor) {
        this. = i18nVistor;
        return this;
    }
    public I18nVisitor getI18nVisitor() {
        return ;
    }
    public String getEngineId() {
        return ;
    }
    public void setEngineId(String engineId) {
        this. = engineId;
    }
    public void setResourceLoaderList(List<ResourceLoaderresourceLoaderList) {
        this. = resourceLoaderList;
    }
        function.setTemplateEngine(this);
        String[] names = function.getNames().split(",");
        if (function.getBindingTypes() == null) {
            for (String name : names) {
                .put(namefunction);
            }
        } else {
            String[] types = function.getBindingTypes().split(",");
            for (String type : types) {
                try {
                    Class clazz = Class.forName(type);
                    Map<StringTemplateFunctionnameMap = .get(clazz);
                    if (nameMap == null) {
                        nameMap = new HashMap<StringTemplateFunction>();
                        .put(clazznameMap);
                    }
                    for (String name : names) {
                        nameMap.put(namefunction);
                    }
                } catch (ClassNotFoundException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return this;
    }
    public TemplateFunction getTemplateFunction(String methodName) {
        return .get(methodName);
    }
    public TemplateFunction getTemplateFunction(Object objectString methodName) {
        Map<StringTemplateFunctiontypeMap = .get(object.getClass());
        if (typeMap != null) {
            TemplateFunction function = typeMap.get(methodName);
            if (function != null) {
                return function;
            }
        }
        for (Class clz : .keySet()) {
            if (clz.isInstance(object)) {
                TemplateFunction function = .get(clz).get(methodName);
                if (function != null) {
                    return function;
                }
            }
        }
        return null;
    }
    private String getKeyName(String classNameString methodName) {
        return className + ":" + methodName;
    }
    public String getEncode() {
        return ;
    }
    public TemplateEngine addResourceLoader(ResourceLoader resourceLoader) {
        resourceLoader.setTemplateEngine(this);
        .add(resourceLoader);
        return this;
    }
    public Template findTemplate(String paththrows TemplateException {
        for (ResourceLoader loader : ) {
            Template template = loader.getTemplate(path);
            if (template != null) {
                return template;
            }
        }
        throw new TemplateException("找不到模板:" + path);
    }
    private Template getMacroLibrary(String paththrows TemplateException {
        for (ResourceLoader loader : ) {
            Template template = loader.getMacroLibrary(path);
            if (template != null) {
                return template;
            }
        }
        throw new TemplateException("找不到模板:" + path);
    }
    public TemplateEngine put(String keyObject value) {
        .put(keyvalue);
        return this;
    }
    public void renderMacro(String macroNameTemplate templateTemplateContext contextWriter writerthrows TemplateException {
        findMacro(macroNametemplatecontext).render(templatecontextcontextwriter);
    }
    public void renderMacro(Macro macroTemplate templateTemplateContext contextWriter writerthrows TemplateException {
        macro.render(templatecontextcontextwriter);
    }
    public void renderTemplate(String pathTemplateContext contextWriter writerthrows TemplateException {
        try {
            Template template = findTemplate(path);
            if (template != null) {
                context.put("$templateContext"context);
                context.put("$compactMode".);
                List<TemplatelayoutPaths = getLayoutList(template.getPath());
                if (layoutPaths.size() > 0) {
                    Writer templateWriter = new CharArrayWriter();
                    template.render(contexttemplateWriter);
                    context.put("pageContent"templateWriter.toString());
                    Writer layoutWriter = null;
                    TemplateContext layoutContext = context;
                    for (int i = layoutPaths.size() - 1; i >= 0; i--) {
                        //每次都构建新的Writer和Context来执行
                        TemplateContext tempContext = new TemplateContextDefault();
                        tempContext.setParent(layoutContext);
                        layoutContext = tempContext;
                        layoutWriter = new CharArrayWriter();
                        layoutPaths.get(i).render(layoutContextlayoutWriter);
                        if (i > 0) {
                            layoutContext.put("pageContent"layoutWriter);
                        }
                    }
                    writer.write(layoutWriter.toString());
                } else {
                    renderTemplate(templatecontextwriter);
                }
                writer.flush();
            } else {
                throw new TemplateException("找不到模板:" + path);
            }
        } catch (IOException e) {
            throw new TemplateException(e);
        }
    }
    public void renderTemplateWithOutLayout(String pathTemplateContext contextWriter writerthrows TemplateException {
        Template template = findTemplate(path);
        if (template != null) {
            renderTemplate(templatecontextwriter);
        } else {
            throw new TemplateException("找不到模板:" + path);
        }
    }
    private List<TemplategetLayoutList(String templatePaththrows TemplateException {
        List<TemplatelayoutPathList = null;
        if () {
            layoutPathList = .get(templatePath);
            if (layoutPathList != null) {
                return layoutPathList;
            }
        }
        if (layoutPathList == null) {
            layoutPathList = new ArrayList<Template>();
        }
        String[] paths = templatePath.split("/");
        String path = "";
        String templateFileName = paths[paths.length - 1];
        for (int i = 0; i < paths.length - 1; i++) {
            path += paths[i] + "/";
            String template = path + templateFileName;
            for (ResourceLoader loader : ) {
                String layoutPath = loader.getLayoutPath(template);
                if (layoutPath != null) {
                    Template layout = loader.getLayout(layoutPath);
                    if (layout == null) {
                        String defaultTemplateName = path +  + layoutPath.substring(layoutPath.lastIndexOf('.'));
                        layout = loader.getLayout(defaultTemplateName);
                    }
                    if (layout != null) {
                        layoutPathList.add(layout);
                        break;
                    }
                }
            }
        }
        if () {
            .put(templatePathlayoutPathList);
        }
        return layoutPathList;
    }
    public void renderTemplate(String paththrows TemplateException {
        renderTemplate(pathnew TemplateContextDefault(), new OutputStreamWriter(.));
    }
    public void renderTemplate(Template templatethrows TemplateException {
        renderTemplate(templatenew TemplateContextDefault(), new OutputStreamWriter(.));
    }
    public void renderTemplate(Template templateTemplateContext contextWriter writerthrows TemplateException {
        template.render(contextwriter);
    }
    public Macro findMacro(Object macroNameObjectTemplate templateTemplateContext contextthrows TemplateException {
        //上下文中的宏优先处理,主要是考虑bodyContent宏
        String macroName = macroNameObject.toString();
        Object obj = context.getItemMap().get(macroName);
        if (obj instanceof Macro) {
            return (Macroobj;
        }
        //查找私有宏
        Macro macro = template.getMacroMap().get(macroName);
        if (macro != null) {
            return macro;
        }
        //先查找import的列表,后添加的优先
        for (int i = template.getImportPathList().size() - 1; i >= 0; i--) {
            Template macroLibrary = getMacroLibrary(template.getImportPathList().get(i));
            if (macroLibrary != null) {
                macro = macroLibrary.getMacroMap().get(macroName);
                if (macro != null) {
                    if () {
                        .put(macroNamemacro);
                    }
                    return macro;
                }
            }
        }
        macro = .get(macroName);
        if (macro != null) {
            return macro;
        }

        
查找公共宏,后添加的优先
        for (int i = .size() - 1; i >= 0; i--) {
            String path = .get(i);
            if (!template.getImportPathList().contains(path)) {
                Template macroLibrary = getMacroLibrary(path);
                if (macroLibrary != null) {
                    macro = macroLibrary.getMacroMap().get(macroName);
                    if (macro != null) {
                        if () {
                            .put(macroNamemacro);
                        }
                        return macro;
                    }
                }
            }
        }
        throw new TemplateException("找不到宏:" + macroName);
    }
    public Object executeFunction(Template templateTemplateContext contextString functionNameObject... parametersthrows TemplateException {
        TemplateFunction function = .get(functionName);
        if (function != null) {
            return function.execute(templatecontextparameters);
        }
        throw new TemplateException("找不到函数:" + functionName);
    }
        return ;
    }
    public String getResourceContent(String pathString encodethrows TemplateException {
        for (ResourceLoader resourceLoader : ) {
            String content = resourceLoader.getResourceContent(pathencode);
            if (content != null) {
                return content;
            }
        }
        throw new TemplateException("找不到资源:" + path);
    }
    public String getResourceContent(String paththrows TemplateException {
        return getResourceContent(pathgetEncode());
    }
New to GrepCode? Check out our FAQ X