Package org.apache.juneau.rest.server.view.mustache

Class MustacheView

java.lang.Object
org.apache.juneau.rest.server.view.mustache.MustacheView
All Implemented Interfaces:
View
public final class MustacheView extends Object implements View
Immutable value class returned from @RestOp-annotated methods to ask the framework to render a Mustache template.

Companion to MustacheMixin and MustacheViewRenderer: the mixin sets up the /mustache/* mount and registers the renderer; the renderer detects MustacheView returns in the response-processor chain and asks the configured com.github.mustachejava.MustacheFactory to compile(templateName) and then execute(writer, scope) directly onto the response writer.

Usage:

@RestGet("/hello/{name}") public View hello(@Path String name) { return MustacheView.of("hello.mustache") .attr("name", name) .attr("ts", Instant.now()); }

The template name is factory-relative — the configured com.github.mustachejava.MustacheFactory resource resolver prepends its own resource root. With the bridge's default factory + basePath("/templates/"), MustacheView.of("hello.mustache") resolves to templates/hello.mustache on the classpath.

Template suffix:

Unlike the Thymeleaf bridge (which always appends .html via the engine resolver's suffix setting), mustache.java does not have a built-in resolver-suffix concept — the literal template name is what factory.compile(...) sees. The templateSuffix(...) builder knob fills the gap: when set, the bridge appends the suffix to template names that don't already end with it (idempotent), so the caller can write MustacheView.of("hello") and the bridge resolves it as "hello.mustache" on the classpath.

Immutability:

Each attr(...) / attrs(...) / header(...) call returns a new MustacheView carrying the additional binding; the original instance is unchanged. This keeps MustacheView a value type safe to share across requests (e.g. as a static singleton built once and returned from many handlers).

See Also:
Since:
10.0.0

  • Method Details

    • of

      public static MustacheView of(String templateName)
      Creates a new MustacheView carrying the given template name and no attributes.

      The template name is factory-relative; the configured com.github.mustachejava.MustacheFactory resource resolver supplies the prefix (resource root). With the bridge's default factory + basePath("/templates/") and templateSuffix(".mustache"), "hello" resolves to templates/hello.mustache; without templateSuffix, the literal name is used as-is.

      Parameters:
      templateName - The template name (factory-relative, suffix optional). Must not be null or blank.
      Returns:
      A new MustacheView instance.
      Throws:
      IllegalArgumentException - If templateName is null or blank.

    • attr

      public MustacheView attr(String key, Object value)
      Returns a copy of this view with the given attribute added (or replaced if a binding for key already exists).

      The full attribute map is passed to mustache.java as the rendering scope, so each entry is accessible inside the template as {{key}}. null values are rejected at build-time because a null scope binding in mustache.java renders as an empty string, which silently masks what is typically a caller bug; rejecting up-front surfaces the mistake at the call site (matches the Thymeleaf-bridge precedent).

      Parameters:
      key - The attribute key (exposed inside the template as {{key}}). Must not be null or blank.
      value - The attribute value. Must not be null.
      Returns:
      A new MustacheView carrying the additional attribute.
      Throws:
      IllegalArgumentException - If key is null or blank, or value is null.

    • attrs

      public MustacheView attrs(Map<String,?> values)
      Returns a copy of this view with all entries from the given map added (or replaced if a binding for any key already exists).
      Parameters:
      values - The attributes to add. null is treated as an empty map (the result is the same instance with no entries added).
      Returns:
      A new MustacheView carrying the additional attributes.
      Throws:
      IllegalArgumentException - If any entry has a null/blank key or a null value.

    • header

      public MustacheView header(String name, String value)
      Returns a copy of this view with the given response header set on the rendered response.

      Typical usage: .header("Content-Type", "text/html; charset=UTF-8") or .header("Cache-Control", "no-store"). The renderer applies these headers via HttpServletResponse.setHeader(...) before writing the rendered output.

      Parameters:
      name - The header name. Must not be null or blank.
      value - The header value. Must not be null.
      Returns:
      A new MustacheView carrying the additional response header.
      Throws:
      IllegalArgumentException - If name is null or blank, or value is null.

    • getTemplateName

      public String getTemplateName()
      Description copied from interface: View
      The name of the template to render — typically a path relative to the mixin-configured base path.

      For example, "hello.jsp" with a JSP mixin basePath("/WEB-INF/views/") resolves to "/WEB-INF/views/hello.jsp" on the request dispatcher.

      Specified by:
      getTemplateName in interface View
      Returns:
      The template name. Never null.

    • getAttributes

      public Map<String,Object> getAttributes()
      Description copied from interface: View
      The attributes to expose to the template.

      Each entry is forwarded to the templating engine as a named binding accessible from inside the template (e.g. ${name} in JSP / EL, th:text="${name}" in Thymeleaf).

      Specified by:
      getAttributes in interface View
      Returns:
      The attributes map. Never null; returns an immutable empty map when no attributes are bound.

    • getResponseHeaders

      public Map<String,String> getResponseHeaders()
      Description copied from interface: View
      Optional response headers applied by the renderer before forwarding to the templating engine.

      Typical use cases: setting Content-Type (e.g. "text/html; charset=UTF-8") or Cache-Control on the rendered response. The default implementation returns an empty map so most View impls don't need to override it.

      Specified by:
      getResponseHeaders in interface View
      Returns:
      An immutable map of headers to apply. Never null; defaults to an empty map.

    • toString

      public String toString()
      Overrides:
      toString in class Object