1. Vue d'ensemble
Le framework Web Spring est construit autour du modèle MVC (Model-View-Controller), ce qui facilite la séparation des préoccupations dans une application. Cela permet d'utiliser différentes technologies de visualisation, de la technologie JSP bien établie à une variété de moteurs de modèles.
Dans cet article, nous allons examiner les principaux moteurs de modèles pouvant être utilisés avec Spring, leur configuration et des exemples d'utilisation.
2. Technologies Spring View
Étant donné que les préoccupations d'une application Spring MVC sont clairement séparées, le passage d'une technologie d'affichage à une autre est principalement une question de configuration.
Pour rendre chaque type de vue, nous devons définir un bean ViewResolver correspondant à chaque technologie. Cela signifie que nous pouvons ensuite renvoyer les noms de vue à partir des méthodes de mappage @Controller de la même manière que nous renvoyons habituellement les fichiers JSP.
Dans les sections suivantes, nous allons passer en revue des technologies plus traditionnelles comme Java Server Pages , ainsi que les principaux moteurs de modèles pouvant être utilisés avec Spring: Thymeleaf , Groovy , FreeMarker, Jade.
Pour chacun d'entre eux, nous allons passer en revue la configuration nécessaire à la fois dans une application Spring standard et une application construite à l'aide de Spring Boot .
3. Pages du serveur Java
JSP est l'une des technologies d'affichage les plus populaires pour les applications Java, et il est pris en charge par Spring prêt à l'emploi. Pour le rendu des fichiers JSP, un type couramment utilisé de bean ViewResolver est 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; } }
Ensuite, nous pouvons commencer à créer des fichiers JSP à l' emplacement / WEB-INF / views :
User Registration Email: Password:
Si nous ajoutons les fichiers à une application Spring Boot , au lieu de dans la classe ApplicationConfiguration , nous pouvons définir les propriétés suivantes dans un fichier application.properties :
spring.mvc.view.prefix: /WEB-INF/views/ spring.mvc.view.suffix: .jsp
Sur la base de ces propriétés, Spring Boot configurera automatiquement le ViewResolver nécessaire .
4. Thymeleaf
Thymeleaf est un moteur de template Java capable de traiter des fichiers HTML, XML, texte, JavaScript ou CSS. Contrairement à d'autres moteurs de modèles, Thymeleaf permet d'utiliser des modèles comme prototypes, ce qui signifie qu'ils peuvent être visualisés comme des fichiers statiques.
4.1. Dépendances de Maven
Pour intégrer Thymeleaf avec Spring, nous devons ajouter les dépendances thymeleaf et thymeleaf-spring4 :
org.thymeleaf thymeleaf 3.0.11.RELEASE org.thymeleaf thymeleaf-spring5 3.0.11.RELEASE
Si nous avons un projet Spring 4, nous devons ajouter thymeleaf-spring4 .
4.2. Configuration du ressort
Ensuite, nous devons ajouter la configuration qui nécessite un bean SpringTemplateEngine , ainsi qu'un bean TemplateResolver qui spécifie l'emplacement et le type des fichiers de vue.
Le SpringResourceTemplateResolver est intégré avec le mécanisme de résolution des ressources de printemps:
@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; } }
Nous avons également besoin d'un bean ViewResolver de type ThymeleafViewResolver :
@Bean public ThymeleafViewResolver thymeleafViewResolver() { ThymeleafViewResolver viewResolver = new ThymeleafViewResolver(); viewResolver.setTemplateEngine(templateEngine()); return viewResolver; }
4.3. Modèles Thymeleaf
Maintenant, nous pouvons ajouter un fichier HTML à l' emplacement WEB-INF / views :
User Registration Email: Password:
Les modèles Thymeleaf ont une syntaxe très similaire aux modèles HTML.
Certaines des fonctionnalités disponibles lors de l'utilisation de Thymeleaf dans une application Spring sont:
-
- prise en charge de la définition du comportement des formulaires
- liaison des entrées de formulaire aux modèles de données
- validation des entrées de formulaire
- affichage des valeurs des sources de messages
- rendu des fragments de modèle
You can read more about using Thymeleaf templates in our article Thymeleaf in Spring MVC.
4.4. Thymeleaf in Spring Boot
Spring Boot will provide auto-configuration for Thymeleaf by adding the spring-boot-starter-thymeleaf dependency:
org.springframework.boot spring-boot-starter-thymeleaf 2.3.3.RELEASE
No explicit configuration is necessary. By default, HTML files should be placed in the resources/templates location.
5. FreeMarker
FreeMarker is a Java-based template engine built by the Apache Software Foundation. It can be used to generate web pages, but also source code, XML files, configuration files, emails and other text-based formats.
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 est un moteur de modèle qui peut être facilement intégré dans une application Spring Boot en utilisant la dépendance spring-boot-starter-moustache .
Pebble prend en charge Spring et Spring Boot dans ses bibliothèques.
D'autres bibliothèques de modèles telles que Handlebars ou React , exécutées sur un moteur de script JSR-223 tel que Nashorn, peuvent également être utilisées.
9. Conclusion
Dans cet article, nous avons passé en revue certains des moteurs de modèles les plus populaires pour les applications Web Spring.
Et, comme toujours, le code source complet des exemples peut être trouvé sur GitHub.