Templating in Java Using JTE

Last updated: February 4, 2026

Written by: Michael Krimgen

Reviewed by: Liam Williams

Spring MVC

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

Java Template Engine is a fast, secure, and lightweight templating library that leverages Java and Kotlin syntax in its templates.

In this tutorial, we’ll have a quick introduction to the library and its key features. First, we’ll look at a basic example, then we’ll explore some additional features, such as its IntelliJ plugin, Spring Boot integration, and possibilities to boost performance.

2. Setup and Maven Dependencies

To use the library, we need the Maven JTE dependency:

<dependency>
    <groupId>gg.jte</groupId>
    <artifactId>jte</artifactId>
    <version>3.2.2</version>
</dependency>

Optionally, we can install the JTE IntelliJ plugin for our IDE.

3. Basic Example

Let’s jump directly into a basic example to see what a JTE template looks like and how we can render it with data from a custom record.

3.1. The Model Class

First, let’s define a model class that will hold the data we’ll use to render our JTE template:

public record Article(String title, String author, String content, int views) {
}

3.2. The Template File

The template syntax aims to be as close to Java as possible. We can import any Java class with @import. Furthermore, we can use any Java expression whose return value is a String, enum, primitive data type, or a type that implements gg.jte.Content. Expressions are written using ${} syntax:

@import com.baeldung.jte.Article
@param Article article
<html>
    <body>
        <h1>${article.title()}</h1>
        <h2>${article.author()}</h2>
        <p>${article.content()}</p>
        <p>${article.views()}</p>
    </body>
</html>

3.3. Template Rendering

Assuming that the above template file is located at src/main/resources/jte, we can render our article view:

public String createHtml() {
    CodeResolver codeResolver = new DirectoryCodeResolver(Path.of("src/main/resources/jte"));

    TemplateOutput output = new StringOutput();
    TemplateEngine.create(codeResolver, Html).render(
      "article.jte",
      new Article("Java Template Engine", "Baeldung", "Helpful article", 42),
      output
    );

    return output.toString();
}

The above method returns the rendered view:

<html>
    <body>
        <h1>Java Template Engine</h1>
        <h2>Baeldung</h2>
        <p>The Java Template Engine is ...</p>
        <p>42</p>
    </body>
</html>

4. Additional Features

Next, let’s go through some of the features that distinguish JTE from other templating libraries.

4.1. Usage With Kotlin

JTE also integrates smoothly with Kotlin. We can use the same Maven dependency for use with Kotlin. The template syntax will be slightly different to align more with the Kotlin syntax, as explained in the official documentation. We’ll look at a short example in the next section.

4.2. Template Syntax

The template syntax aims to be similar to Java and Kotlin. Let’s look at an example. Using Java, a for-each loop in the template looks similar to a for-each loop in Java itself:

@for(String line : article.content().lines().toList())
    <p>${line}</p>
@endfor

And here’s the same template in Kotlin:

@for(line in article.content().lines())
    <li>${line}</li>
@endfor

In addition, we can add Java or Kotlin code within the ${}. Here’s an example in Java:

@import com.baeldung.jte.Article
@param Article article
<html>
    <body>
        <h1>${article.title()}</h1>
        <h2>${article.author()}</h2>
        <p>${article.content()}</p>
        <p>${article.views() < 100 ? "niche" : "popular"}</p>
    </body>
</html>

The example shows how we can use the ternary operator to display some text depending on the value returned by article.views().

4.3. HTML vs Plain Text Templates

In our example, we’ve used ContentType.Html as the content type for our template. This option tells JTE that the output format is HTML and enables intelligent rendering. This ensures that our output is correctly escaped and attributes are omitted if their value is false.

Here’s an example of escaped HTML output. Let’s assume that the value of the field title is:

<script>alert('inject');</script>

Then the rendered template will contain the escaped string:

<h1>&lt;script&gt;alert('inject');&lt;/script&gt;</h1>

For any other content type, we can use ContentType.Plain. In this case, no escaping is applied.

4.4. IntelliJ Plugin

JTE comes with an IntelliJ plugin that greatly improves the developer experience. It provides code completion, refactoring support, code navigation, and syntax highlighting.

4.5. Spring Boot Integration

JTE provides a smooth Spring Boot integration, which makes it easy to use JTE as a ViewResolver in Spring MVC.

4.6. Performance Features

JTE aims to outperform most well-known Java libraries, such as Thymeleaf and FreeMarker, in terms of speed. Two features to improve performance are the possibility to precompile templates and binary rendering.

5. Conclusion

In this article, we introduced JTE, a templating library for Java and Kotlin. JTE provides a rich set of features and a complete developer experience, including an IntelliJ plugin and Spring integration. As usual, the code in this article is available over on GitHub.