Moteurs de modèles dans Groovy

1. Vue d'ensemble

Dans ce didacticiel d'introduction, nous explorerons le concept de moteurs de modèles dans Groovy.

Dans Groovy, nous pouvons utiliser GString s pour générer facilement du texte dynamique. Cependant, les moteurs de modèles offrent une meilleure façon de gérer le texte dynamique à l'aide de modèles statiques.

Ces modèles sont pratiques pour définir des modèles statiques pour diverses notifications telles que les SMS et les e-mails.

2. Qu'est-ce que TemplateEngine de Groovy ?

TemplateEngine de Groovy est une classe abstraite qui contient la méthode createTemplate .

Tous les moteurs d' infrastructure de modèle disponibles dans Groovy étendent TemplateEngine et implémentent createTemplate. En outre, chaque moteur renvoie l' objet d'interface Template .

L' interface Template a une méthode make , qui prend une carte pour la liaison des variables. Par conséquent, il doit être implémenté par chaque framework de modèle.

Discutons de la fonctionnalité et du comportement de tous les frameworks de modèles disponibles dans Groovy.

3. SimpleTemplateEngine

Le SimpleTemplateEngine génère du texte dynamique à l' aide chaîne interpolation et scriptlets. Ce moteur est très utile pour les notifications simples comme les SMS et les e-mails texte simples.

Par exemple:

def smsTemplate = 'Dear , Thanks for reading our Article. ${signature}' def bindMap = [user: "Norman", signature: "Baeldung"] def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(bindMap) assert smsText.toString() == "Dear Norman, Thanks for reading our Article. Baeldung"

4. StreamingTemplateEngine

Dans un sens général, StreamingTemplateEngine fonctionne de la même manière que SimpleTemplateEngine. Cependant, en interne, il utilise des fermetures inscriptibles pour générer un modèle.

Pour la même raison, il présente des avantages lorsque vous travaillez sur des chaînes plus grandes (> 64K). Par conséquent, il est plus efficace que SimpleTemplateEngine.

Écrivons un exemple rapide pour générer un contenu d'e-mail dynamique à l'aide d'un modèle statique.

Tout d'abord, nous allons créer un modèle d' article statique

Dear <% out <, Please read the requested article below. <% out < From, <% out <

Ici, nous utilisons scriptlets pour le texte dynamique et sur de l'écrivain.

Maintenant, nous allons générer le contenu d'un e-mail à l'aide de StreamingTemplateEngine :

def articleEmailTemplate = new File('src/main/resources/articleEmail.template') def bindMap = [user: "Norman", signature: "Baeldung"] bindMap.articleText = """1. Overview This is a tutorial article on Template Engines...""" //can be a string larger than 64k def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(bindMap) assert articleEmailText.toString() == """Dear Norman, Please read the requested article below. 1. Overview This is a tutorial article on Template Engines... From, Baeldung"""

5. GStringTemplateEngine

Comme son nom l'indique, GStringTemplateEngine utilise GString pour générer du texte dynamique à partir de modèles statiques.

Tout d'abord, écrivons un modèle d' e-mail simple en utilisant GString :

Dear $user, Thanks for subscribing our services. ${signature}

Nous allons maintenant utiliser GStringTemplateEngine pour créer du contenu dynamique:

def emailTemplate = new File('src/main/resources/email.template') def emailText = new GStringTemplateEngine().createTemplate(emailTemplate).make(bindMap) 

6. XmlTemplateEngine

Le XmlTemplateEngine est utile lorsque nous voulons créer des sorties XML dynamiques. Il nécessite un schéma XML en entrée et autorise deux balises spéciales, pour injecter un script et pour injecter une expression.

Par exemple, convertissons le modèle d' e - mail déjà discuté en XML:

def emailXmlTemplate = ''' def emailContent = "Thanks for subscribing our services." Dear ${user} emailContent ${signature} ''' def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(bindMap)

Par conséquent, l' emailXml aura un rendu XML et le contenu sera:

 Dear Norman Thanks for subscribing our services. Baeldung 

Il est intéressant de noter que la sortie XML est indentée et embellie par le framework de modèle.

7. MarkupTemplateEngine

Ce framework de modèle est un package complet pour générer du HTML et d'autres langages de balisage.

En outre, il utilise un langage spécifique au domaine pour traiter les modèles et est le plus optimisé parmi tous les frameworks de modèles disponibles dans Groovy.

7.1. HTML

Écrivons un exemple rapide de rendu HTML pour le modèle d' e - mail déjà discuté :

def emailHtmlTemplate = """ html { head { title('Service Subscription Email') } body { p('Dear Norman') p('Thanks for subscribing our services.') p('Baeldung') } }""" def emailHtml = new MarkupTemplateEngine().createTemplate(emailHtmlTemplate).make()

Par conséquent, le contenu de emailHtml sera:

Service Subscription Email 

Dear Norman

Thanks for subscribing our services.

Baeldung

7.2. XML

De même, nous pouvons rendre XML:

def emailXmlTemplate = """ xmlDeclaration() xs{ email { greet('Dear Norman') content('Thanks for subscribing our services.') signature('Baeldung') } }""" def emailXml = new MarkupTemplateEngine().createTemplate(emailXmlTemplate).make()

Par conséquent, le contenu de emailXml sera:

 Dear NormanThanks for subscribing our services. Baeldung

7.3. ModèleConfiguration

Notez que contrairement à XmlTemplateEngine , la sortie du modèle de ce framework n'est pas indentée et embellie par elle-même.

Pour une telle configuration, nous utiliserons la classe TemplateConfiguration :

TemplateConfiguration config = new TemplateConfiguration() config.autoIndent = true config.autoEscape = true config.autoNewLine = true def templateEngine = new MarkupTemplateEngine(config)

7.4. Internationalisation

En outre, la propriété locale de TemplateConfiguration est disponible pour activer la prise en charge de l'internationalisation.

Tout d'abord, nous allons créer un fichier de modèle statique email.tpl et y copier la chaîne emailHtmlTemplate déjà décrite . Cela sera traité comme le modèle par défaut.

De même, nous créerons des fichiers de modèle basés sur les paramètres régionaux tels que email_ja_JP.tpl pour le japonais, email_fr_FR.tpl pour le français, etc.

Finally, all we need is to set the locale in the TemplateConfiguration object:

config.locale = Locale.JAPAN

Hence, the corresponding locale-based template will be picked.

8. Conclusion

In this article, we've seen various template frameworks available in Groovy.

We can leverage these handy template engines to generate dynamic text using static templates. Therefore, they can be helpful in the dynamic generation of various kinds of notifications or on-screen messages and errors.

As usual, the code implementations of this tutorial are available on the GitHub project.