TOC

Moteurs de modèles pour le printemps

Moteurs de modèle pour le printemps

1. Vue d'ensemble

L'infrastructure Web Spring est construite autour du modèle MVC (Model-View-Controller), ce qui facilite la séparation des problèmes dans une application. Cela permet d'utiliser différentes technologies d'affichage, de la technologie JSP bien établie à divers moteurs de modèles.

Dans cet article, nous allons examiner les principaux moteurs de modèles qui peuvent être utilisés avec Spring, leur configuration et des exemples d'utilisation.

2. Technologies Spring View

Étant donné que les problèmes rencontrés dans une application Spring MVC sont clairement séparés, le passage d'une technologie d'affichage à une autre est essentiellement une question de configuration.

Pour rendre chaque type de vue, nous devons définir un beanViewResolver 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 telles queJava 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 deSpring Boot.

3. Java Server Pages

JSP est l’une des technologies de visualisation les plus populaires pour les applications Java. Il est pris en charge par Spring immédiatement. Pour le rendu des fichiers JSP, un type couramment utilisé de beanViewResolver estInternalResourceViewResolver: 

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

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

    
        
        User Registration
    
    
        
            Email: 
            
            Password:

Si nous ajoutons les fichiers à une applicationSpring Boot, alors au lieu de dans la classeApplicationConfiguration, nous pouvons définir les propriétés suivantes dans un fichierapplication.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 lesViewResolver nécessaires.

4. Thymeleaf

Thymeleaf est un moteur de template Java capable de traiter des fichiers HTML, XML, texte, JavaScript ou CSS. Contrairement aux 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 Maven

Pour intégrerThymeleaf avec Spring, nous devons ajouter les dépendancesthymeleaf etthymeleaf-spring4: 


    org.thymeleaf
    thymeleaf
    3.0.7.RELEASE


    org.thymeleaf
    thymeleaf-spring4
    3.0.7.RELEASE

Si nous avons un projet Spring 3, nous devons ajouterthymeleaf-spring3.

4.2. Configuration du ressort

Ensuite, nous devons ajouter la configuration qui nécessite un beanSpringTemplateEngine, ainsi qu'un beanTemplateResolver qui spécifie l'emplacement et le type des fichiers de vue.

LeSpringResourceTemplateResolver est intégré au mécanisme de résolution des ressources de Spring: 

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

De plus, nous avons besoin d'un beanViewResolver de typeThymeleafViewResolver: 

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

4.3. ModèlesThymeleaf

Maintenant, nous pouvons ajouter un fichier HTML à l'emplacementWEB-INF/views: 


    
        
        User Registration
    
    
        

            Email:
            Password:

La syntaxe des modèlesThymeleaf est très similaire à celle des modèles HTML.

Certaines des fonctionnalités disponibles lors de l'utilisation deThymeleaf dans une application Spring sont:

  • aide à la définition du comportement des formulaires

  • relier les entrées de formulaire aux modèles de données

  • validation pour les entrées de formulaire

  • afficher les valeurs des sources de message

  • rendu des fragments de modèle

Vous pouvez en savoir plus sur l'utilisation des modèlesThymeleaf dans notre articleThymeleaf in Spring MVC.

4.4. Thymeleaf enSpring Boot

Spring Boot fournira une configuration automatique pourThymeleaf en ajoutant la dépendancespring-boot-starter-thymeleaf: 


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

Aucune configuration explicite n'est nécessaire. Par défaut, les fichiers HTML doivent être placés à l'emplacementresources/templates.

5. FreeMarker

FreeMarker est un moteur de template basé sur Java construit par lesApache Software Foundation. Il peut être utilisé pour générer des pages Web, mais également du code source, des fichiers XML, des fichiers de configuration, des courriels et d’autres formats textuels.

La génération se fait sur la base de fichiers modèles écrits à l'aide desFreeMarker Template Language.

5.1. Dépendances Maven

Pour commencer à utiliser les modèles dans notre projet, nous avons besoin de la dépendancefreemarker: 


    org.freemarker
    freemarker
    2.3.23

Pour l'intégration Spring, nous avons également besoin de la dépendancespring-context-support: 


    org.springframework
    spring-context-support
    4.3.10.RELEASE

5.2. Configuration du ressort

L'intégration deFreeMarker avec Spring MVC nécessite de définir un beanFreemarkerConfigurer qui spécifie l'emplacement des fichiers de modèle: 

@Configuration
@EnableWebMvc
public class FreemarkerConfiguration {

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

Ensuite, nous devons définir un beanViewResolver approprié de typeFreeMarkerViewResolver: 

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

5.3. ModèlesFreeMarker

Nous pouvons créer un modèle HTML en utilisantFreeMarker à l'emplacementWEB-INF/views: 

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

    
        
        User Registration
    
    
        

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

Dans l'exemple ci-dessus, nous avons importé un ensemble de macros définies par Spring pour travailler avec des formulaires enFreeMarker, y compris la liaison des entrées de formulaire aux modèles de données.

En outre, leFreeMarker Template Language contient un grand nombre de balises, de directives et d'expressions pour travailler avec des collections, des structures de contrôle de flux, des opérateurs logiques, des chaînes de formatage et d'analyse, des nombres et bien d'autres fonctionnalités.

5.4. FreeMarker enSpring Boot

Dans une applicationSpring Boot, nous pouvons simplifier la configuration nécessaire en utilisant la dépendancespring-boot-starter-freemarker: 


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

Ce démarreur ajoute la configuration automatique nécessaire. Tout ce que nous devons faire est de commencer à placer nos fichiers de modèle dans le dossierresources/templates.

6. Groovy

Les vues Spring MVC peuvent également être générées à l'aide desGroovy Markup Template Engine. Ce moteur est basé sur une syntaxe de générateur et peut être utilisé pour générer tout format de texte.

6.1. Dépendances Maven

La dépendancegroovy-templates doit être ajoutée à nospom.xml: 


    org.codehaus.groovy
    groovy-templates
    2.4.12

6.2. Configuration du ressort

L'intégration desMarkup Template Engine avec Spring MVC nécessite de définir un beanGroovyMarkupConfigurer et unViewResolver de typeGroovyMarkupViewResolver: 

@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. ModèlesGroovy Markup

Les modèles sont écrits dans le langage Groovy et présentent plusieurs caractéristiques:

  • ils sont compilés en bytecode

  • ils contiennent un support pour les fragments et les mises en page

  • ils fournissent un soutien pour l'internationalisation

  • le rendu est rapide

Créons un modèle Groovy pour notre formulaire «Enregistrement d’utilisateur», qui comprend des liaisons de données: 

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

Spring Boot contient la configuration automatique pour lesGroovy Template Engine, qui est ajoutée en incluant la dépendancespring-boot-starter-groovy-templates: 


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

L'emplacement par défaut des modèles est/resources/templates.

7. Jade4j

Jade4j est l'implémentation Java du moteur de templatePug (à l'origine connu sous le nom deJade) pour Javascript. Les modèlesJade4j peuvent être utilisés pour générer des fichiers HTML.

7.1. Dépendances Maven

Pour l'intégration Spring, nous avons besoin de la dépendancespring-jade4j: 


    de.neuland-bfi
    spring-jade4j
    1.2.5

7.2. Configuration du ressort

Pour utiliserJade4j avec Spring, nous devons définir un beanSpringTemplateLoader qui configure l'emplacement des modèles, ainsi qu'un beanJadeConfiguration: 

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

Ensuite, nous avons besoin du beanViewResolver habituel, dans ce cas de typeJadeViewResolver: 

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

7.3. ModèlesJade4j

Les modèlesJade4j sont caractérisés par une syntaxe facile à utiliser et sensible aux espaces: 

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

Le projet fournit également uninteractive documentation très utile, où vous pouvez afficher la sortie de votre modèle au fur et à mesure que vous l'écrivez.

Spring Boot ne fournit pas de démarreurJade4j, donc dans un projetBoot, nous devrions ajouter la même configuration Spring que celle définie ci-dessus.

8. Autres moteurs de modèles

Outre les moteurs de gabarit décrits jusqu'à présent, il en existe un bon nombre d'autres qui peuvent être utilisés.

Passons brièvement en revue quelques-uns des.

Velocity est un moteur de template plus ancien, qui est très complexe mais présente l'inconvénient que Spring a abandonné son utilisation depuis la version 4.3.

JMustache est un moteur de modèle qui peut être facilement intégré dans une application Spring Boot en utilisant la dépendancespring-boot-starter-mustache.

Pebble contient le support pour Spring etSpring Boot dans ses bibliothèques.

D'autres bibliothèques de modèles telles queHandlebars ouReact, exécutées sur un moteur de scriptJSR-223 tel queNashorn, peuvent également être utilisées.

9. Conclusion

Dans cet article, nous avons passé en revue certains des moteurs de gabarit les plus populaires pour les applications Web Spring.

Et, comme toujours, le code source complet des exemples peut être trouvéover on GitHub.

Related