Motori modello per la primavera

1. Panoramica

Il framework Web Spring è costruito attorno al pattern MVC (Model-View-Controller), che semplifica la separazione dei problemi in un'applicazione. Ciò consente la possibilità di utilizzare diverse tecnologie di visualizzazione, dalla consolidata tecnologia JSP a una varietà di motori di modelli.

In questo articolo, daremo uno sguardo ai principali motori di template che possono essere usati con Spring, alla loro configurazione ed esempi di utilizzo.

2. Spring View Technologies

Dato che le preoccupazioni in un'applicazione Spring MVC sono nettamente separate, il passaggio da una tecnologia di visualizzazione a un'altra è principalmente una questione di configurazione.

Per eseguire il rendering di ogni tipo di visualizzazione, è necessario definire un bean ViewResolver corrispondente a ciascuna tecnologia. Ciò significa che possiamo quindi restituire i nomi delle viste dai metodi di mappatura @Controller nello stesso modo in cui di solito restituiamo i file JSP.

Nelle sezioni seguenti, esamineremo tecnologie più tradizionali come Java Server Pages , nonché i principali motori di modelli che possono essere utilizzati con Spring: Thymeleaf , Groovy , FreeMarker, Jade.

Per ciascuno di questi, esamineremo la configurazione necessaria sia in un'applicazione Spring standard che in un'applicazione creata utilizzando Spring Boot .

3. Java Server Pages

JSP è una delle tecnologie di visualizzazione più popolari per le applicazioni Java ed è supportata da Spring out-of-the-box. Per il rendering dei file JSP, un tipo di bean ViewResolver comunemente utilizzato è InternalResourceViewResolver :

@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; } }

Successivamente, possiamo iniziare a creare file JSP nella posizione / WEB-INF / views :

    User Registration    Email:   Password:      

Se stiamo aggiungendo i file a un'applicazione Spring Boot , invece che nella classe ApplicationConfiguration , possiamo definire le seguenti proprietà in un file application.properties :

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

In base a queste proprietà, Spring Boot configurerà automaticamente il ViewResolver necessario .

4. Foglia di timone

Thymeleaf è un motore di modelli Java in grado di elaborare file HTML, XML, testo, JavaScript o CSS. A differenza di altri motori di modelli, Thymeleaf consente di utilizzare i modelli come prototipi, il che significa che possono essere visualizzati come file statici.

4.1. Dipendenze di Maven

Per integrare Thymeleaf con Spring, dobbiamo aggiungere le dipendenze thymeleaf e thymeleaf-spring4 :

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

Se abbiamo un progetto Spring 4, allora dobbiamo aggiungere thymeleaf-spring4 .

4.2. Configurazione a molla

Successivamente, è necessario aggiungere la configurazione che richiede un bean SpringTemplateEngine , oltre a un bean TemplateResolver che specifica la posizione e il tipo dei file di visualizzazione.

Lo SpringResourceTemplateResolver è integrato con meccanismo di risoluzione delle risorse di primavera:

@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; } }

Inoltre, abbiamo bisogno di un bean ViewResolver di tipo ThymeleafViewResolver :

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

4.3. Modelli di foglia di timone

Ora possiamo aggiungere un file HTML nella posizione WEB-INF / views :

   User Registration    Email: Password:    

I modelli Thymeleaf sono molto simili nella sintassi ai modelli HTML.

Alcune delle funzionalità disponibili quando si utilizza Thymeleaf in un'applicazione Spring sono:

    • supporto per la definizione del comportamento delle forme
    • legare gli input del modulo ai modelli di dati
    • convalida per gli input del modulo
    • visualizzazione dei valori dalle sorgenti dei messaggi
    • rendering di frammenti di modelli

Puoi leggere ulteriori informazioni sull'utilizzo dei modelli Thymeleaf nel nostro articolo Thymeleaf in Spring MVC.

4.4. Foglia di timone in Spring Boot

Spring Boot fornirà la configurazione automatica per Thymeleaf aggiungendo la dipendenza spring-boot-starter-thymeleaf :

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

Non è necessaria alcuna configurazione esplicita. Per impostazione predefinita, i file HTML devono essere inseriti nella posizione delle risorse / modelli .

5. FreeMarker

FreeMarker è un motore di modelli basato su Java creato da Apache Software Foundation . Può essere utilizzato per generare pagine Web, ma anche codice sorgente, file XML, file di configurazione, e-mail e altri formati basati su testo.

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 è un motore di modelli che può essere facilmente integrato in un'applicazione Spring Boot utilizzando la dipendenza spring-boot-starter-mustache .

Pebble contiene il supporto per Spring e Spring Boot all'interno delle sue librerie.

È possibile utilizzare anche altre librerie di modelli come Handlebars o React , in esecuzione su un motore di script JSR-223 come Nashorn .

9. Conclusione

In questo articolo, abbiamo esaminato alcuni dei motori di template più popolari per le applicazioni web Spring.

E, come sempre, il codice sorgente completo degli esempi può essere trovato su GitHub.