Groovy - Moteurs de modèles

Le moteur de template de Groovy fonctionne comme un publipostage (l'ajout automatique de noms et d'adresses d'une base de données aux lettres et enveloppes afin de faciliter l'envoi de courrier, notamment publicitaire, à de nombreuses adresses) mais il est beaucoup plus général.

Modèles simples dans les chaînes

Si vous prenez l'exemple simple ci-dessous, nous définissons d'abord une variable de nom contenant la chaîne «Groovy». Dans l'instruction println, nous utilisons $ symbol pour définir un paramètre ou un modèle dans lequel une valeur peut être insérée.

def name = "Groovy" 
println "This Tutorial is about ${name}"

Si le code ci-dessus est exécuté en groovy, la sortie suivante sera affichée. La sortie montre clairement que le $ name a été remplacé par la valeur qui a été assignée par l'instruction def.

Moteur de modèle simple

Voici un exemple de SimpleTemplateEngine qui vous permet d'utiliser des scriptlets et des expressions EL de type JSP dans votre modèle afin de générer du texte paramétré. Le moteur de création de modèles vous permet de lier une liste de paramètres et leurs valeurs afin qu'ils puissent être remplacés dans la chaîne contenant les espaces réservés définis.

def text ='This Tutorial focuses on $TutorialName. In this tutorial you will learn 

about $Topic'  

def binding = ["TutorialName":"Groovy", "Topic":"Templates"]  
def engine = new groovy.text.SimpleTemplateEngine() 
def template = engine.createTemplate(text).make(binding) 

println template

Si le code ci-dessus est exécuté en groovy, la sortie suivante sera affichée.

Utilisons maintenant la fonctionnalité de création de modèles pour un fichier XML. Dans un premier temps, ajoutons le code suivant à un fichier appelé Student.template. Dans le fichier suivant, vous remarquerez que nous n'avons pas ajouté les valeurs réelles des éléments, mais des espaces réservés. Ainsi, $ name, $ is et $ subject sont tous placés comme des espaces réservés qui devront être remplacés lors de l'exécution.

<Student> 
   <name>${name}</name> 
   <ID>${id}</ID> 
   <subject>${subject}</subject> 
</Student>

Ajoutons maintenant notre code de script Groovy pour ajouter la fonctionnalité qui peut être utilisée pour remplacer le modèle ci-dessus par des valeurs réelles. Les choses suivantes doivent être notées à propos du code suivant.

  • Le mappage des espaces réservés aux valeurs réelles est effectué via une liaison et un SimpleTemplateEngine. La liaison est une carte avec les espaces réservés comme clés et les remplacements comme valeurs.

import groovy.text.* 
import java.io.* 

def file = new File("D:/Student.template") 
def binding = ['name' : 'Joe', 'id' : 1, 'subject' : 'Physics']
				  
def engine = new SimpleTemplateEngine() 
def template = engine.createTemplate(file) 
def writable = template.make(binding) 

println writable

Si le code ci-dessus est exécuté en groovy, la sortie suivante sera affichée. À partir de la sortie, on peut voir que les valeurs sont remplacées avec succès dans les espaces réservés appropriés.

<Student> 
   <name>Joe</name> 
   <ID>1</ID> 
   <subject>Physics</subject> 
</Student>

StreamingTemplateEngine

Le moteur StreamingTemplateEngine est un autre moteur de création de modèles disponible dans Groovy. C'est un peu équivalent à SimpleTemplateEngine, mais crée le modèle à l'aide de fermetures inscriptibles, ce qui le rend plus évolutif pour les grands modèles. Plus précisément, ce moteur de modèle peut gérer des chaînes de plus de 64 Ko.

Voici un exemple d'utilisation de StreamingTemplateEngine -

def text = '''This Tutorial is <% out.print TutorialName %> The Topic name 

is ${TopicName}''' 
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)
  
def binding = [TutorialName : "Groovy", TopicName  : "Templates",]
String response = template.make(binding) 
println(response)

Si le code ci-dessus est exécuté en groovy, la sortie suivante sera affichée.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

Le XmlTemplateEngine est utilisé dans les scénarios de création de modèles dans lesquels la source du modèle et la sortie attendue sont destinées à être XML. Les modèles utilisent les notations normales $ {expression} et $ variable pour insérer une expression arbitraire dans le modèle.

Voici un exemple d'utilisation de XMLTemplateEngine.

def binding = [StudentName: 'Joe', id: 1, subject: 'Physics'] 
def engine = new groovy.text.XmlTemplateEngine() 

def text = '''\
   <document xmlns:gsp='http://groovy.codehaus.org/2005/gsp'>
      <Student>
         <name>${StudentName}</name>
         <ID>${id}</ID>
         <subject>${subject}</subject>
      </Student>
   </document> 
''' 

def template = engine.createTemplate(text).make(binding) 
println template.toString()

Si le code ci-dessus est exécuté en groovy, la sortie suivante sera affichée

Joe
    
    
   1
    
    
   Physics