Simple Templates

/**
 * Basic template engine supporting JSP-style syntax
 */
public class SimpleTemplateEngine extends TemplateEngine {
    /**
     * Creates a new SimpleTemplateEngine with default settings
     */
    public SimpleTemplateEngine();
    
    /**
     * Creates a new SimpleTemplateEngine with verbose mode setting
     * @param verbose true to enable template source debugging output
     */
    public SimpleTemplateEngine(boolean verbose);
    
    /**
     * Creates a new SimpleTemplateEngine with custom class loader
     * @param parentLoader ClassLoader for template compilation
     */
    public SimpleTemplateEngine(ClassLoader parentLoader);
    
    /**
     * Creates a new SimpleTemplateEngine with custom GroovyShell
     * @param groovyShell GroovyShell instance for script execution
     */
    public SimpleTemplateEngine(GroovyShell groovyShell);
    
    /**
     * Enable or disable verbose template debugging
     * @param verbose true to display template source for debugging
     */
    public void setVerbose(boolean verbose);
    
    /**
     * Check if verbose mode is enabled
     * @return true if verbose debugging is enabled
     */
    public boolean isVerbose();
    
    /**
     * Enable or disable backslash escaping for GROOVY-4585 compatibility
     * @param escapeBackslash true to enable backslash escaping
     */
    public void setEscapeBackslash(boolean escapeBackslash);
    
    /**
     * Check if backslash escaping is enabled
     * @return true if backslash escaping is enabled
     */
    public boolean isEscapeBackslash();
}

import groovy.text.SimpleTemplateEngine;
import groovy.text.Template;
import groovy.lang.GroovyShell;
import java.util.Map;
import java.util.HashMap;

// Basic usage with default settings
SimpleTemplateEngine engine = new SimpleTemplateEngine();

// Enable verbose debugging to see generated script
SimpleTemplateEngine verboseEngine = new SimpleTemplateEngine(true);

// Use custom class loader
ClassLoader customLoader = MyClass.class.getClassLoader();
SimpleTemplateEngine customEngine = new SimpleTemplateEngine(customLoader);

// Use custom GroovyShell with specific configuration
GroovyShell shell = new GroovyShell();
SimpleTemplateEngine shellEngine = new SimpleTemplateEngine(shell);

// Template with mixed JSP and GString syntax
String templateText = """
Dear <%= firstname %> $lastname,

We <% if (accepted) print 'are pleased' else print 'regret' %> 
to inform you that your paper entitled
'$title' was ${ accepted ? 'accepted' : 'rejected' }.

The conference committee.
""";

Template template = engine.createTemplate(templateText);

Map<String, Object> binding = new HashMap<>();
binding.put("firstname", "Grace");
binding.put("lastname", "Hopper");
binding.put("accepted", true);
binding.put("title", "Groovy for COBOL programmers");

String result = template.make(binding).toString();

String template = """
<% 
def greeting = "Hello"
if (name) {
    greeting += " " + name
} else {
    greeting += " World"
}
%>
$greeting!
""";

String template = """
Current time: <%= new Date() %>
User count: <%= users.size() %>
""";

String template = """
Welcome ${user.name}!
Your balance is $balance.
""";

SimpleTemplateEngine engine = new SimpleTemplateEngine(true);
// or
engine.setVerbose(true);

// When creating templates, the generated script will be printed to System.out
Template template = engine.createTemplate(templateText);

SimpleTemplateEngine engine = new SimpleTemplateEngine();
engine.setEscapeBackslash(true);

// Now backslashes in templates will be properly escaped
String template = "Path: C:\\Users\\$username\\Documents";

<servlet>
  <servlet-name>SimpleTemplate</servlet-name>
  <servlet-class>groovy.servlet.TemplateServlet</servlet-class>
  <init-param>
    <param-name>template.engine</param-name>
    <param-value>groovy.text.SimpleTemplateEngine</param-value>
  </init-param>
</servlet>

try {
    Template template = engine.createTemplate(templateText);
    String result = template.make(binding).toString();
} catch (CompilationFailedException e) {
    // Template compilation failed - syntax error in template
    System.err.println("Template compilation error: " + e.getMessage());
} catch (IOException e) {
    // File I/O error when reading template from file/URL
    System.err.println("I/O error: " + e.getMessage());
} catch (ClassNotFoundException e) {
    // Missing class dependencies
    System.err.println("Class not found: " + e.getMessage());
}