Calling an Object’s Method From Thymeleaf

1. Introduction

In this article, we’ll take a look at how we can use custom Java methods inside our Thymeleaf templates. We’ll look at a few kinds of methods and how to call them using Thymeleaf syntax.

2. Why Call Object Methods?

Normally, when we’re working with Thymeleaf templates, we render HTML markup and insert values from our model attributes into it. This is how Thymeleaf is designed and expects us to work.

Occasionally, though, we might need to do something slightly more complicated. For example, we might need to call a Java method to generate extra data for our template, or to produce correctly formatted output for a value. This isn’t usual practice for Thymeleaf templates, but sometimes we can’t avoid it easily.

3. Calling Methods on Model Objects

One of the most typical use cases for calling Java methods from our templates is when the methods are part of our model objects. This is how we can get data from our model object into our template.

For example, our model might be as follows:

public class MethodsModel {
    private final String theName;

    public MethodsModel(String theName) {
        this.theName = theName;
    }

    public String getName() {
        return theName;
    }

    public String buildUppercaseName() {
        return getName().toUpperCase();
    }

    public String getNameSubstring(int index) {
        return getName().substring(index);
    }
}

First, we can simply call getter methods, for example getName(). We can do this by using the field name that the getter represents:

<p th:text="'getName = ' + ${methodsModel.name}"></p>

Thymeleaf understands that this needs to map onto the getName() method. It won’t access private members, so in order to access a private field we need to use a public getter.

We can also call methods that don’t follow the getter pattern, by using the traditional method invocation syntax we know from Java:

<p th:text="'buildUppercaseName = ' + ${methodsModel.buildUppercaseName()}"></p>

When doing this, Thymeleaf understands that we’re calling the named method directly.

We can also pass parameters to a method:

<p th:text="'getNameSubstring = ' + ${methodsModel.getNameSubstring(3)}"></p>

Doing this will cause Thymeleaf to call the Java method with the same parameters, getting the correct output for our template.

4. Calling Static Methods

In some cases, we need to use helper methods on other objects. For example, when we want to use some static Java code to help format values that we’re rendering in our template:

public class DateFormatter {
    private static String DEFAULT_FORMAT = "YYYY-MM-DD hh:mm:ss";

    public static String defaultDateFormat() {
        return DEFAULT_FORMAT;
    }
    public static String format(Instant instant) {
        return DateTimeFormatter.ofPattern(DEFAULT_FORMAT).format(instant.atZone(ZoneId.of("UTC")));
    }
}

Thymeleaf can call these methods in the same way we saw earlier. The only complication is getting the correct reference to the class in question.

When rendering our Thymeleaf templates with Spring, we’re able to use some SpEL constructs to help us out. In particular, here we can use the T() call to get a reference to a type:

<p th:text="'defaultDateFormat = ' + ${T(com.baeldung.thymeleaf.controller.DateFormatter).defaultDateFormat()}"></p>

This resolves the com.baeldung.thymeleaf.controller.DateFormatter class and then calls the defaultDateFormat() static method on it, inserting the return value into our template.

We’re also able to pass parameters in, exactly as before:

<p th:text="'formatNow = ' + ${T(com.baeldung.thymeleaf.controller.DateFormatter).format(methodsModel.now)}"></p>

Here, we’re calling the format() method, and passing in the result of calling getNow() on our model object. This allows us to use a Java method to format our value before it’s inserted into our output.

5. Calling Methods on Spring Beans

We sometimes need to call methods defined on beans in our Spring context. One approach is to inject the bean into our model object:

@Controller
public class MyController {
    @Autowired
    public MyBean myBean;

    @RequestMapping(value = "/myRoute", method = RequestMethod.GET)
    public String handle(Model model) {
        model.addAttribute("myBean", myBean);
        return "view.html";
    }
}

However, this won’t scale well, as we’d have to repeat it in any controller that uses a template that depends on the bean.

Fortunately, Spring actually makes all our Spring beans available to our Thymeleaf templates by default. All we need to do is ensure that we have beans defined with unique names:

public class MethodsBean {
    public String hello() {
        return "Hello, Baeldung!";
    }
}

@Configuration
public class MethodsConfiguration {
    @Bean
    public MethodsBean methodsBean() {
        return new MethodsBean();
    }
}

We can then call methods on it exactly as before:

<p th:text="'methodsBean = ' + ${@methodsBean.hello()}"></p>

Here, the “@methodsBean” syntax refers to the bean in our Spring context with this name. This does, unfortunately, mean that we can’t refer to unnamed beans unless we can reliably determine the generated name at compile time. However, generally in cases where we need to access Spring beans from our templates, we also have control over what they’re named.

6. Conclusion

In this article, we’ve seen several ways to call Java methods on different types of classes directly from our Thymeleaf templates. Next time you’re writing Thymeleaf and need to do this, why not give it a try.

As always, all the code used in this article is available over on GitHub.