public class XmlTemplateEngine
extends TemplateEngineTemplate engine for use in templating scenarios where both the template source and the expected output are intended to be XML.
Templates may use the normal '${expression}' and '$variable' notations to insert an arbitrary expression into the template. In addition, support is also provided for special tags: <gsp:scriptlet> (for inserting code fragments) and <gsp:expression> (for code fragments which produce output).
Comments and processing instructions will be removed as part of processing and special XML characters such as <, >, " and ' in the text of the template will be escaped using the respective XML notation. The output will also be indented using standard XML pretty printing.
That escaping is applied to the template as it is read, and deliberately not to the
${expression} and $variable insertions, which have to survive
as Groovy for the value to be computed at all. Whatever such an insertion produces is
written as it stands: a value carrying < or & reaches
the output as markup rather than as text, and can leave it neither well-formed nor what
the template intended. Escape a value that may contain either, with
XmlUtil.escapeXml or otherwise, before binding it —
always for a value that came from somewhere you do not control.
The xmlns namespace definition for gsp: tags will be removed
but other namespace definitions will be preserved (but may change to an
equivalent position within the XML tree).
Normally, the template source will be in a file but here is a simple example providing the XML template as a string:
def binding = [firstname:"Jochen", lastname:"Theodorou",
nickname:"blackdrag", salutation:"Dear"]
def engine = new groovy.text.XmlTemplateEngine()
def text = '''\
<?xml version="1.0" encoding="UTF-8"?>
<document xmlns:gsp='http://groovy.codehaus.org/2005/gsp' xmlns:foo='baz' type='letter'>
<gsp:scriptlet>def greeting = "${salutation}est"</gsp:scriptlet>
<gsp:expression>greeting</gsp:expression>
<foo:to>$firstname "$nickname" $lastname</foo:to>
How are you today?
</document>
'''
def template = engine.createTemplate(text).make(binding)
println template.toString()
<document type='letter'>
Dearest
<foo:to xmlns:foo='baz'>
Jochen "blackdrag" Theodorou
</foo:to>
How are you today?
</document>
groovy.servlet.TemplateServlet by placing the
following in your web.xml file (plus a corresponding servlet-mapping element):
<servlet>
<servlet-name>XmlTemplate</servlet-name>
<servlet-class>groovy.servlet.TemplateServlet</servlet-class>
<init-param>
<param-name>template.engine</param-name>
<param-value>groovy.text.XmlTemplateEngine</param-value>
</init-param>
</servlet>
| Modifiers | Name | Description |
|---|---|---|
static String |
DEFAULT_INDENTATION |
Default indentation sequence used for pretty-printed XML output. |
| Constructor and description |
|---|
XmlTemplateEngine()Creates an XML template engine using the default indentation and with XML validation disabled. |
XmlTemplateEngine(String indentation, boolean validating)Creates an XML template engine with custom indentation and validation settings. |
XmlTemplateEngine(XmlParser xmlParser, ClassLoader parentLoader)Creates an XML template engine backed by the supplied parser and a GroovyShell built from the parent loader. |
XmlTemplateEngine(XmlParser xmlParser, GroovyShell groovyShell)Creates an XML template engine backed by the supplied parser and shell. |
| Type Params | Return Type | Name and description |
|---|---|---|
|
public Template |
createTemplate(Reader reader)Parses XML template source from the supplied reader and compiles it into a template. |
|
public String |
getIndentation()Returns the indentation string used for pretty-printed XML output. |
|
public void |
setConfigurePrinter(Closure configurePrinter)Closure that can be used to configure the printer. |
|
public void |
setIndentation(String indentation)Sets the indentation string used for pretty-printed XML output. |
|
public String |
toString()Returns a concise engine name for diagnostics. |
| Methods inherited from class | Name |
|---|---|
class TemplateEngine |
createTemplate, createTemplate, createTemplate, createTemplate, createTemplate, createTemplate |
Default indentation sequence used for pretty-printed XML output.
Creates an XML template engine using the default indentation and with XML validation disabled.
Creates an XML template engine with custom indentation and validation settings.
indentation - indentation string used when rendering nested XML nodesvalidating - true to enable XML validation while parsing templatesCreates an XML template engine backed by the supplied parser and a GroovyShell built from the parent loader.
xmlParser - parser used to read template XMLparentLoader - class loader used to compile generated template scriptsCreates an XML template engine backed by the supplied parser and shell.
xmlParser - parser used to read template XMLgroovyShell - shell used to compile generated template scriptsParses XML template source from the supplied reader and compiles it into a template.
reader - XML template sourceReturns the indentation string used for pretty-printed XML output.
nullClosure that can be used to configure the printer. The printer is passed as a parameter to the closure.
new XmlTemplateEngine(configurePrinter: { it.preserveWhitespace = true })
Sets the indentation string used for pretty-printed XML output.
indentation - indentation sequence to use; null restores DEFAULT_INDENTATIONReturns a concise engine name for diagnostics.
Copyright © 2003-2026 The Apache Software Foundation. All rights reserved.