Guide de Moustache avec Spring Boot

1. Vue d'ensemble

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

C'est un moteur de modèle sans logique pour créer du contenu dynamique , qui est populaire en raison de sa simplicité.

Si vous souhaitez découvrir les bases, consultez notre article d'introduction à Moustache.

2. Dépendance de Maven

Pour pouvoir utiliser Moustache avec Spring Boot, nous devons ajouter le démarreur Spring Boot dédié à notre pom.xml:

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

De plus, nous avons besoin de la dépendance spring-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 servira des articles sur une page Web.

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

 {{#articles}} 

{{publishDate}}

{{author}}

{{body}}

{{/articles}}

Nous enregistrerons ce fichier HTML, disons article.html, et le référencerons dans notre index.html:

 {{>layout/article}} 

Ici, la mise en page est un sous-répertoire et l' article est le nom de fichier du fichier modèle.

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

spring.mustache.suffix:.html

4. Contrôleur

Maintenant, écrivons le contrôleur pour servir les 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 à rendre sur la page. Dans le modèle d'article, la balise articles commençant par # et se terminant par /, prend en charge la liste.

Cela itérera sur le modèle passé et rendra chaque élément séparément, comme dans un tableau HTML:

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

La méthode generateArticle () crée une instance Article 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 du modèle d' article .

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 frapper localhost: 8080 / article, et nos articles seront répertoriés:

5. Gestion des valeurs par défaut

Dans un environnement Moustache, si nous ne fournissons pas de valeur pour un espace réservé, l' exception MoustacheException sera lancée avec un message «Pas de méthode ou de champ avec le nom» nom-variable… ».

Afin d'é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 peut être trouvé ici.

Ensuite, nous devons configurer MoustacheViewResolver au lieu de InternalResourceViewResolver 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 le suffixe, où nos modèles sont stockés, le préfixe de l'extension de nos modèles, et le templateLoader, qui sera responsable du chargement des modèles.

7. Conclusion

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

Enfin, nous avons expliqué comment l'intégrer à Spring, à l'aide de MustacheViewResolver.

Comme toujours, le code source est disponible sur GitHub.