Java tutorial
/* * Copyright (C) 2013 The Rythm Engine project * Gelin Luo <greenlaw110(at)gmail.com> * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 * * 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.rythmengine; import org.mvel2.MVEL; import org.mvel2.integration.PropertyHandler; import org.mvel2.integration.PropertyHandlerFactory; import org.mvel2.integration.VariableResolverFactory; import org.rythmengine.conf.RythmConfiguration; import org.rythmengine.conf.RythmConfigurationKey; import org.rythmengine.exception.RythmException; import org.rythmengine.exception.TagLoadException; import org.rythmengine.extension.*; import org.rythmengine.internal.*; import org.rythmengine.internal.compiler.*; import org.rythmengine.internal.dialect.AutoToString; import org.rythmengine.internal.dialect.BasicRythm; import org.rythmengine.internal.dialect.DialectManager; import org.rythmengine.internal.dialect.ToString; import org.rythmengine.logger.ILogger; import org.rythmengine.logger.Logger; import org.rythmengine.logger.NullLogger; import org.rythmengine.resource.ITemplateResource; import org.rythmengine.resource.StringTemplateResource; import org.rythmengine.resource.TemplateResourceManager; import org.rythmengine.resource.ToStringTemplateResource; import org.rythmengine.sandbox.RythmSecurityManager; import org.rythmengine.sandbox.SandboxExecutingService; import org.rythmengine.sandbox.SandboxThreadFactory; import org.rythmengine.template.ITag; import org.rythmengine.template.ITemplate; import org.rythmengine.template.JavaTagBase; import org.rythmengine.template.TemplateBase; import org.rythmengine.toString.ToStringOption; import org.rythmengine.toString.ToStringStyle; import org.rythmengine.utils.F; import org.rythmengine.utils.IO; import org.rythmengine.utils.JSONWrapper; import org.rythmengine.utils.S; import java.io.*; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.*; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * <p>Not Thread Safe</p> * <p/> * <p>A Rythm Template Engine is the entry to the Rythm templating system. It provides a set of * APIs to render template. Each JVM allows multiple <code>RythmEngine</code> instance, with each * one represent a set of configurations.</p> * <p/> * <p>The {@link Rythm} facade contains a default <code>RythmEngine</code> instance to make it * easy to use for most cases</p> */ public class RythmEngine implements IEventDispatcher { private static final ILogger logger = Logger.get(RythmEngine.class); /** * Rythm Engine Version. Used along with * {@link org.rythmengine.conf.RythmConfigurationKey#ENGINE_PLUGIN_VERSION plugin version} to * check if the cached template bytecode need to be refreshed or not * <p/> */ private static final String version; static { version = IO.readContentAsString( RythmEngine.class.getClassLoader().getResourceAsStream("rythm-engine-version")); } private static final InheritableThreadLocal<RythmEngine> _engine = new InheritableThreadLocal<RythmEngine>(); /** * Set the engine instance to a {@link ThreadLocal} variable, thus it is easy to * {@link #get() get} the current * <code>RythmEngine</code> dominating the rendering process. * <p/> * <p><b>Note</b>, this method is NOT an API to be called by user application</p> * * @param engine * @return {@code true} if engine instance set to the threadlocal, {@code false} * if the threadlocal has set an instance already */ public static boolean set(RythmEngine engine) { if (_engine.get() == null) { _engine.set(engine); return true; } else { return false; } } /** * Clear the engine threadlocal variable */ public static void clear() { _engine.remove(); } /** * Get the current engine instance from a {@link ThreadLocal} variable which is * {@link #set(RythmEngine) set} previously. * <p/> * <p><b>Note</b>, this method is NOT an API to be called by user application</p> * * @return the engine */ public static RythmEngine get() { return _engine.get(); } /** * Check if the current rendering is dominated by a {@link Sandbox} * <p/> * <p><b>Note</b>, this method is NOT an API to be called by user application</p> * * @return true if the current thread is running in Sandbox mode */ public static boolean insideSandbox() { return Sandbox.sandboxMode(); } @Override public String toString() { return null == _conf ? "rythm-engine-uninitialized" : id(); } /* ----------------------------------------------------------------------------- Fields and Accessors -------------------------------------------------------------------------------*/ private RythmConfiguration _conf = null; /** * Return {@link RythmConfiguration configuration} of the engine * <p/> * <p>Usually user application should not call this method</p> * * @return rythm configuration */ public RythmConfiguration conf() { if (null == _conf) { throw new IllegalStateException("Rythm engine not initialized"); } return _conf; } /** * Return Version string of the engine instance. The version string * is composed by {@link #version Rythm version} and the * configured {@link RythmConfigurationKey#ENGINE_PLUGIN_VERSION plugin version}. The version * string will be used by Rythm to see if compiled bytecodes cached on disk should * be refreshed in an new version or not. * <p/> * <p><code>Note</code>, this method is not generally used by user application</p> * * @return engine version along with plugin version */ public String version() { return version + "-" + conf().pluginVersion(); } private Rythm.Mode _mode = null; /** * Return the engine {@link Rythm.Mode mode} * * @return engine running mode */ public Rythm.Mode mode() { if (null == _mode) { _mode = conf().get(RythmConfigurationKey.ENGINE_MODE); } return _mode; } private String _id = null; /** * Return the instance {@link org.rythmengine.conf.RythmConfigurationKey#ENGINE_ID ID} * * @return the engine id */ public String id() { if (null == _id) { _id = conf().get(RythmConfigurationKey.ENGINE_ID); } return _id; } /** * Alias of {@link #id()} * * @return the engine id */ public String getId() { return id(); } /** * Is this engine the default {@link Rythm#engine} instance? * <p/> * <p><b>Note</b>, not to be used by user application</p> * * @return true if this is the default engine */ public boolean isSingleton() { return Rythm.engine == this; } /** * Is the engine running in {@link Rythm.Mode#prod product} mode? * * @return true if engine is running in prod mode */ public boolean isProdMode() { return mode() == Rythm.Mode.prod; } /** * Is the engine running in {@link Rythm.Mode#dev development} mode? * * @return true if engine is running is debug mode */ public boolean isDevMode() { return mode() != Rythm.Mode.prod; } private TemplateResourceManager _resourceManager; /** * Get {@link TemplateResourceManager resource manager} of the engine * <p/> * <p><b>Note</b>, this method should not be used by user application</p> * * @return resource manager */ public TemplateResourceManager resourceManager() { return _resourceManager; } private TemplateClassManager _classes; /** * Get {@link TemplateClassManager template class manager} of the engine * <p/> * <p><b>Note</b>, this method should not be used by user application</p> * * @return template class manager */ public TemplateClassManager classes() { return _classes; } private TemplateClassLoader _classLoader = null; /** * Get {@link TemplateClassLoader class loader} of the engine * <p/> * <p><b>Note</b>, this method should not be used by user application</p> * * @return template class loader */ public TemplateClassLoader classLoader() { return _classLoader; } private TemplateClassCache _classCache = null; /** * Get {@link TemplateClassCache class cache} of the engine * <p/> * <p><b>Note</b>, this method should not be used by user application</p> * * @return template class cache */ public TemplateClassCache classCache() { return _classCache; } private ExtensionManager _extensionManager; /** * Return {@link ExtensionManager} of this engine * * @return extension manager */ public ExtensionManager extensionManager() { return _extensionManager; } private final DialectManager _dialectManager = new DialectManager(); /** * Not an API * * @return {@link DialectManager} instance */ public DialectManager dialectManager() { return _dialectManager; } private ICacheService _cacheService = null; /** * Define the render time settings, which is intialized each time a renderXX method * get called */ public class RenderSettings { private RenderSettings(RythmConfiguration conf) { this.conf = conf; } private final RythmConfiguration conf; private final ThreadLocal<Locale> _locale = new ThreadLocal<Locale>() { @Override protected Locale initialValue() { return conf.locale(); } }; private final ThreadLocal<ICodeType> _codeType = new ThreadLocal<ICodeType>(); private final ThreadLocal<Map<String, Object>> _usrCtx = new ThreadLocal<Map<String, Object>>(); /** * Init the render time by setting {@link org.rythmengine.extension.ICodeType code type}. * This method should called before calling render methods to setup the context of this render * * @param codeType * @return the render setting instance */ public final RenderSettings init(ICodeType codeType) { if (null != codeType) _codeType.set(codeType); else _codeType.remove(); return this; } /** * Init the render time by setting {@link java.util.Locale locale}. * This method should called before calling render methods to setup the context of this render * * @param locale * @return the render setting instance */ public final RenderSettings init(Locale locale) { if (null != locale) _locale.set(locale); else _locale.remove(); return this; } /** * Init the render time by setting user context * This method should called before calling render methods to setup the context of this render * * @param usrCtx * @return the render setting instance */ public final RenderSettings init(Map<String, Object> usrCtx) { if (null != usrCtx) _usrCtx.set(usrCtx); else _usrCtx.remove(); return this; } /** * Return ThreadLocal locale. * * @return locale setting for this render process */ public final Locale locale() { return _locale.get(); } /** * Return thread local code type * * @return {@link org.rythmengine.extension.ICodeType code type} setting for this render process */ public final ICodeType codeType() { return _codeType.get(); } /** * Return thread local user context map * * @return the user context map */ public final Map<String, Object> userContext() { return _usrCtx.get(); } /** * Clear the render time after render process done * * @return this engine instance */ public final RythmEngine clear() { _locale.remove(); _codeType.remove(); _usrCtx.remove(); return RythmEngine.this; } } /** * The RenderSettings instance keep the environment settings for one render operation */ public RenderSettings renderSettings; private String secureCode = null; /** * Prepare the render operation environment settings * * @param codeType * @param locale * @param usrCtx * @return the engine instance itself */ public final RythmEngine prepare(ICodeType codeType, Locale locale, Map<String, Object> usrCtx) { renderSettings.init(codeType).init(locale).init(usrCtx); return this; } /** * Prepare the render operation environment settings * * @param codeType * @return the engine instance itself */ public final RythmEngine prepare(ICodeType codeType) { renderSettings.init(codeType); return this; } /** * Prepare the render operation environment settings * * @param locale * @return the engine instance itself */ public final RythmEngine prepare(Locale locale) { renderSettings.init(locale); return this; } /** * Prepare the render operation environment settings * * @param userContext * @return the engine instance itself */ public final RythmEngine prepare(Map<String, Object> userContext) { renderSettings.init(userContext); return this; } /* ----------------------------------------------------------------------------- Constructors, Configuration and Initializing -------------------------------------------------------------------------------*/ private void _initLogger(Map<String, ?> conf) { boolean logEnabled = (Boolean) RythmConfigurationKey.LOG_ENABLED.getConfiguration(conf); if (logEnabled) { ILoggerFactory factory = RythmConfigurationKey.LOG_FACTORY_IMPL.getConfiguration(conf); Logger.registerLoggerFactory(factory); } else { Logger.registerLoggerFactory(new NullLogger.Factory()); } } // trim "rythm." from conf keys private Map<String, Object> _processConf(Map<String, ?> conf) { Map<String, Object> m = new HashMap<String, Object>(conf.size()); for (String s : conf.keySet()) { Object o = conf.get(s); if (s.startsWith("rythm.")) s = s.replaceFirst("rythm\\.", ""); m.put(s, o); } return m; } private void _initConf(Map<String, ?> conf, File confFile) { // load conf from disk Map<String, ?> rawConf = _loadConfFromDisk(confFile); rawConf = _processConf(rawConf); // load conf from System.properties Properties sysProps = System.getProperties(); rawConf.putAll((Map) sysProps); // load conf from user supplied configuration if (null != conf) rawConf.putAll((Map) _processConf(conf)); _initLogger(rawConf); // initialize the configuration with all loaded data RythmConfiguration rc = new RythmConfiguration(rawConf, this); this._conf = rc; // initialize logger factory ILoggerFactory logFact = rc.get(RythmConfigurationKey.LOG_FACTORY_IMPL); Logger.registerLoggerFactory(logFact); // check if it needs to debug the conf information if (rawConf.containsKey("rythm.debug_conf") && Boolean.parseBoolean(rawConf.get("rythm.debug_conf").toString())) { rc.debug(); } } /** * Create a rythm engine instance with default configuration * * @see org.rythmengine.conf.RythmConfigurationKey */ public RythmEngine() { init(null, null); } /** * Create a rythm engine instance with either template root or configuration file specified * * @param file if is directory then the template root, otherwise then the configuration file * @see org.rythmengine.conf.RythmConfigurationKey */ public RythmEngine(File file) { init(null, file); } public RythmEngine(Properties userConfiguration) { this((Map) userConfiguration); } /** * Create a rythm engine instance with user supplied configuration data * * @param userConfiguration * @see org.rythmengine.conf.RythmConfigurationKey */ public RythmEngine(Map<String, ?> userConfiguration) { init(userConfiguration, null); } private Map<String, Object> properties = new HashMap<String, Object>(); /** * Set user property to the engine. Note The property is not used by the engine program * it's purely a place for user to add any tags or properties to the engine and later * get fetched out and use in the user application * * @param key * @param val */ public void setProperty(String key, Object val) { properties.put(key, val); } /** * Get user property by key * * @param key * @param <T> * @return the property being cast to type T */ public <T> T getProperty(String key) { return (T) properties.get(key); } private Map _loadConfFromDisk(File conf) { InputStream is = null; boolean emptyConf = false; if (null == conf) { ClassLoader cl = Thread.currentThread().getContextClassLoader(); if (null == cl) cl = Rythm.class.getClassLoader(); is = cl.getResourceAsStream("rythm.conf"); } else { try { is = new FileInputStream(conf); } catch (IOException e) { if (!emptyConf) logger.warn(e, "Error opening conf file:" + conf); } } if (null != is) { Properties p = new Properties(); try { p.load(is); return p; } catch (Exception e) { logger.warn(e, "Error loading rythm.conf"); } finally { try { if (null != is) is.close(); } catch (Exception e) { //ignore } } } return new HashMap(); } private void init(Map<String, ?> conf, File file) { if (null == file || file.isDirectory()) { _initConf(conf, null); if (null != file) _conf.setTemplateHome(file); } else if (file.isFile() && file.canRead()) { _initConf(conf, file); } renderSettings = new RenderSettings(_conf); // post configuration initializations _mode = _conf.get(RythmConfigurationKey.ENGINE_MODE); _classes = new TemplateClassManager(this); _classLoader = new TemplateClassLoader(this); _classCache = new TemplateClassCache(this); _resourceManager = new TemplateResourceManager(this); _extensionManager = new ExtensionManager(this); int ttl = (Integer) _conf.get(RythmConfigurationKey.DEFAULT_CACHE_TTL); _cacheService = _conf.get(RythmConfigurationKey.CACHE_SERVICE_IMPL); _cacheService.setDefaultTTL(ttl); _cacheService.startup(); // register built-in transformers if enabled boolean enableBuiltInJavaExtensions = (Boolean) _conf .get(RythmConfigurationKey.BUILT_IN_TRANSFORMER_ENABLED); if (enableBuiltInJavaExtensions) { registerTransformer("rythm", "(org.rythmengine.utils.S|s\\(\\))", S.class); } boolean enableBuiltInTemplateLang = (Boolean) _conf.get(RythmConfigurationKey.BUILT_IN_CODE_TYPE_ENABLED); if (enableBuiltInTemplateLang) { ExtensionManager em = extensionManager(); em.registerCodeType(ICodeType.DefImpl.HTML); em.registerCodeType(ICodeType.DefImpl.JS); em.registerCodeType(ICodeType.DefImpl.JSON); em.registerCodeType(ICodeType.DefImpl.CSV); em.registerCodeType(ICodeType.DefImpl.CSS); } _templates.clear(); _templates.put("chain", new JavaTagBase() { @Override protected void call(__ParameterList params, __Body body) { body.render(__getBuffer()); } }); List<Class> udts = _conf.getList(RythmConfigurationKey.EXT_TRANSFORMER_IMPLS, Class.class); registerTransformer(udts.toArray(new Class[] {})); List<IPropertyAccessor> udpa = _conf.getList(RythmConfigurationKey.EXT_PROP_ACCESSOR_IMPLS, IPropertyAccessor.class); registerPropertyAccessor(udpa.toArray(new IPropertyAccessor[] {})); List<Class> udfmt = _conf.getList(RythmConfigurationKey.EXT_FORMATTER_IMPLS, Class.class); registerFormatter(udfmt.toArray(new Class[] {})); // -- built-in formatters try { Class.forName("org.joda.time.DateTime"); Class<IFormatter> fmtCls = (Class<IFormatter>) Class .forName("org.rythmengine.extension.JodaDateTimeFormatter"); IFormatter fmt = fmtCls.newInstance(); extensionManager().registerFormatter(fmt); } catch (Exception e) { // ignore; } if (conf().autoScan()) { resourceManager().scan(); } ShutdownService service = getShutdownService(conf().gae()); service.setShutdown(new Runnable() { @Override public void run() { RythmEngine.this.shutdown(); } }); if (conf().gae()) { logger.warn("Rythm engine : GAE in cloud enabled"); } logger.debug("Rythm-%s started in %s mode", version, mode()); } public static ShutdownService getShutdownService(boolean isGaeAvailable) { if (!isGaeAvailable) { return DefaultShutdownService.INSTANCE; } try { String classname = "org.rythmengine.GaeShutdownService"; Class clazz = Class.forName(classname); Object[] oa = clazz.getEnumConstants(); ShutdownService result = (ShutdownService) oa[0]; return result; } catch (Throwable t) { // Nothing to do } return DefaultShutdownService.INSTANCE; } /* ----------------------------------------------------------------------------- Registrations -------------------------------------------------------------------------------*/ /** * Register {@link org.rythmengine.extension.IFormatter formatters} * * @param formatterClasses */ public void registerFormatter(Class<IFormatter>... formatterClasses) { for (Class<IFormatter> cls : formatterClasses) { try { IFormatter fmt = cls.newInstance(); extensionManager().registerFormatter(fmt); } catch (Exception e) { Logger.error(e, "Error get formatter instance from class[%s]", cls); } } } public void registerFormatter(IFormatter... formatters) { for (IFormatter fmt : formatters) { extensionManager().registerFormatter(fmt); } } /** * Register {@link Transformer transformers} using namespace specified in * the namespace {@link org.rythmengine.extension.Transformer#value() value} defined in * the annotation. * * @param transformerClasses */ public void registerTransformer(Class<?>... transformerClasses) { registerTransformer(null, null, transformerClasses); } /** * Register {@link Transformer transformers} using namespace specified to * replace the namespace {@link org.rythmengine.extension.Transformer#value() value} defined in * the annotation. * * @param transformerClasses */ public void registerTransformer(String namespace, String waivePattern, Class<?>... transformerClasses) { ExtensionManager jem = extensionManager(); for (Class<?> extensionClass : transformerClasses) { Transformer t = extensionClass.getAnnotation(Transformer.class); boolean classAnnotated = null != t; String nmsp = namespace; boolean namespaceIsEmpty = S.empty(namespace); if (classAnnotated && namespaceIsEmpty) { nmsp = t.value(); } String waive = waivePattern; boolean waiveIsEmpty = S.empty(waive); if (classAnnotated && waiveIsEmpty) { waive = t.waivePattern(); } boolean clsRequireTemplate = null == t ? false : t.requireTemplate(); boolean clsLastParam = null == t ? false : t.lastParam(); for (Method m : extensionClass.getDeclaredMethods()) { int flag = m.getModifiers(); if (!Modifier.isPublic(flag) || !Modifier.isStatic(flag)) continue; int len = m.getParameterTypes().length; if (len <= 0) continue; Transformer tm = m.getAnnotation(Transformer.class); boolean methodAnnotated = null != tm; if (!methodAnnotated && !classAnnotated) continue; String mnmsp = nmsp; if (methodAnnotated && namespaceIsEmpty) { mnmsp = tm.value(); if (S.empty(mnmsp)) mnmsp = nmsp; } String mwaive = waive; if (methodAnnotated && waiveIsEmpty) { mwaive = tm.waivePattern(); if (S.empty(mwaive)) mwaive = waive; } String cn = extensionClass.getSimpleName(); if (S.empty(mwaive)) mwaive = cn; boolean requireTemplate = clsRequireTemplate; if (null != tm && tm.requireTemplate()) { requireTemplate = true; } boolean lastParam = clsLastParam; if (null != tm && tm.lastParam()) { lastParam = true; } String cn0 = extensionClass.getName(); String mn = m.getName(); String fullName = String.format("%s.%s", cn0, mn); if (S.notEmpty(mnmsp) && !"rythm".equals(mnmsp)) { mn = mnmsp + "_" + mn; } if (len == 1) { jem.registerJavaExtension( new IJavaExtension.VoidParameterExtension(mwaive, mn, fullName, requireTemplate)); } else { jem.registerJavaExtension(new IJavaExtension.ParameterExtension(mwaive, mn, ".+", fullName, requireTemplate, lastParam)); } } } } /** * Register user implemented {@link org.rythmengine.extension.IPropertyAccessor} * * @param accessors */ public void registerPropertyAccessor(IPropertyAccessor... accessors) { for (final IPropertyAccessor a : accessors) { _registerPropertyAccessor(a); } PropertyHandlerFactory.unregisterPropertyHandler(Serializable.class); } private void _registerPropertyAccessor(final IPropertyAccessor a) { PropertyHandlerFactory.registerPropertyHandler(a.getTargetType(), new PropertyHandler() { @Override public Object getProperty(String name, Object contextObj, VariableResolverFactory variableFactory) { return a.getProperty(name, contextObj); } @Override public Object setProperty(String name, Object contextObj, VariableResolverFactory variableFactory, Object value) { return a.setProperty(name, contextObj, value); } }); } public void registerResourceLoader(ITemplateResourceLoader... loaders) { } /* ----------------------------------------------------------------------------- Rendering methods and APIs -------------------------------------------------------------------------------*/ private void setRenderArgs(ITemplate t, Object... args) { if (null == args) { t.__setRenderArg(0, null); } else if (1 == args.length) { Object o0 = args[0]; if (o0 instanceof Map) { t.__setRenderArgs((Map<String, Object>) args[0]); } else if (o0 instanceof JSONWrapper) { t.__setRenderArg((JSONWrapper) o0); } else { t.__setRenderArgs(args); } } else { t.__setRenderArgs(args); } //if (mode.isDev()) cceCounter.remove(); } @Deprecated private void handleCCE(ClassCastException ce) { // Integer I = cceCounter.get(); // if (null == I) { // I = 0; // cceCounter.set(1); // } else { // I++; // cceCounter.set(I); // } // if (I > 2) { // cceCounter.remove(); // throw ce; // } // restart(ce); } //static ThreadLocal<Integer> cceCounter = new ThreadLocal<Integer>(); private ITemplate getTemplate(IDialect dialect, String template, Object... args) { boolean typeInferenceEnabled = conf().typeInferenceEnabled(); if (typeInferenceEnabled) { ParamTypeInferencer.registerParams(this, args); } String key = template; if (typeInferenceEnabled) { key += ParamTypeInferencer.uuid(); } TemplateClass tc = classes().getByTemplate(key); if (null == tc) { tc = new TemplateClass(template, this, dialect); } ITemplate t = tc.asTemplate(this); setRenderArgs(t, args); return t; } /** * Get an new {@link ITemplate template} instance from a String and an array * of render args. The string parameter could be either a template file path * or the inline template source content. * <p/> * <p>When the args array contains only one element and is of {@link java.util.Map} type * the the render args are passed to template * {@link ITemplate#__setRenderArgs(java.util.Map) by name}, * otherwise they passes to template instance by position</p> * * @param template * @param args * @return template instance */ @SuppressWarnings("unchecked") public ITemplate getTemplate(String template, Object... args) { return getTemplate(null, template, args); } /** * (3rd party API, not for user application) * Get an new template class by {@link org.rythmengine.resource.ITemplateResource template resource} * * @param resource the template resource * @return template class */ public TemplateClass getTemplateClass(ITemplateResource resource) { String key = S.str(resource.getKey()); TemplateClass tc = classes().getByTemplate(key); if (null == tc) { tc = new TemplateClass(resource, this); } return tc; } /** * Get an new template instance by template source {@link java.io.File file} * and an array of arguments. * <p/> * <p>When the args array contains only one element and is of {@link java.util.Map} type * the the render args are passed to template * {@link ITemplate#__setRenderArgs(java.util.Map) by name}, * otherwise they passes to template instance by position</p> * * @param file the template source file * @param args the render args. See {@link #getTemplate(String, Object...)} * @return template instance */ @SuppressWarnings("unchecked") public ITemplate getTemplate(File file, Object... args) { boolean typeInferenceEnabled = conf().typeInferenceEnabled(); if (typeInferenceEnabled) { ParamTypeInferencer.registerParams(this, args); } String key = S.str(resourceManager().get(file).getKey()); if (typeInferenceEnabled) { key += ParamTypeInferencer.uuid(); } TemplateClass tc = classes().getByTemplate(key); ITemplate t; if (null == tc) { tc = new TemplateClass(file, this); t = tc.asTemplate(this); if (null == t) return null; _templates.put(tc.getKey(), t); //classes().add(key, tc); } else { t = tc.asTemplate(this); } setRenderArgs(t, args); return t; } /** * Render template by string parameter and an array of * template args. The string parameter could be either * a path point to the template source file, or the inline * template source content. The render result is returned * as a String * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param template either the path of template source file or inline template content * @param args render args array * @return render result */ public String render(String template, Object... args) { try { ITemplate t = getTemplate(template, args); return t.render(); } finally { renderCleanUp(); } } /** * Render template by string parameter and an array of * template args. The string parameter could be either * a path point to the template source file, or the inline * template source content. The render result is output * to the specified binary output stream * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param os the output stream * @param template either the path of template source file or inline template content * @param args render args array */ public void render(OutputStream os, String template, Object... args) { outputMode.set(OutputMode.os); try { ITemplate t = getTemplate(template, args); t.render(os); } finally { renderCleanUp(); } } /** * Render template by string parameter and an array of * template args. The string parameter could be either * a path point to the template source file, or the inline * template source content. The render result is output * to the specified character based writer * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param w the writer * @param template either the path of template source file or inline template content * @param args render args array */ public void render(Writer w, String template, Object... args) { outputMode.set(OutputMode.writer); try { ITemplate t = getTemplate(template, args); t.render(w); } finally { renderCleanUp(); } } /** * Render template with source specified by {@link java.io.File file instance} * and an array of render args. Render result return as a String * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param file the template source file * @param args render args array * @return render result */ public String render(File file, Object... args) { try { ITemplate t = getTemplate(file, args); return t.render(); } finally { renderCleanUp(); } } /** * Render template with source specified by {@link java.io.File file instance} * and an array of render args. Render result output into the specified binary * {@link java.io.OutputStream} * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param os the output stream * @param file the template source file * @param args render args array */ public void render(OutputStream os, File file, Object... args) { outputMode.set(OutputMode.os); try { ITemplate t = getTemplate(file, args); t.render(os); } finally { renderCleanUp(); } } /** * Render template with source specified by {@link java.io.File file instance} * and an array of render args. Render result output into the specified binary * {@link java.io.Writer} * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param w the writer * @param file the template source file * @param args render args array */ public void render(Writer w, File file, Object... args) { outputMode.set(OutputMode.writer); try { ITemplate t = getTemplate(file, args); t.render(w); } finally { renderCleanUp(); } } /** * Render template by string typed inline template content and an array of * template args. The render result is returned as a String * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param template the inline template content * @param args the render args array * @return render result */ public String renderStr(String template, Object... args) { return renderString(template, args); } /** * Alias of {@link #renderString(String, Object...)} * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param template the inline template content * @param args the render args array * @return render result */ @SuppressWarnings("unchecked") public String renderString(String template, Object... args) { boolean typeInferenceEnabled = conf().typeInferenceEnabled(); if (typeInferenceEnabled) { ParamTypeInferencer.registerParams(this, args); } String key = template; if (typeInferenceEnabled) { key += ParamTypeInferencer.uuid(); } try { TemplateClass tc = classes().getByTemplate(key, false); if (null == tc) { tc = new TemplateClass(new StringTemplateResource(template), this); //classes().add(key, tc); } ITemplate t = tc.asTemplate(this); setRenderArgs(t, args); return t.render(); } finally { renderCleanUp(); } } /** * Render template in substitute mode by string typed template source * and an array of render args. The string parameter could be either * a path point to the template source file, or the inline * template source content. Return render result as String * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param template either the template source file path or the inline template content * @param args the render args array * @return render result */ public String substitute(String template, Object... args) { try { ITemplate t = getTemplate(BasicRythm.INSTANCE, template, args); return t.render(); } finally { renderCleanUp(); } } /** * Render template in substitute mode by File typed template source * and an array of render args. Return render result as String * <p/> * <p>See {@link #getTemplate(java.io.File, Object...)} for note on * render args</p> * * @param file the template source file * @param args the render args array * @return render result */ public String substitute(File file, Object... args) { try { ITemplate t = getTemplate(file, args, BasicRythm.INSTANCE); return t.render(); } finally { renderCleanUp(); } } /** * Render template in ToString mode by string typed template source * and one object instance which state is to be output. * The string parameter could be either a path point to the template * source file, or the inline template source content. Return render * result as String * * @param template either the template source file path or the inline template content * @param obj the object instance which state is to be output as a string * @return render result */ public String toString(String template, Object obj) { Class argClass = obj.getClass(); String clsName = argClass.getName(); if (clsName.matches(".*\\$[0-9].*")) { argClass = obj.getClass().getSuperclass(); } String key = template + argClass; try { TemplateClass tc = classes().getByTemplate(key); if (null == tc) { tc = new TemplateClass(template, this, new ToString(argClass)); //classes().add(key, tc); } ITemplate t = tc.asTemplate(this); t.__setRenderArg(0, obj); return t.render(); } finally { renderCleanUp(); } } /** * Render template in AutoToString mode by one object instance which state is * to be output. Return render result as String * * @param obj the object instance which state is to be output as a string * @return render result */ public String toString(Object obj) { return toString(obj, ToStringOption.DEFAULT_OPTION, (ToStringStyle) null); } /** * Render template in AutoToString mode by one object instance which state is * to be output and {@link ToStringOption option} and {@link ToStringStyle stype}. * Return render result as String * * @param obj the object instance which state is to be output as a string * @param option the output option * @param style the output style * @return render result */ public String toString(Object obj, ToStringOption option, ToStringStyle style) { Class<?> c = obj.getClass(); AutoToString.AutoToStringData key = new AutoToString.AutoToStringData(c, option, style); try { //String template = AutoToString.templateStr(c, option, style); TemplateClass tc = classes().getByTemplate(key); if (null == tc) { tc = new TemplateClass(new ToStringTemplateResource(key), this, new AutoToString(c, key)); //classes().add(key, tc); } ITemplate t = tc.asTemplate(this); t.__setRenderArg(0, obj); return t.render(); } finally { renderCleanUp(); } } /** * Render template in AutoToString mode by one object instance which state is * to be output and {@link ToStringOption option} and * {@link org.apache.commons.lang3.builder.ToStringStyle apache commons to string stype}. * Return render result as String * * @param obj the object instance which state is to be output as a string * @param option the output option * @param style the output style specified as apache commons ToStringStyle * @return render result */ public String commonsToString(Object obj, ToStringOption option, org.apache.commons.lang3.builder.ToStringStyle style) { return toString(obj, option, ToStringStyle.fromApacheStyle(style)); } private Set<String> nonExistsTemplates = new HashSet<String>(); private class NonExistsTemplatesChecker { boolean started = false; private ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(1); NonExistsTemplatesChecker() { scheduler.scheduleAtFixedRate(new Runnable() { @Override public void run() { List<String> toBeRemoved = new ArrayList<String>(); for (String template : nonExistsTemplates) { ITemplateResource rsrc = resourceManager().getResource(template); if (rsrc.isValid()) { toBeRemoved.add(template); } } nonExistsTemplates.removeAll(toBeRemoved); toBeRemoved.clear(); TemplateClass tc = classes().all().get(0); for (String tag : _nonExistsTags) { if (null != resourceManager().tryLoadTemplate(tag, tc)) { toBeRemoved.add(tag); } } _nonExistsTags.removeAll(toBeRemoved); toBeRemoved.clear(); } }, 0, 1000 * 10, TimeUnit.MILLISECONDS); } } private NonExistsTemplatesChecker nonExistsTemplatesChecker = null; /** * Render template if specified template exists, otherwise return empty string * * @param template the template source path * @param args render args. See {@link #getTemplate(String, Object...)} * @return render result */ public String renderIfTemplateExists(String template, Object... args) { boolean typeInferenceEnabled = conf().typeInferenceEnabled(); if (typeInferenceEnabled) { ParamTypeInferencer.registerParams(this, args); } if (nonExistsTemplates.contains(template)) return ""; String key = template; if (typeInferenceEnabled) { key += ParamTypeInferencer.uuid(); } try { TemplateClass tc = classes().getByTemplate(template); if (null == tc) { ITemplateResource rsrc = resourceManager().getResource(template); if (rsrc.isValid()) { tc = new TemplateClass(rsrc, this); //classes().add(key, tc); } else { nonExistsTemplates.add(template); if (isDevMode() && nonExistsTemplatesChecker == null) { nonExistsTemplatesChecker = new NonExistsTemplatesChecker(); } return ""; } } ITemplate t = tc.asTemplate(this); setRenderArgs(t, args); return t.render(); } finally { renderCleanUp(); } } /* ----------------------------------------------------------------------------- Eval -------------------------------------------------------------------------------*/ /** * Evaluate a script and return executing result. Note the API is not mature yet * don't use it in your application * * @param script * @return the result */ public Object eval(String script) { // // use Java's ScriptEngine at the moment // ScriptEngineManager manager = new ScriptEngineManager(); // ScriptEngine jsEngine = manager.getEngineByName("JavaScript"); // try { // return jsEngine.eval(script); // } catch (ScriptException e) { // throw new RuntimeException(e); // } return eval(script, Collections.EMPTY_MAP); } private Map<String, Serializable> mvels = new HashMap<String, Serializable>(); public Object eval(String script, Map<String, Object> params) { Serializable ce = mvels.get(script); if (null == ce) { ce = MVEL.compileExpression(script); mvels.put(script, ce); } return MVEL.executeExpression(ce, params); } public Object eval(String script, Object context, Map<String, Object> params) { Serializable ce = mvels.get(script); if (null == ce) { ce = MVEL.compileExpression(script); mvels.put(script, ce); } return MVEL.executeExpression(ce, context, params); } /* ----------------------------------------------------------------------------- Tags -------------------------------------------------------------------------------*/ private final Map<String, ITemplate> _templates = new HashMap<String, ITemplate>(); private final Map<String, JavaTagBase> _tags = new HashMap<String, JavaTagBase>(); private final Set<String> _nonTmpls = new HashSet<String>(); /** * Whether a {@link ITemplate template} is registered to the engine by name specified * <p/> * <p>Not an API for user application</p> * * @param tmplName * @return true if there is a template with the name specified */ public boolean templateRegistered(String tmplName) { return _templates.containsKey(tmplName) || _tags.containsKey(tmplName); } /** * Get a {@link ITemplate template} registered to the engine by name * <p/> * <p>Not an API for user application</p> * * @param tmplName * @return the template instance */ public ITemplate getRegisteredTemplate(String tmplName) { return _templates.get(tmplName); } /** * Return {@link TemplateClass} from a tag name * <p/> * <p>Not an API for user application</p> * * @param name * @return template class */ public TemplateClass getRegisteredTemplateClass(String name) { TemplateBase tmpl = (TemplateBase) _templates.get(name); if (null == tmpl) return null; return tmpl.__getTemplateClass(false); } /** * Register a template class and return self * * @param tc * @return this engine instance */ public RythmEngine registerTemplateClass(TemplateClass tc) { classes().add(tc); return this; } /** * Check if a template exists and return it's name * <p/> * <p>Not an API for user application</p> * * @param name * @param callerClass * @return template name */ public String testTemplate(String name, TemplateClass callerClass) { if (Keyword.THIS.toString().equals(name)) { return callerClass.getTagName(); } if (mode().isProd() && _nonTmpls.contains(name)) return null; if (templateRegistered(name)) return name; // try imported path if (null != callerClass.importPaths) { for (String s : callerClass.importPaths) { String name0 = s + "." + name; if (_templates.containsKey(name0)) return name0; } } // try relative path // TODO: handle logic error here, caller foo.bar.html, tag: zee // then should try foo.zee.html, if tag is zee.js, then should try foo.zee.js String callerName = callerClass.getTagName(); if (null != callerName) { int pos = callerName.lastIndexOf("."); if (-1 != pos) { String s = callerName.substring(0, pos); String name0 = s + "." + name; if (_templates.containsKey(name0)) return name0; pos = s.lastIndexOf("."); if (-1 != pos) { s = callerName.substring(0, pos); name0 = s + "." + name; if (_templates.containsKey(name0)) return name0; } } } try { // try to ask resource manager TemplateClass tc = resourceManager().tryLoadTemplate(name, callerClass); if (null == tc) { if (mode().isProd()) _nonTmpls.add(name); return null; } String fullName = tc.getTagName(); return fullName; } catch (TagLoadException e) { throw e; } catch (RythmException e) { throw e; } catch (Exception e) { logger.error(e, "error trying load tag[%s]", name); // see if the } return null; } public void registerFastTag(JavaTagBase tag) { _tags.put(tag.__getName(), tag); } /** * Register a template. * <p>Not an API for user application</p> */ public void registerTemplate(ITemplate template) { //TemplateResourceManager rm = resourceManager(); String name; if (template instanceof JavaTagBase) { name = template.__getName(); } else { name = template.__getTemplateClass(false).getTagName(); } registerTemplate(name, template); } /** * Register a tag using the given name * <p/> * <p>Not an API for user application</p> * * @param name * @param template */ public void registerTemplate(String name, ITemplate template) { if (null == template) throw new NullPointerException(); // if (_templates.containsKey(name)) { // return false; // } _templates.put(name, template); return; } /** * Invoke a template * <p/> * <p>Not an API for user application</p> * * @param line * @param name * @param caller * @param params * @param body * @param context */ public void invokeTemplate(int line, String name, ITemplate caller, ITag.__ParameterList params, ITag.__Body body, ITag.__Body context) { invokeTemplate(line, name, caller, params, body, context, false); } private Set<String> _nonExistsTags = new HashSet<String>(); /** * Invoke a tag * <p/> * <p>Not an API for user application</p> * * @param line * @param name * @param caller * @param params * @param body * @param context * @param ignoreNonExistsTag */ public void invokeTemplate(int line, String name, ITemplate caller, ITag.__ParameterList params, ITag.__Body body, ITag.__Body context, boolean ignoreNonExistsTag) { if (_nonExistsTags.contains(name)) return; Sandbox.enterSafeZone(secureCode); RythmEvents.ENTER_INVOKE_TEMPLATE.trigger(this, (TemplateBase) caller); try { // try tag registry first ITemplate t = _tags.get(name); if (null == t) { t = _templates.get(name); } if (null == t) { // is calling self if (S.isEqual(name, caller.__getName())) t = caller; } if (null == t) { // try imported path TemplateClass tc = caller.__getTemplateClass(true); if (null != tc.importPaths) { for (String s : tc.importPaths) { String name0 = s + "." + name; t = _tags.get(name0); if (null == t) t = _templates.get(name0); if (null != t) break; } } // try relative path if (null == t) { String callerName = tc.getTagName(); int pos = -1; if (null != callerName) pos = callerName.lastIndexOf("."); if (-1 != pos) { String name0 = callerName.substring(0, pos) + "." + name; t = _tags.get(name0); if (null == t) t = _templates.get(name0); } } // try load the tag from resource if (null == t) { tc = resourceManager().tryLoadTemplate(name, tc); if (null != tc) t = _templates.get(tc.getTagName()); if (null == t) { if (ignoreNonExistsTag) { if (logger.isDebugEnabled()) { logger.debug("cannot find tag: " + name); } _nonExistsTags.add(name); if (isDevMode() && nonExistsTemplatesChecker == null) { nonExistsTemplatesChecker = new NonExistsTemplatesChecker(); } return; } else { throw new NullPointerException("cannot find tag: " + name); } } t = t.__cloneMe(this, caller); } } if (!(t instanceof JavaTagBase)) { // try refresh the tag loaded from template file under tag root // note Java source tags are not reloaded here String cn = t.getClass().getName(); TemplateClass tc0 = classes().getByClassName(cn); if (null == tc0) { System.out.println(t.getClass()); System.out.println(name); System.out.println(cn); System.out.println(caller.getClass()); } t = tc0.asTemplate(caller, this); } else { t = t.__cloneMe(this, caller); } if (null != params) { if (t instanceof JavaTagBase) { ((JavaTagBase) t).__setRenderArgs0(params); } else { for (int i = 0; i < params.size(); ++i) { ITag.__Parameter param = params.get(i); if (null != param.name) t.__setRenderArg(param.name, param.value); else t.__setRenderArg(i, param.value); } } } if (null == body && null != params) { body = (ITag.__Body) params.getByName("__body"); if (null == body) { body = (ITag.__Body) params.getByName("_body"); } } if (null != body) { t.__setRenderArg("__body", body); t.__setRenderArg("_body", body); // for compatibility } RythmEvents.ON_TAG_INVOCATION.trigger(this, F.T2((TemplateBase) caller, t)); try { if (null != context) { t.__setBodyContext(context); } t.__setSecureCode(secureCode).__call(line); } finally { RythmEvents.TAG_INVOKED.trigger(this, F.T2((TemplateBase) caller, t)); } } finally { RythmEvents.EXIT_INVOKE_TEMPLATE.trigger(this, (TemplateBase) caller); Sandbox.leaveCurZone(secureCode); } } // -- cache api /** * Cache object using key and args for ttl seconds * <p/> * <p>Not an API for user application</p> * * @param key * @param o * @param ttl if zero then defaultTTL used, if negative then never expire * @param args */ public void cache(String key, Object o, int ttl, Object... args) { if (conf().cacheDisabled()) return; ICacheService cacheService = _cacheService; Serializable value = null == o ? "" : (o instanceof Serializable ? (Serializable) o : o.toString()); if (args.length > 0) { StringBuilder sb = new StringBuilder(key); for (Object arg : args) { sb.append("-").append(arg); } key = sb.toString(); } cacheService.put(key, value, ttl); } /** * Store object o into cache service with ttl equals to duration specified. * <p/> * <p>The duration is a string to be parsed by @{link #durationParser}</p> * <p/> * <p>The object o is associated with given key and a list of argument values</p> * <p/> * <p>Not an API for user application</p> * * @param key * @param o * @param duration * @param args */ public void cache(String key, Object o, String duration, Object... args) { if (conf().cacheDisabled()) return; IDurationParser dp = conf().durationParser(); int ttl = null == duration ? 0 : dp.parseDuration(duration); cache(key, o, ttl, args); } /** * Evict an object from cache service by key * * @param key identify the object should be removed from cache service */ public void evict(String key) { if (conf().cacheDisabled()) { return; } _cacheService.evict(key); } /** * Get cached value using key and a list of argument values * <p/> * <p>Not an API for user application</p> * * @param key * @param args * @return cached item */ public Serializable cached(String key, Object... args) { if (conf().cacheDisabled()) return null; ICacheService cacheService = _cacheService; if (args.length > 0) { StringBuilder sb = new StringBuilder(key); for (Object arg : args) { sb.append("-").append(arg); } key = sb.toString(); } return cacheService.get(key); } // -- SPI interface // -- issue #47 private Map<TemplateClass, Set<TemplateClass>> extendMap = new HashMap<TemplateClass, Set<TemplateClass>>(); /** * Not an API for user application * * @param parent * @param child */ public void addExtendRelationship(TemplateClass parent, TemplateClass child) { if (mode().isProd()) return; Set<TemplateClass> children = extendMap.get(parent); if (null == children) { children = new HashSet<TemplateClass>(); extendMap.put(parent, children); } children.add(child); } /** * Not an API for user application * * @param parent */ // called to invalidate all template class which extends the parent public void invalidate(TemplateClass parent) { if (mode().isProd()) return; Set<TemplateClass> children = extendMap.get(parent); if (null == children) return; for (TemplateClass child : children) { invalidate(child); child.reset(); } } // -- Sandbox private SandboxExecutingService _secureExecutor = null; /** * Create a {@link Sandbox} instance to render the template * * @return an new sandbox instance */ public synchronized Sandbox sandbox() { if (null != _secureExecutor) { return new Sandbox(this, _secureExecutor); } int poolSize = (Integer) conf().get(RythmConfigurationKey.SANDBOX_POOL_SIZE); SecurityManager csm = conf().get(RythmConfigurationKey.SANDBOX_SECURITY_MANAGER_IMPL); int timeout = (Integer) conf().get(RythmConfigurationKey.SANDBOX_TIMEOUT); SandboxThreadFactory fact = conf().get(RythmConfigurationKey.SANBOX_THREAD_FACTORY_IMPL); SecurityManager ssm = System.getSecurityManager(); RythmSecurityManager rsm; String code; if (null == ssm || !(ssm instanceof RythmSecurityManager)) { code = conf().get(RythmConfigurationKey.SANDBOX_SECURE_CODE); rsm = new RythmSecurityManager(csm, code, this); } else { rsm = ((RythmSecurityManager) ssm); code = rsm.getCode(); } secureCode = code; _secureExecutor = new SandboxExecutingService(poolSize, fact, timeout, this, code); Sandbox sandbox = new Sandbox(this, _secureExecutor); if (ssm != rsm) System.setSecurityManager(rsm); return sandbox; } /** * Create a {@link Sandbox} instance with user supplied context * * @param context * @return an new sandbox instance */ public Sandbox sandbox(Map<String, Object> context) { return sandbox().setUserContext(context); } // dispatch rythm events private IEventDispatcher eventDispatcher = null; public IEventDispatcher eventDispatcher() { if (null == eventDispatcher) { eventDispatcher = new EventBus(this); } return eventDispatcher; } /** * Not an API for user application * * @param event * @param param * @return event handler process result */ @Override public Object accept(IEvent event, Object param) { return eventDispatcher().accept(event, param); } /* ----------------------------------------------------------------------------- Output Mode -------------------------------------------------------------------------------*/ /** * Defines the output method for render result. * <ul> * <li>os: output to binary {@link java.io.OutputStream}</li> * <li>writer: output to character based {@link java.io.Writer}</li> * <li>str: return render result as a {@link java.lang.String}</li> * </ul> * <p/> * <p>This is not an API used in user application</p> */ public static enum OutputMode { os, writer, str { @Override public boolean writeOutput() { return false; } }; /** * Return true if the current output mode is to output to {@link java.io.OutputStream} * or {@link java.io.Writer} * * @return true if output mode is not return string */ public boolean writeOutput() { return true; } } private final static InheritableThreadLocal<OutputMode> outputMode = new InheritableThreadLocal<OutputMode>() { @Override protected OutputMode initialValue() { return OutputMode.str; } }; /** * Not an API. * * @return output mode */ public static OutputMode outputMode() { return outputMode.get(); } public static void renderCleanUp() { outputMode.remove(); TemplateResourceManager.cleanUpTmplBlackList(); } /* ----------------------------------------------------------------------------- Restart and Shutdown -------------------------------------------------------------------------------*/ /** * Restart the engine with an exception as the cause. * <p><b>Note</b>, this is not supposed to be called by user application</p> * * @param cause */ public void restart(RuntimeException cause) { if (isProdMode()) throw cause; if (!(cause instanceof ClassReloadException)) { String msg = cause.getMessage(); if (cause instanceof RythmException) { RythmException re = (RythmException) cause; msg = re.getSimpleMessage(); } logger.warn("restarting rythm engine due to %s", msg); } restart(); } private void restart() { if (isProdMode()) return; _classLoader = new TemplateClassLoader(this); //_classes.clear(); // clear all template tags which is managed by TemplateClassManager List<String> templateTags = new ArrayList<String>(); for (String name : _templates.keySet()) { ITag tag = _templates.get(name); if (!(tag instanceof JavaTagBase)) { templateTags.add(name); } } for (String name : templateTags) { _templates.remove(name); } } interface IShutdownListener { void onShutdown(); } private IShutdownListener shutdownListener = null; void setShutdownListener(IShutdownListener listener) { this.shutdownListener = listener; } private boolean zombie = false; /** * Shutdown this rythm engine */ public void shutdown() { if (zombie) { return; } logger.info("Shutting down Rythm Engine: [%s]", id()); if (null != _cacheService) { try { _cacheService.shutdown(); } catch (Exception e) { logger.error(e, "Error shutdown cache service"); } } if (null != _secureExecutor) { try { _secureExecutor.shutdown(); } catch (Exception e) { logger.error(e, "Error shutdown secure executor"); } } if (null != _resourceManager) { try { _resourceManager.shutdown(); } catch (Exception e) { logger.error(e, "Error shutdown resource manager"); } } if (null != shutdownListener) { try { shutdownListener.onShutdown(); } catch (Exception e) { logger.error(e, "Error execute shutdown listener"); } } if (null != _templates) _templates.clear(); if (null != _classes) _classes.clear(); if (null != _nonExistsTags) _nonExistsTags.clear(); if (null != _nonTmpls) _nonTmpls.clear(); _classLoader = null; Rythm.RenderTime.clear(); zombie = true; } public static void main(String[] args) { Map<String, String> m = new HashMap<String, String>(); m.put("a", "A"); m.put("b", "B"); int i = 0; System.out.println(new RythmEngine().render("@args Map<String, String> m\nhello @m.a@", m, i)); } }