Schablonenmotoren für den Frühling

1. Übersicht

Das Spring-Webframework basiert auf dem MVC-Muster (Model-View-Controller), das das Trennen von Problemen in einer Anwendung erleichtert. Dies ermöglicht die Verwendung verschiedener Ansichtstechnologien, von der etablierten JSP-Technologie bis zu einer Vielzahl von Template-Engines.

In diesem Artikel werden wir uns die wichtigsten Template-Engines ansehen, die mit Spring verwendet werden können, ihre Konfiguration und Anwendungsbeispiele.

2. Spring View-Technologien

Angesichts der Tatsache, dass Bedenken in einer Spring MVC-Anwendung sauber voneinander getrennt sind, ist der Wechsel von einer Ansichtstechnologie zur anderen in erster Linie eine Frage der Konfiguration.

Um jeden Ansichtstyp zu rendern, müssen wir eine ViewResolver- Bean definieren , die jeder Technologie entspricht. Dies bedeutet, dass wir dann die Ansichtsnamen von @ Controller- Zuordnungsmethoden auf die gleiche Weise zurückgeben können, wie wir normalerweise JSP-Dateien zurückgeben.

In den folgenden Abschnitten werden wir uns mit traditionelleren Technologien wie Java Server Pages sowie den wichtigsten Template-Engines befassen , die mit Spring verwendet werden können: Thymeleaf , Groovy , FreeMarker, Jade.

Für jede dieser Anwendungen werden wir die Konfiguration durchgehen, die sowohl in einer Standard-Spring-Anwendung als auch in einer mit Spring Boot erstellten Anwendung erforderlich ist .

3. Java Server Pages

JSP ist eine der beliebtesten Ansichtstechnologien für Java-Anwendungen und wird von Spring Out-of-the-Box unterstützt. Zum Rendern von JSP-Dateien ist InternalResourceViewResolver ein häufig verwendeter Typ der ViewResolver- Bean :

@EnableWebMvc @Configuration public class ApplicationConfiguration implements WebMvcConfigurer { @Bean public ViewResolver jspViewResolver() { InternalResourceViewResolver bean = new InternalResourceViewResolver(); bean.setPrefix("/WEB-INF/views/"); bean.setSuffix(".jsp"); return bean; } }

Als Nächstes können wir mit dem Erstellen von JSP-Dateien am Speicherort / WEB-INF / views beginnen :

    User Registration    Email:   Password:      

Wenn wir die Dateien zu einer Spring Boot- Anwendung hinzufügen , können wir anstelle der ApplicationConfiguration- Klasse die folgenden Eigenschaften in einer application.properties- Datei definieren:

spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp

Basierend auf diesen Eigenschaften konfiguriert Spring Boot den erforderlichen ViewResolver automatisch .

4. Thymeleaf

Thymeleaf ist eine Java-Template-Engine, die HTML-, XML-, Text-, JavaScript- oder CSS-Dateien verarbeiten kann. Im Gegensatz zu anderen Template-Engines ermöglicht Thymeleaf die Verwendung von Templates als Prototypen, dh sie können als statische Dateien angezeigt werden.

4.1. Maven-Abhängigkeiten

Um Thymeleaf in Spring zu integrieren , müssen wir die Abhängigkeiten Thymeleaf und Thymeleaf-spring4 hinzufügen :

 org.thymeleaf thymeleaf 3.0.11.RELEASE   org.thymeleaf thymeleaf-spring5 3.0.11.RELEASE 

Wenn wir ein Spring 4-Projekt haben, müssen wir thymeleaf-spring4 hinzufügen .

4.2. Federkonfiguration

Als Nächstes müssen wir die Konfiguration hinzufügen, für die eine SpringTemplateEngine- Bean sowie eine TemplateResolver- Bean erforderlich sind , die den Speicherort und den Typ der Ansichtsdateien angibt.

Der SpringResourceTemplateResolver ist in den Ressourcenauflösungsmechanismus von Spring integriert:

@Configuration @EnableWebMvc public class ThymeleafConfiguration { @Bean public SpringTemplateEngine templateEngine() { SpringTemplateEngine templateEngine = new SpringTemplateEngine(); templateEngine.setTemplateResolver(thymeleafTemplateResolver()); return templateEngine; } @Bean public SpringResourceTemplateResolver thymeleafTemplateResolver() { SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver(); templateResolver.setPrefix("/WEB-INF/views/"); templateResolver.setSuffix(".html"); templateResolver.setTemplateMode("HTML5"); return templateResolver; } }

Außerdem benötigen wir eine ViewResolver- Bean vom Typ ThymeleafViewResolver :

@Bean public ThymeleafViewResolver thymeleafViewResolver() { ThymeleafViewResolver viewResolver = new ThymeleafViewResolver(); viewResolver.setTemplateEngine(templateEngine()); return viewResolver; }

4.3. Thymeleaf Vorlagen

Jetzt können wir eine HTML-Datei am Speicherort WEB-INF / views hinzufügen :

   User Registration    Email: Password:    

Thymeleaf- Vorlagen sind in der Syntax HTML-Vorlagen sehr ähnlich.

Einige der Funktionen, die bei der Verwendung von Thymeleaf in einer Spring-Anwendung verfügbar sind, sind:

    • Unterstützung für die Definition des Formularverhaltens
    • verbindliche Formulareingaben an Datenmodelle
    • Validierung für Formulareingaben
    • Anzeigen von Werten aus Nachrichtenquellen
    • Rendern von Vorlagenfragmenten

Weitere Informationen zur Verwendung von Thymeleaf- Vorlagen finden Sie in unserem Artikel Thymeleaf in Spring MVC.

4.4. Thymeleaf im Frühlingsstiefel

Spring Boot bietet eine automatische Konfiguration für Thymeleaf durch Hinzufügen der Spring-Boot-Starter-Thymeleaf- Abhängigkeit:

 org.springframework.boot spring-boot-starter-thymeleaf 2.3.3.RELEASE 

Es ist keine explizite Konfiguration erforderlich. Standardmäßig sollten HTML-Dateien am Speicherort für Ressourcen / Vorlagen abgelegt werden .

5. FreeMarker

FreeMarker ist eine Java-basierte Vorlagen-Engine, die von der Apache Software Foundation erstellt wurde . Es kann verwendet werden, um Webseiten, aber auch Quellcode, XML-Dateien, Konfigurationsdateien, E-Mails und andere textbasierte Formate zu generieren.

The generation is done based on template files written using the FreeMarker Template Language.

5.1. Maven Dependencies

To start using the templates in our project, we need the freemarker dependency:

 org.freemarker freemarker 2.3.23 

For Spring integration, we also need the spring-context-support dependency:

 org.springframework spring-context-support 5.2.8.RELEASE 

5.2. Spring Configuration

Integrating FreeMarker with Spring MVC requires defining a FreemarkerConfigurer bean which specifies the location of the template files:

@Configuration @EnableWebMvc public class FreemarkerConfiguration { @Bean public FreeMarkerConfigurer freemarkerConfig() { FreeMarkerConfigurer freeMarkerConfigurer = new FreeMarkerConfigurer(); freeMarkerConfigurer.setTemplateLoaderPath("/WEB-INF/views/"); return freeMarkerConfigurer; } }

Next, we need to define an appropriate ViewResolver bean of type FreeMarkerViewResolver:

@Bean public FreeMarkerViewResolver freemarkerViewResolver() { FreeMarkerViewResolver resolver = new FreeMarkerViewResolver(); resolver.setCache(true); resolver.setPrefix(""); resolver.setSuffix(".ftl"); return resolver; }

5.3. FreeMarker Templates

We can create an HTML template using FreeMarker in the WEB-INF/views location:

    User Registration     Email:  Password:     

In the example above, we have imported a set of macros defined by Spring for working with forms in FreeMarker, including binding form inputs to data models.

Also, the FreeMarker Template Language contains a large number of tags, directives, and expressions for working with collections, flow control structures, logical operators, formatting and parsing strings, numbers and many more features.

5.4. FreeMarker in Spring Boot

In a Spring Boot application, we can simplify the needed configuration by using the spring-boot-starter-freemarker dependency:

 org.springframework.boot spring-boot-starter-freemarker 2.3.3.RELEASE 

This starter adds the necessary auto-configuration. All we need to do is start placing our template files in the resources/templates folder.

6. Groovy

Spring MVC views can also be generated using the Groovy Markup Template Engine. This engine is based on a builder syntax and can be used for generating any text format.

6.1. Maven Dependencies

The groovy-templates dependency needs to be added to our pom.xml:

 org.codehaus.groovy groovy-templates 2.4.12 

6.2. Spring Configuration

The integration of the Markup Template Engine with Spring MVC requires defining a GroovyMarkupConfigurer bean and a ViewResolver of type GroovyMarkupViewResolver:

@Configuration @EnableWebMvc public class GroovyConfiguration { @Bean public GroovyMarkupConfigurer groovyMarkupConfigurer() { GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer(); configurer.setResourceLoaderPath("/WEB-INF/views/"); return configurer; } @Bean public GroovyMarkupViewResolver thymeleafViewResolver() { GroovyMarkupViewResolver viewResolver = new GroovyMarkupViewResolver(); viewResolver.setSuffix(".tpl"); return viewResolver; } }

6.3. Groovy Markup Templates

Templates are written in the Groovy language and have several characteristics:

    • they are compiled into bytecode
    • they contain support for fragments and layouts
    • they provide support for internationalization
    • the rendering is fast

Let's create a Groovy template for our “User Registration” form, which includes data bindings:

yieldUnescaped '' html(lang:'en') { head { meta('http-equiv':'"Content-Type" ' + 'content="text/html; charset=utf-8"') title('User Registration') } body { form (id:'userForm', action:'register', method:'post') { label (for:'email', 'Email') input (name:'email', type:'text', value:user.email?:'') label (for:'password', 'Password') input (name:'password', type:'password', value:user.password?:'') div (class:'form-actions') { input (type:'submit', value:'Submit') } } } }

6.4. Groovy Template Engine in Spring Boot

Spring Boot contains auto-configuration for the Groovy Template Engine, which is added by including the spring-boot-starter-groovy-templates dependency:

 org.springframework.boot spring-boot-starter-groovy-templates 2.3.3.RELEASE 

The default location for the templates is /resources/templates.

7. Jade4j

Jade4j is the Java implementation of the Pug template engine (originally known as Jade) for Javascript. Jade4j templates can be used for generating HTML files.

7.1. Maven Dependencies

For Spring integration, we need the spring-jade4j dependency:

 de.neuland-bfi spring-jade4j 1.2.5 

7.2. Spring Configuration

To use Jade4j with Spring, we have to define a SpringTemplateLoader bean that configures the location of the templates, as well as a JadeConfiguration bean:

@Configuration @EnableWebMvc public class JadeTemplateConfiguration { @Bean public SpringTemplateLoader templateLoader() { SpringTemplateLoader templateLoader = new SpringTemplateLoader(); templateLoader.setBasePath("/WEB-INF/views/"); templateLoader.setSuffix(".jade"); return templateLoader; } @Bean public JadeConfiguration jadeConfiguration() { JadeConfiguration configuration = new JadeConfiguration(); configuration.setCaching(false); configuration.setTemplateLoader(templateLoader()); return configuration; } }

Next, we need the usual ViewResolver bean, in this case of type JadeViewResolver:

@Bean public ViewResolver viewResolver() { JadeViewResolver viewResolver = new JadeViewResolver(); viewResolver.setConfiguration(jadeConfiguration()); return viewResolver; }

7.3. Jade4j Templates

Jade4j templates are characterized by an easy-to-use whitespace-sensitive syntax:

doctype html html head title User Registration body form(action="register" method="post" ) label(for="email") Email: input(type="text" name="email") label(for="password") Password: input(type="password" name="password") input(type="submit" value="Submit")

The project also provides a very useful interactive documentation, where you can view the output of your template as you write it.

Spring Boot does not provide a Jade4j starter, so in a Boot project, we would have to add the same Spring configuration as defined above.

8. Other Template Engines

Besides the template engines described so far, there are quite a few more available which may be used.

Let's review some of them briefly.

Velocity is an older template engine, which is very complex but has the disadvantage that Spring has deprecated its use since version 4.3 and removed completely in Spring 5.0.1.

JMustache ist eine Vorlagen-Engine, die mithilfe der Spring-Boot-Starter-Moustache- Abhängigkeit problemlos in eine Spring Boot-Anwendung integriert werden kann .

Pebble unterstützt Spring und Spring Boot in seinen Bibliotheken.

Andere Vorlagenbibliotheken wie Handlebars oder React , die auf einer JSR-223- Skript-Engine wie Nashorn ausgeführt werden, können ebenfalls verwendet werden.

9. Fazit

In diesem Artikel haben wir einige der beliebtesten Template-Engines für Spring-Webanwendungen besprochen.

Und wie immer finden Sie den vollständigen Quellcode der Beispiele auf GitHub.