Template Engines in Groovy

1. Übersicht

In diesem Einführungs-Tutorial werden wir das Konzept der Template-Engines in Groovy untersuchen.

In Groovy können wir GStrings verwenden , um auf einfache Weise dynamischen Text zu generieren. Die Vorlagen-Engines bieten jedoch eine bessere Möglichkeit, dynamischen Text mithilfe statischer Vorlagen zu verarbeiten.

Mit diesen Vorlagen können Sie statische Vorlagen für verschiedene Benachrichtigungen wie SMS und E-Mails definieren.

2. Was ist Groovys TemplateEngine ?

Groovy TemplateEngine ist eine abstrakte Klasse, die enthält Create Methode.

Alle in Groovy verfügbaren Template Framework Engines erweitern TemplateEngine und implementieren createTemplate. Darüber hinaus gibt jede Engine das Vorlagenschnittstellenobjekt zurück .

Die Vorlagenschnittstelle verfügt über eine Methode make , die eine Zuordnung zum Binden von Variablen verwendet. Daher muss es von jedem Template-Framework implementiert werden.

Lassen Sie uns die Funktionalität und das Verhalten aller verfügbaren Vorlagen-Frameworks in Groovy diskutieren.

3. SimpleTemplateEngine

Die SimpleTemplateEngine generiert dynamischen Text mithilfe von String- Interpolation und Scriptlets. Diese Engine ist sehr nützlich für einfache Benachrichtigungen wie SMS und einfache Text-E-Mails.

Zum Beispiel:

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

Im Allgemeinen funktioniert die StreamingTemplateEngine ähnlich wie die SimpleTemplateEngine. Doch intern verwendet es Beschreibbare Schließungen eine Vorlage zu erzeugen.

Aus dem gleichen Grund bietet es Vorteile bei der Arbeit mit größeren Strings (> 64 KB). Daher ist es effizienter als SimpleTemplateEngine.

Lassen Sie uns ein kurzes Beispiel schreiben, um mithilfe einer statischen Vorlage einen dynamischen E-Mail-Inhalt zu generieren.

Zunächst erstellen wir eine statische Artikel-E-Mail- Vorlage:

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

Hier verwenden wir Scriptlets für dynamischen Text und heraus für den Schriftsteller.

Jetzt generieren wir den Inhalt einer E-Mail mit 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

Wie der Name schon sagt, GStringTemplateEngine verwendet Gstring dynamischen Text aus statischen Templates zu generieren.

Schreiben wir zunächst eine einfache E-Mail- Vorlage mit GString :

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

Jetzt verwenden wir GStringTemplateEngine , um dynamischen Inhalt zu erstellen:

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

6. XmlTemplateEngine

Die XmlTemplateEngine ist nützlich, wenn Sie dynamische XML-Ausgaben erstellen möchten. Es erfordert ein XML-Schema als Eingabe und erlaubt zwei spezielle Tags: Skript injizieren und einen Ausdruck injizieren.

Konvertieren wir beispielsweise die bereits besprochene E-Mail- Vorlage in XML:

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

Daher wird in der emailXml XML gerendert, und der Inhalt lautet :

 Dear Norman Thanks for subscribing our services. Baeldung 

Es ist interessant festzustellen, dass die XML-Ausgabe selbst durch das Vorlagenframework eingerückt und verschönert wird.

7. MarkupTemplateEngine

Dieses Vorlagenframework ist ein vollständiges Paket zum Generieren von HTML und anderen Auszeichnungssprachen.

Darüber hinaus verwendet es die domänenspezifische Sprache zur Verarbeitung der Vorlagen und ist das optimierteste aller in Groovy verfügbaren Vorlagen-Frameworks.

7.1. HTML

Schreiben wir ein kurzes Beispiel zum Rendern von HTML für die bereits diskutierte E-Mail- Vorlage:

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

Daher lautet der Inhalt von emailHtml :

Service Subscription Email 

Dear Norman

Thanks for subscribing our services.

Baeldung

7.2. XML

Ebenso können wir XML rendern:

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

Daher lautet der Inhalt von emailXml :

 Dear NormanThanks for subscribing our services. Baeldung

7.3. TemplateConfiguration

Beachten Sie, dass im Gegensatz zu XmlTemplateEngine die Vorlagenausgabe dieses Frameworks nicht von selbst eingerückt und verschönert wird.

Für eine solche Konfiguration verwenden wir die TemplateConfiguration- Klasse:

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

7.4. Internationalisierung

Darüber hinaus ist die Locale- Eigenschaft von TemplateConfiguration verfügbar, um die Unterstützung der Internationalisierung zu ermöglichen.

Zunächst erstellen wir eine statische Vorlagendatei email.tpl und kopieren die bereits besprochene Zeichenfolge emailHtmlTemplate hinein. Dies wird als Standardvorlage behandelt.

Ebenso erstellen wir auf Gebietsschemas basierende Vorlagendateien wie email_ja_JP.tpl für Japanisch, email_fr_FR.tpl für Französisch usw.

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.