Handlebars.java

The block and partial helpers work together to enable Template Inheritance.

• {{#block "name"}}...{{/block}}: Defines a named region in a template.
• {{#partial "name"}}...{{/partial}}: Defines a partial that can be used to fill a block region.

{{#block "title"}}
  ...
{{/block}}

{{#partial "title"}}
  ...
{{/partial}}

The include helper is a port of a Handlebars.js feature. It is primarily used if you need to maintain compatibility with templates written for Handlebars.js that rely on specific partial implementation behaviors.

Note: In Handlebars.java, all features provided by the include helper are natively supported using standard partials.

Handlebars.java is a Java port of Handlebars/Mustache. You can use compileInline to create a template directly from a string and apply to render it with data.

Handlebars handlebars = new Handlebars();

Template template = handlebars.compileInline("Hello {{this}}!");

System.out.println(template.apply("Handlebars.java"));

The handlebars-proto artifact provides a small standalone server useful for web designers to test Mustache/Handlebars templates with data. You can run it as a JAR file and point it to a directory containing your .hbs templates and corresponding .json or .yml data files.

To use the server:

1. Download the handlebars-proto JAR from Maven Central.
2. Run the JAR using the -dir flag to specify your template directory.
3. Access templates via a browser at http://localhost:6780/template_name.hbs.

You can also test multiple datasets for a single template by appending a data parameter to the URI (e.g., ?data=mytestdata).

java -jar handlebars-proto-${current-version}.jar -dir myTemplates

Add the following dependency to your pom.xml to use Handlebars.java. Ensure you replace ${handlebars-version} with the desired stable version.

<dependency>
  <groupId>com.github.jknack</groupId>
  <artifactId>handlebars</artifactId>
  <version>${handlebars-version}</version>
</dependency>

The NumberHelper provides common functions for working with numbers in templates:

• isEven: Checks if a number is even.
• isOdd: Checks if a number is odd.
• stripes: Typically used for alternating styles (often used in conjunction with even/odd logic).

These helpers can return a boolean-like string or a specific CSS class name if a second argument is provided.

{{isEven number}} // output: even

{{isEven number "row-even"}} // output: row-even

The assign helper allows you to create auxiliary or temporary variables within a template. This is useful for storing the result of a complex expression or a sub-template to be used later in the same template context.

Usage pattern: {{#assign "variableName"}} expression {{/assign}}

{{#assign "benefitsTitle"}} benefits.{{type}}.title {{/assign}}
<span class="benefit-title"> {{i18n benefitsTitle}} </span>

By default, Handlebars.java uses a combination of JavaBeanValueResolver, MapValueResolver, and MethodValueResolver. You can customize how data is resolved from your context using the Context.Builder.

Available Resolvers:

• JavaBeanValueResolver.INSTANCE: Resolves via getXXX or isXXX methods.
• FieldValueResolver.INSTANCE: Resolves via non-static fields.
• MapValueResolver.INSTANCE: Resolves from java.util.Map objects.
• MethodValueResolver.INSTANCE: Resolves via any public methods.
• JsonNodeValueResolver.INSTANCE: Resolves from Jackson JsonNode objects.

Usage:

Context context = Context.newBuilder(model)
  .resolver(MapValueResolver.INSTANCE, JavaBeanValueResolver.INSTANCE)
  .build();

Context context = Context.newBuilder(model)
  .resolver(JavaBeanValueResolver.INSTANCE)
  .build();

The handlebars-json module allows you to serialize objects to JSON directly within a template using the json helper.

Usage: {{json context [view="alias"] [escapeHTML=false] [pretty=false]}}

Options:

• context: The object to serialize.
• view: The name of a Jackson View (optional).
• escapeHTML: Whether to escape HTML characters (default: false).
• pretty: Whether to format the JSON (default: false).

Registration:

handlebars.registerHelper("json", JacksonHelper.INSTANCE);

{{json context [view="foo.MyFullyQualifiedClassName"] [escapeHTML=false] [pretty=false]}}

Templates are loaded via the TemplateLoader interface. By default, Handlebars uses ClassPathTemplateLoader. Other available implementations include:

• ClassPathTemplateLoader (default)
• FileTemplateLoader
• SpringTemplateLoader (available via the handlebars-springmvc module)

To use a specific loader, pass it to the Handlebars constructor.

var handlebars = new Handlebars();
var template = handlebars.compile("mytemplate");

System.out.println(template.apply("Handlebars.java"));