Class Template


  • public class Template
    extends Configurable

    Stores an already parsed template, ready to be processed (rendered) for unlimited times, possibly from multiple threads.

    Typically, you will use Configuration.getTemplate(String) to create/get Template objects, so you don't construct them directly. But you can also construct a template from a Reader or a String that contains the template source code. But then it's important to know that while the resulting Template is efficient for later processing, creating a new Template itself is relatively expensive. So try to re-use Template objects if possible. Configuration.getTemplate(String) does that (caching Template-s) for you, but the constructor of course doesn't, so it's up to you to solve then.

    Objects of this class meant to be handled as immutable and thus thread-safe. However, it has some setter methods for changing FreeMarker settings. Those must not be used while the template is being processed, or if the template object is already accessible from multiple threads.

    • Method Detail

      • getPlainTextTemplate

        public static Template getPlainTextTemplate​(String name,
                                                    String sourceName,
                                                    String content,
                                                    Configuration config)
        Creates a Template that only contains a single block of static text, no dynamic content.
        Parameters:
        name - See getName() for more details.
        sourceName - See getSourceName() for more details. If null, it will be the same as the name.
        content - the block of text that this template represents
        config - the configuration to which this template belongs
        Since:
        2.3.22
      • process

        public void process​(Object dataModel,
                            Writer out)
                     throws TemplateException,
                            IOException
        Executes template, using the data-model provided, writing the generated output to the supplied Writer.

        For finer control over the runtime environment setup, such as per-HTTP-request configuring of FreeMarker settings, you may need to use createProcessingEnvironment(Object, Writer) instead.

        Parameters:
        dataModel - the holder of the variables visible from the template (name-value pairs); usually a Map<String, Object> or a JavaBean (where the JavaBean properties will be the variables). Can be any object that the ObjectWrapper in use turns into a TemplateHashModel. You can also use an object that already implements TemplateHashModel; in that case it won't be wrapped. If it's null, an empty data model is used.
        out - The Writer where the output of the template will go. Note that unless you have used Configurable.setAutoFlush(boolean) to disable this, Writer.flush() will be called at the when the template processing was finished. Writer.close() is not called.
        Throws:
        TemplateException - if an exception occurs during template processing
        IOException - if an I/O exception occurs during writing to the writer.
      • createProcessingEnvironment

        public Environment createProcessingEnvironment​(Object dataModel,
                                                       Writer out,
                                                       ObjectWrapper wrapper)
                                                throws TemplateException,
                                                       IOException
        Creates a Environment object, using this template, the data-model provided as parameter. You have to call Environment.process() on the return value to set off the actual rendering.

        Use this method if you want to do some special initialization on the Environment before template processing, or if you want to read the Environment after template processing. Otherwise using process(Object, Writer) is simpler.

        Example:

         Environment env = myTemplate.createProcessingEnvironment(root, out, null);
         env.process();

        The above is equivalent with this:

         myTemplate.process(root, out);

        But with createProcessingEnvironment, you can manipulate the environment before and after the processing:

         Environment env = myTemplate.createProcessingEnvironment(root, out);
         
         env.setLocale(myUsersPreferredLocale);
         env.setTimeZone(myUsersPreferredTimezone);
         
         env.process();  // output is rendered here
         
         TemplateModel x = env.getVariable("x");  // read back a variable set by the template
        Parameters:
        dataModel - the holder of the variables visible from all templates; see process(Object, Writer) for more details.
        wrapper - The ObjectWrapper to use to wrap objects into TemplateModel instances. Normally you left it null, in which case Configurable.getObjectWrapper() will be used.
        out - The Writer where the output of the template will go; see process(Object, Writer) for more details.
        Returns:
        the Environment object created for processing. Call Environment.process() to process the template.
        Throws:
        TemplateException - if an exception occurs while setting up the Environment object.
        IOException - if an exception occurs doing any auto-imports
      • toString

        public String toString()
        Returns a string representing the raw template text in canonical form.
        Overrides:
        toString in class Object
      • getName

        public String getName()
        The usually path-like (or URL-like) identifier of the template, or possibly null for non-stored templates. It usually looks like a relative UN*X path; it should use /, not \, and shouldn't start with / (but there are no hard guarantees). It's not a real path in a file-system, it's just a name that a TemplateLoader used to load the backing resource (in simple cases; actually that name is getSourceName(), but see it there). Or, it can also be a name that was never used to load the template (directly created with Template(String, Reader, Configuration)). Even if the templates are stored straightforwardly in files, this is relative to the base directory of the TemplateLoader. So it really could be anything, except that it has importance in these situations:

        Relative paths to other templates in this template will be resolved relatively to the directory part of this. Like if the template name is "foo/this.ftl", then <#include "other.ftl"> gets the template with name "foo/other.ftl".

        You should not use this name to indicate error locations, or to find the actual templates in general, because localized lookup, acquisition and other lookup strategies can transform names before they get to the TemplateLoader (the template storage) mechanism. Use getSourceName() for these purposes.

        Some frameworks use URL-like template names like "someSchema://foo/bar.ftl". FreeMarker understands this notation, so an absolute path like "/baaz.ftl" in that template will be resolved too "someSchema://baaz.ftl".

      • getSourceName

        public String getSourceName()
        The name that was actually used to load this template from the TemplateLoader (or from other custom storage mechanism). This is what should be shown in error messages as the error location. This is usually the same as getName(), except when localized lookup, template acquisition (* step in the name), or other TemplateLookupStrategy transforms the requested name (getName()) to a different final TemplateLoader-level name. For example, when you get a template with name "foo.ftl" then because of localized lookup, it's possible that something like "foo_en.ftl" will be loaded behind the scenes. While the template name will be still the same as the requested template name ("foo.ftl"), errors should point to "foo_de.ftl". Note that relative paths are always resolved relatively to the name, not to the sourceName.
        Since:
        2.3.22
      • getConfiguration

        public Configuration getConfiguration()
        Returns the Configuration object associated with this template.
      • setEncoding

        public void setEncoding​(String encoding)
        Deprecated.
        Should only be used internally, and might will be removed later.
      • getEncoding

        public String getEncoding()
        Returns the default character encoding used for reading included files.
      • setCustomLookupCondition

        public void setCustomLookupCondition​(Object customLookupCondition)
        Mostly only used internally; setter pair of getCustomLookupCondition(). This meant to be called directly after instantiating the template with its constructor, after a successfull lookup that used this condition. So this should only be called from code that deals with creating new Template objects, like from TemplateCache.
        Since:
        2.3.22
      • dump

        public void dump​(PrintStream ps)
        Dump the raw template in canonical form.
      • addMacro

        public void addMacro​(freemarker.core.Macro macro)
        Deprecated.
        Should only be used internally, and might will be removed later.
        Called by code internally to maintain a table of macros
      • addImport

        public void addImport​(freemarker.core.LibraryLoad ll)
        Deprecated.
        Should only be used internally, and might will be removed later.
        Called by code internally to maintain a list of imports
      • getSource

        public String getSource​(int beginColumn,
                                int beginLine,
                                int endColumn,
                                int endLine)
        Returns the template source at the location specified by the coordinates given, or null if unavailable.
        Parameters:
        beginColumn - the first column of the requested source, 1-based
        beginLine - the first line of the requested source, 1-based
        endColumn - the last column of the requested source, 1-based
        endLine - the last line of the requested source, 1-based
        See Also:
        TemplateObject.getSource()
      • getRootTreeNode

        public freemarker.core.TemplateElement getRootTreeNode()
        Deprecated.
        Should only be used internally, and might will be removed later.
      • getMacros

        public Map getMacros()
        Deprecated.
        Should only be used internally, and might will be removed later.
      • getImports

        public List getImports()
        Deprecated.
        Should only be used internally, and might will be removed later.
      • addPrefixNSMapping

        public void addPrefixNSMapping​(String prefix,
                                       String nsURI)
        Deprecated.
        Should only be used internally, and might will be removed later.
        This is used internally.
      • getDefaultNS

        public String getDefaultNS()
      • getNamespaceForPrefix

        public String getNamespaceForPrefix​(String prefix)
        Returns:
        the NamespaceUri mapped to this prefix in this template. (Or null if there is none.)
      • getPrefixForNamespace

        public String getPrefixForNamespace​(String nsURI)
        Returns:
        the prefix mapped to this nsURI in this template. (Or null if there is none.)
      • getPrefixedName

        public String getPrefixedName​(String localName,
                                      String nsURI)
        Returns:
        the prefixed name, based on the ns_prefixes defined in this template's header for the local name and node namespace passed in as parameters.
      • containingElements

        public TreePath containingElements​(int column,
                                           int line)
        Deprecated.
        Should only be used internally, and might will be removed later.
        Returns:
        an array of the TemplateElements containing the given column and line numbers.