Modelli di motori in Groovy

1. Panoramica

In questo tutorial introduttivo, esploreremo il concetto di motori di modelli in Groovy.

In Groovy, possiamo usare GString s per generare facilmente testo dinamico. Tuttavia, i motori dei modelli forniscono un modo migliore per gestire il testo dinamico utilizzando modelli statici.

Questi modelli sono utili per definire modelli statici per varie notifiche come SMS ed e-mail.

2. Cos'è TemplateEngine di Groovy ?

TemplateEngine di Groovy è una classe astratta che contiene il metodo createTemplate .

Tutti i motori di template framework disponibili in Groovy estendono TemplateEngine e implementano createTemplate. Inoltre, ogni motore restituisce l' oggetto dell'interfaccia Template .

L' interfaccia Template ha un metodo make , che accetta una mappa per legare le variabili. Pertanto, deve essere implementato da ogni framework modello.

Discutiamo la funzionalità e il comportamento di tutti i framework di modelli disponibili in Groovy.

3. SimpleTemplateEngine

Il SimpleTemplateEngine genera testo dinamico utilizzando stringa di interpolazione e scriptlet. Questo motore è molto utile per notifiche semplici come SMS e semplici email di testo.

Per esempio:

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

In senso generale, StreamingTemplateEngine funziona in modo simile a SimpleTemplateEngine. Tuttavia, internamente utilizza chiusure scrivibili per generare un modello.

Per lo stesso motivo, offre vantaggi quando si lavora su stringhe più grandi (> 64K). Quindi, è più efficiente di SimpleTemplateEngine.

Scriviamo un rapido esempio per generare un contenuto di posta elettronica dinamico utilizzando un modello statico.

In primo luogo, creeremo un articolo statico Modello di posta elettronica :

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

Qui stiamo usando scriptlet per il testo dinamico e fuori per lo scrittore.

Ora genereremo il contenuto di un'e-mail utilizzando 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

Come suggerisce il nome, GStringTemplateEngine utilizza GString per generare testo dinamico da modelli statici.

Per prima cosa, scriviamo un semplice modello di email usando GString :

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

Ora useremo GStringTemplateEngine per creare contenuto dinamico:

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

6. XmlTemplateEngine

Il XmlTemplateEngine è utile quando vogliamo creare output XML dinamici. Richiede lo schema XML come input e consente due tag speciali, per iniettare script e per iniettare un'espressione.

Ad esempio, convertiamo il modello di posta elettronica già discusso in XML:

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

Quindi, emailXml avrà il rendering XML e il contenuto sarà:

 Dear Norman Thanks for subscribing our services. Baeldung 

È interessante notare che l'output XML è rientrato e abbellito dal framework del modello.

7. MarkupTemplateEngine

Questo framework modello è un pacchetto completo per generare HTML e altri linguaggi di markup.

Inoltre, utilizza il linguaggio specifico del dominio per elaborare i modelli ed è il più ottimizzato tra tutti i framework di modelli disponibili in Groovy.

7.1. HTML

Scriviamo un rapido esempio per eseguire il rendering dell'HTML per il modello di email già discusso :

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

Pertanto, il contenuto di emailHtml sarà:

Service Subscription Email 

Dear Norman

Thanks for subscribing our services.

Baeldung

7.2. XML

Allo stesso modo, possiamo rendere XML:

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

Pertanto, il contenuto di emailXml sarà:

 Dear NormanThanks for subscribing our services. Baeldung

7.3. TemplateConfiguration

Nota che, a differenza di XmlTemplateEngine , l'output del modello di questo framework non è rientrato e abbellito da solo.

Per tale configurazione, useremo la classe TemplateConfiguration :

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

7.4. Internazionalizzazione

Inoltre, la proprietà locale di TemplateConfiguration è disponibile per abilitare il supporto dell'internazionalizzazione.

In primo luogo, creeremo un file modello statico email.tpl e copieremo la stringa emailHtmlTemplate già discussa al suo interno. Questo verrà considerato come il modello predefinito.

Allo stesso modo, creeremo file modello basati sulla locale come email_ja_JP.tpl per il giapponese, email_fr_FR.tpl per il francese, ecc.

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.