Guide de Moustache avec Spring Boot

1. Vue d'ensemble

Dans cet article, nous nous concentrerons sur l'utilisation des modèles Moustache pour produire du contenu HTML dans les applications Spring Boot.

C'est unlogic-less template engine for creating dynamic content, qui est populaire en raison de sa simplicité.

Si vous souhaitez découvrir les bases, consultez notre article surintroduction to Mustache.

2. Dépendance Maven

Pour pouvoir utiliser Moustache avec Spring Boot, nous devons ajouter lesdedicated Spring Boot starter à nospom.xml:


    org.springframework.boot
    spring-boot-starter-mustache


    org.springframework.boot
    spring-boot-starter-web

De plus, nous avons besoin de la dépendancespring-boot-starter-web.

3. Création de modèles

Montrons un exemple et créons une application MVC simple à l'aide de Spring-Boot qui diffusera des articles sur une page Web.

Écrivons le premier modèle pour le contenu de l'article:


    {{#articles}}
    {{title}}
    {{publishDate}}
    {{author}}
    {{body}}
    {{/articles}}

Nous enregistrerons ce fichier HTML, disonsarticle.html, aet le référencerons dans nosindex.html:


    {{>layout/article}}

Ici, lelayout est un sous-répertoire, et learticle est le nom de fichier du fichier modèle.

Notez que l'extension de fichier de modèle de moustache par défaut est désormais.mustache. Nous pouvons remplacer cette configuration par une propriété:

spring.mustache.suffix:.html

4. Manette

Écrivons maintenant le contrôleur de diffusion des articles:

@GetMapping("/article")
public ModelAndView displayArticle(Map model) {

    List articles = IntStream.range(0, 10)
      .mapToObj(i -> generateArticle("Article Title " + i))
      .collect(Collectors.toList());

    model.put("articles", articles);

    return new ModelAndView("index", model);
}

Le contrôleur renvoie une liste d'articles à restituer sur la page. Dans le modèle d'article, la balisearticles commençant par # et se terminant par /, s'occupe de la liste.

Cela va parcourir le modèle passé et afficher chaque élément séparément, comme dans un tableau HTML:

 {{#articles}}...{{/articles}}

La méthodegenerateArticle() crée une instanceArticle avec des données aléatoires.

Notez que les clés du modèle d'article, renvoyées par le contrôleur, doivent être identiques à celles des balises de modèlearticle.

Maintenant, testons notre application:

@Test
public void givenIndexPage_whenContainsArticle_thenTrue() {

    ResponseEntity entity
      = this.restTemplate.getForEntity("/article", String.class);

    assertTrue(entity.getStatusCode()
      .equals(HttpStatus.OK));
    assertTrue(entity.getBody()
      .contains("Article Title 0"));
}

Nous pouvons également tester l'application en la déployant avec:

mvn spring-boot:run

Une fois déployé, nous pouvons atteindrelocalhost:8080/article, et nous afficherons nos articles:

5. Gestion des valeurs par défaut

Dans un environnement Moustache, si nous ne fournissons pas de valeur pour un espace réservé, lesMustacheException seront lancés avec un message“No method or field with name ”variable-name …”.

Pour éviter de telles erreurs, il est préférable de fournir une valeur globale par défaut à tous les espaces réservés:

@Bean
public Mustache.Compiler mustacheCompiler(
  Mustache.TemplateLoader templateLoader,
  Environment environment) {

    MustacheEnvironmentCollector collector
      = new MustacheEnvironmentCollector();
    collector.setEnvironment(environment);

    return Mustache.compiler()
      .defaultValue("Some Default Value")
      .withLoader(templateLoader)
      .withCollector(collector);
}

6. Moustache avec Spring MVC

Voyons maintenant comment intégrer Spring MVC si nous décidons de ne pas utiliser Spring Boot. Tout d'abord, ajoutons la dépendance:


    com.github.sps.mustache
    mustache-spring-view
    1.4

Le dernier a pu être trouvéhere.

Ensuite, nous devons configurerMustacheViewResolver au lieu desInternalResourceViewResolver de Spring:

@Bean
public ViewResolver getViewResolver(ResourceLoader resourceLoader) {
    MustacheViewResolver mustacheViewResolver
      = new MustacheViewResolver();
    mustacheViewResolver.setPrefix("/WEB-INF/views/");
    mustacheViewResolver.setSuffix("..mustache");
    mustacheViewResolver.setCache(false);
    MustacheTemplateLoader mustacheTemplateLoader
      = new MustacheTemplateLoader();
    mustacheTemplateLoader.setResourceLoader(resourceLoader);
    mustacheViewResolver.setTemplateLoader(mustacheTemplateLoader);
    return mustacheViewResolver;
}

Nous avons juste besoin de configurer lessuffix, où nos templates sont stockés,prefix l'extension de nos templates, et lestemplateLoader, qui seront responsables du chargement des templates.

7. Conclusion

Dans ce rapide tutoriel, nous avons étudié l'utilisation de modèles Moustache avec Spring Boot, le rendu d'une collection d'éléments dans l'interface utilisateur et la fourniture de valeurs par défaut aux variables pour éviter les erreurs.

Enfin, nous avons expliqué comment l'intégrer à Spring, en utilisantMustacheViewResolver.

Comme toujours, le code source est disponibleover on GitHub.

TOC

Guide de Moustache avec Spring Boot