Mesin Templat di Groovy

1. Gambaran keseluruhan

Dalam tutorial pengenalan ini, kita akan meneroka konsep mesin templat di Groovy.

Di Groovy, kita dapat menggunakan GString untuk menghasilkan teks dinamik dengan mudah. Walau bagaimanapun, mesin templat menyediakan cara yang lebih baik dalam menangani teks dinamik menggunakan templat statik.

Templat ini mudah digunakan dalam menentukan templat statik untuk pelbagai pemberitahuan seperti SMS dan e-mel.

2. Apa itu TemplateEngine Groovy ?

Groovy TemplateEngine adalah kelas abstrak yang mengandungi kaedah createTemplate .

Semua mesin rangka templat yang terdapat di Groovy memperluas TemplateEngine dan melaksanakan createTemplate. Selain itu, setiap enjin mengembalikan objek antara muka Templat .

The template antara muka mempunyai kaedah make , yang mengambil peta untuk pembolehubah terikat. Oleh itu, ia mesti dilaksanakan oleh setiap kerangka templat.

Mari bincangkan fungsi dan tingkah laku semua kerangka templat yang ada di Groovy.

3. SimpleTemplateEngine

The SimpleTemplateEngine menjana teks dinamik menggunakan String interpolasi dan scriptlets. Enjin ini cukup berguna untuk pemberitahuan mudah seperti SMS dan e-mel teks sederhana.

Sebagai contoh:

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

Secara umum, StreamingTemplateEngine berfungsi sama dengan SimpleTemplateEngine. Walau bagaimanapun, secara dalaman ia menggunakan penutupan Boleh tulis untuk menghasilkan templat.

Atas sebab yang sama, ia mempunyai faedah ketika bekerja menggunakan Strings yang lebih besar (> 64K). Oleh itu, ia lebih cekap daripada SimpleTemplateEngine.

Mari tulis contoh ringkas untuk menghasilkan kandungan e-mel dinamik menggunakan templat statik.

Pertama, kami akan membuat templat e-mel artikel statik :

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

Di sini, kami menggunakan skrip untuk teks dinamik dan keluar untuk penulis.

Sekarang, kami akan menghasilkan kandungan e-mel menggunakan 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

Seperti namanya, GStringTemplateEngine menggunakan GString untuk menghasilkan teks dinamik dari templat statik.

Pertama, mari tulis templat e-mel mudah menggunakan GString :

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

Sekarang, kami akan menggunakan GStringTemplateEngine untuk membuat kandungan dinamik:

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

6. XmlTemplateEngine

The XmlTemplateEngine berguna apabila kita ingin membuat output XML dinamik. Ia memerlukan skema XML sebagai input dan membolehkan dua tag khas, untuk menyuntik skrip dan untuk menyuntikkan ungkapan.

Sebagai contoh, mari kita menukar templat e-mel yang sudah dibincangkan ke XML:

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

Oleh itu, emailXml akan diberikan XML, dan kandungannya akan:

 Dear Norman Thanks for subscribing our services. Baeldung 

Sangat menarik untuk diperhatikan bahawa output XML dilekatkan dan diperindah dengan kerangka templat.

7. MarkupTemplateEngine

Kerangka templat ini adalah pakej lengkap untuk menghasilkan HTML dan bahasa markup lain.

Selain itu, ia menggunakan Domain Spesifik Bahasa untuk memproses templat dan merupakan yang paling dioptimumkan di antara semua kerangka templat yang terdapat di Groovy.

7.1. HTML

Mari tulis contoh ringkas untuk membuat HTML untuk templat e-mel yang sudah dibincangkan :

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

Oleh itu, kandungan emailHtml adalah:

Service Subscription Email 

Dear Norman

Thanks for subscribing our services.

Baeldung

7.2. XML

Begitu juga, kita boleh membuat XML:

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

Oleh itu, kandungan emailXml adalah:

 Dear NormanThanks for subscribing our services. Baeldung

7.3. Konfigurasi Templat

Perhatikan bahawa tidak seperti XmlTemplateEngine , keluaran templat kerangka ini tidak dilekatkan dan dicantikkan dengan sendirinya.

Untuk konfigurasi seperti itu, kami akan menggunakan kelas TemplateConfiguration :

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

7.4. Pengantarabangsaan

Selain itu, tempat-tempat kejadian harta TemplateConfiguration disediakan untuk membolehkan sokongan pengantarabangsaan.

Pertama, kami akan membuat fail templat statik email.tpl dan menyalin rentetan emailHtmlTemplate yang telah dibincangkan ke dalamnya. Ini akan dianggap sebagai templat lalai.

Begitu juga, kami akan membuat fail templat berasaskan bahasa seperti email_ja_JP.tpl untuk bahasa Jepun, email_fr_FR.tpl untuk bahasa Perancis, dll.

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.