TOC

Template Engines für den Frühling

Template-Motoren für den Frühling

1. Überblick

Das Spring-Webframework basiert auf dem MVC-Muster (Model-View-Controller), mit dem sich Probleme in einer Anwendung leichter trennen lassen. Dies ermöglicht die Verwendung verschiedener View-Technologien, von der bewährten 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 eineViewResolver-Bean definieren, die jeder Technologie entspricht. Dies bedeutet, dass wir dann die Ansichtsnamen aus den Zuordnungsmethoden von@Controllerauf dieselbe Weise zurückgeben können, wie wir normalerweise JSP-Dateien zurückgeben.

In den folgenden Abschnitten werden wir uns mit traditionelleren Technologien wieJava 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 mitSpring Boot erstellten Anwendung erforderlich ist.

3. Java Server Pages

JSP ist eine der beliebtesten View-Technologien für Java-Anwendungen und wird von Spring Out-of-the-Box unterstützt. Zum Rendern von JSP-Dateien istInternalResourceViewResolver ein häufig verwendeter Typ vonViewResolver 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 von/WEB-INF/viewsbeginnen: 

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

    
        
        User Registration
    
    
        
            Email: 
            
            Password:

Wenn wir die Dateien zu einerSpring Boot-Anwendung hinzufügen, können wir anstelle derApplicationConfiguration-Klasse die folgenden Eigenschaften in einerapplication.properties-Datei definieren: 

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

Basierend auf diesen Eigenschaften konfiguriertSpring Boot die erforderlichenViewResolver 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 können inThymeleaf Vorlagen als Prototypen verwendet werden, sodass sie als statische Dateien angezeigt werden können.

4.1. Maven-Abhängigkeiten

UmThymeleaf in Spring zu integrieren, müssen Sie die Abhängigkeitenthymeleaf undthymeleaf-spring4 hinzufügen: 


    org.thymeleaf
    thymeleaf
    3.0.7.RELEASE


    org.thymeleaf
    thymeleaf-spring4
    3.0.7.RELEASE

Wenn wir ein Spring 3-Projekt haben, müssen wirthymeleaf-spring3 hinzufügen.

4.2. Federkonfiguration

Als Nächstes müssen wir die Konfiguration hinzufügen, für die eineSpringTemplateEngine-Bean erforderlich ist, sowie eineTemplateResolver-Bean, die den Speicherort und den Typ der Ansichtsdateien angibt.

DasSpringResourceTemplateResolver 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 eineViewResolver-Bean vom TypThymeleafViewResolver: 

@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 vonWEB-INF/viewshinzufügen: 


    
        
        User Registration
    
    
        

            Email:
            Password:

Die Vorlagen vonThymeleafind in der Syntax den HTML-Vorlagen sehr ähnlich.

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

  • Unterstützung für das Definieren des Formularverhaltens

  • Formulareingaben an Datenmodelle binden

  • Validierung für Formulareingaben

  • Anzeigen von Werten aus Nachrichtenquellen

  • Vorlagenfragmente rendern

Weitere Informationen zur Verwendung vonThymeleaf-Vorlagen finden Sie in unserem ArtikelThymeleaf in Spring MVC.

4.4. Thymeleaf inSpring Boot

Spring Boot bietet eine automatische Konfiguration fürThymeleaf durch Hinzufügen der Abhängigkeit vonspring-boot-starter-thymeleaf: 


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

Es ist keine explizite Konfiguration erforderlich. Standardmäßig sollten HTML-Dateien am Speicherort vonresources/templatesabgelegt werden.

5. FreeMarker

FreeMarker ist eine Java-basierte Vorlagen-Engine, die vonApache Software Foundation erstellt wurde. Es kann zum Generieren von Webseiten, aber auch von Quellcode, XML-Dateien, Konfigurationsdateien, E-Mails und anderen textbasierten Formaten verwendet werden.

Die Generierung basiert auf Vorlagendateien, die mitFreeMarker Template Language geschrieben wurden.

5.1. Maven-Abhängigkeiten

Um die Vorlagen in unserem Projekt verwenden zu können, benötigen wir die Abhängigkeit vonfreemarker: 


    org.freemarker
    freemarker
    2.3.23

Für die Spring-Integration benötigen wir außerdem die Abhängigkeit vonspring-context-support: 


    org.springframework
    spring-context-support
    4.3.10.RELEASE

5.2. Federkonfiguration

Für die Integration vonFreeMarker in Spring MVC muss eineFreemarkerConfigurer-Bean definiert werden, die den Speicherort der Vorlagendateien angibt: 

@Configuration
@EnableWebMvc
public class FreemarkerConfiguration {

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

Als nächstes müssen wir eine geeigneteViewResolver-Bean vom TypFreeMarkerViewResolver definieren: 

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

5.3. FreeMarker Vorlagen

Wir können eine HTML-Vorlage mitFreeMarker an der Position vonWEB-INF/viewserstellen: 

<#import "/spring.ftl" as spring/>

    
        
        User Registration
    
    
        

            <@spring.bind path="user" />
            Email: <@spring.formInput "user.email"/>
            Password: <@spring.formPasswordInput "user.password"/>

Im obigen Beispiel haben wir eine Reihe von von Spring definierten Makros für die Arbeit mit Formularen inFreeMarker importiert, einschließlich der Bindung von Formulareingaben an Datenmodelle.

Außerdem enthältFreeMarker Template Language eine große Anzahl von Tags, Anweisungen und Ausdrücken für die Arbeit mit Sammlungen, Flusssteuerungsstrukturen, logischen Operatoren, Formatierungs- und Analysezeichenfolgen, Zahlen und vielen weiteren Funktionen.

5.4. FreeMarker inSpring Boot

In einerSpring Boot-Anwendung können wir die erforderliche Konfiguration mithilfe derspring-boot-starter-freemarker-Abhängigkeit vereinfachen: 


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

Dieser Starter fügt die notwendige Autokonfiguration hinzu. Alles, was wir tun müssen, ist, unsere Vorlagendateien im Ordnerresources/templatesabzulegen.

6. Groovy

Spring MVC-Ansichten können auch mitGroovy Markup Template Engine generiert werden. Diese Engine basiert auf einer Builder-Syntax und kann zum Generieren eines beliebigen Textformats verwendet werden.

6.1. Maven-Abhängigkeiten

Die Abhängigkeit vongroovy-templatesmuss zu unserenpom.xmlhinzugefügt werden: 


    org.codehaus.groovy
    groovy-templates
    2.4.12

6.2. Federkonfiguration

Die Integration derMarkup Template Engine in Spring MVC erfordert die Definition einerGroovyMarkupConfigurer-Bean und einerViewResolver vom TypGroovyMarkupViewResolver: 

@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 Vorlagen

Vorlagen sind in der Groovy-Sprache geschrieben und weisen mehrere Merkmale auf:

  • Sie werden in Bytecode kompiliert

  • Sie enthalten Unterstützung für Fragmente und Layouts

  • Sie unterstützen die Internationalisierung

  • Das Rendern ist schnell

Erstellen wir eine Groovy-Vorlage für unser Formular "Benutzerregistrierung", das Datenbindungen enthält: 

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 inSpring Boot

Spring Boot enthält eine automatische Konfiguration fürGroovy Template Engine, die durch Einbeziehen der Abhängigkeit vonspring-boot-starter-groovy-templates hinzugefügt wird: 


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

Der Standardspeicherort für die Vorlagen ist/resources/templates.

7. Jade4j

Jade4j ist die Java-Implementierung derPug Template Engine (ursprünglich alsJade bekannt) für Javascript. Jade4j Vorlagen können zum Generieren von HTML-Dateien verwendet werden.

7.1. Maven-Abhängigkeiten

Für die Spring-Integration benötigen wir die Abhängigkeit vonspring-jade4j: 


    de.neuland-bfi
    spring-jade4j
    1.2.5

7.2. Federkonfiguration

UmJade4j mit Spring zu verwenden, müssen wir eineSpringTemplateLoader-Bean definieren, die den Speicherort der Vorlagen konfiguriert, sowie eineJadeConfiguration-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;
    }
}

Als nächstes benötigen wir die üblicheViewResolver-Bohne, in diesem Fall vom TypJadeViewResolver: 

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

7.3. Jade4j Vorlagen

Jade4j Vorlagen zeichnen sich durch eine benutzerfreundliche Whitespace-sensitive Syntax aus: 

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")

Das Projekt bietet auch ein sehr nützlichesinteractive documentation, in dem Sie die Ausgabe Ihrer Vorlage beim Schreiben anzeigen können.

Spring Boot bietet keinenJade4j-Starter, daher müssten wir in einemBoot-Projekt dieselbe Federkonfiguration wie oben definiert hinzufügen.

8. Andere Template-Engines

Neben den bisher beschriebenen Template-Engines stehen noch einige weitere zur Verfügung, die verwendet werden können.

Lassen Sie uns einige davon kurz betrachten.

Velocity ist eine ältere Template-Engine, die sehr komplex ist, aber den Nachteil hat, dass Spring ihre Verwendung seit Version 4.3 nicht mehr unterstützt.

JMustache ist eine Vorlagen-Engine, die mithilfe der Abhängigkeit vonspring-boot-starter-mustacheeinfach in eine Spring Boot-Anwendung integriert werden kann.

Pebble enthält Unterstützung für Spring undSpring Boot in seinen Bibliotheken.

Andere Vorlagenbibliotheken wieHandlebars oderReact, die auf einerJSR-223-Skript-Engine wieNashorn, ausgeführt werden, können ebenfalls verwendet werden.

9. Fazit

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

Und wie immer kann der vollständige Quellcode der Beispieleover on GitHub gefunden werden.

Related