TOC

Mecanismos de modelo no Groovy

Mecanismos de modelo no Groovy

1. Visão geral

Neste tutorial introdutório, exploraremos o conceito de motores de modelo emGroovy.

No Groovy, podemos usarGStrings para gerar texto dinâmico facilmente. No entanto, os mecanismos de modelo fornecem uma maneira melhor de lidar com texto dinâmico usando modelos estáticos.

Esses modelos são convenientes na definição de modelos estáticos para várias notificações, como SMS e e-mails.

2. O que éTemplateEngine do Groovy?

OTemplateEngine do Groovy é uma classe abstrata que contém o métodocreateTemplate.

Todos os mecanismos de framework de template disponíveis no Groovy estendemTemplateEnginee implementamcreateTemplate. Além disso, cada mecanismo retorna o objeto de interfaceTemplate.

The Template interface has a method make, which takes a map for binding variables. Portanto, deve ser implementado por cada framework de template.

Vamos discutir a funcionalidade e o comportamento de todas as estruturas de modelo disponíveis no Groovy.

3. SimpleTemplateEngine

OSimpleTemplateEngine gera texto dinâmico usando a interpolaçãoString e scriptlets. Esse mecanismo é bastante útil para notificações simples como SMS e e-mails de texto simples.

Por exemplo: 

def smsTemplate = 'Dear <% print user %>, Thanks for reading our Article. ${signature}'
def bindMap = [user: "Norman", signature: "example"]
def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(bindMap)

assert smsText.toString() == "Dear Norman, Thanks for reading our Article. example"

4. StreamingTemplateEngine

Em um sentido geral,StreamingTemplateEngine funciona de maneira semelhante aSimpleTemplateEngine.. No entanto, internamente ele usa fechamentosWritable para gerar um modelo.

Pelo mesmo motivo, possui benefícios ao trabalhar com Strings maiores (> 64K). Portanto, é mais eficiente do queSimpleTemplateEngine.

Vamos escrever um exemplo rápido para gerar um conteúdo de e-mail dinâmico usando um modelo estático.

Em primeiro lugar, criaremos um modelo estáticoarticleEmail: 

Dear <% out << (user) %>,
Please read the requested article below.
<% out << (articleText) %>
From,
<% out << (signature) %>

Aqui, estamos usando scriptlets<% %> para texto dinâmico eout para o escritor.

Agora, vamos gerar o conteúdo de um e-mail usandoStreamingTemplateEngine: 

def articleEmailTemplate = new File('src/main/resources/articleEmail.template')
def bindMap = [user: "Norman", signature: "example"]

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,
example"""

5. GStringTemplateEngine

Como o nome sugere,GStringTemplateEngine usaGString para gerar texto dinâmico a partir de modelos estáticos.

Em primeiro lugar, vamos escrever um modeloemail simples usandoGString: 

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

Agora, usaremosGStringTemplateEngine para criar conteúdo dinâmico: 

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

6. XmlTemplateEngine

OXmlTemplateEngine é útil quando queremos criar saídas XML dinâmicas. Requer o esquema XML como entrada e permite duas tags especiais,<gsp:scriptlet> para injetar script e<gsp:expression> para injetar uma expressão.

Por exemplo, vamos converter o modeloemail já discutido em XML: 

def emailXmlTemplate = '''

    def emailContent = "Thanks for subscribing our services."
    
        Dear ${user}
        emailContent
        ${signature}
    
'''

def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(bindMap)

Portanto, oemailXml terá XML renderizado e o conteúdo será: 


  
    
      Dear Norman
    
    
      Thanks for subscribing our services.
    
    
      example

É interessante notar que a saída XML é recuada e embelezada pela estrutura do modelo.

7. MarkupTemplateEngine

Essa estrutura de modelo é um pacote completo para gerar HTML e outras linguagens de marcação.

Além disso, ele usa a linguagem específica do domínio para processar os modelos e é a mais otimizada entre todas as estruturas de modelos disponíveis no Groovy.

7.1. HTML

Vamos escrever um exemplo rápido para renderizar HTML para o modeloemail já discutido: 

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

Portanto, o conteúdo deemailHtml será: 

Service Subscription Email

Dear Norman
Thanks for subscribing our services.
example

7.2. XML

Da mesma forma, podemos renderizar XML: 

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

Portanto, o conteúdo deemailXml será: 


Dear NormanThanks for subscribing our services.
example

7.3. TemplateConfiguration

Observe que, ao contrário deXmlTemplateEngine, a saída do template desta estrutura não é recuada e embelezada por si mesma.

Para tal configuração, usaremos a classeTemplateConfiguration: 

TemplateConfiguration config = new TemplateConfiguration()
config.autoIndent = true
config.autoEscape = true
config.autoNewLine = true

def templateEngine = new MarkupTemplateEngine(config)

7.4. Internacionalização

Além disso, a propriedadelocale deTemplateConfiguration está disponível para permitir o suporte à internacionalização.

Em primeiro lugar, vamos criar um arquivo de modelo estáticoemail.tple copiar a stringemailHtmlTemplate já discutida nele. Isso será tratado como o modelo padrão.

Da mesma forma, criaremos arquivos de modelo com base na localidade, comoemail_ja_JP.tpl para japonês, email_fr_FR.tpl para francês, etc.

Finalmente, tudo o que precisamos é definirlocale no objetoTemplateConfiguration: 

config.locale = Locale.JAPAN

Portanto, o modelo baseado em localidade correspondente será escolhido.

8. Conclusão

Neste artigo, vimos vários frameworks de modelo disponíveis no Groovy.

Podemos aproveitar esses mecanismos úteis de modelos para gerar texto dinâmico usando modelos estáticos. Portanto, eles podem ser úteis na geração dinâmica de vários tipos de notificações ou mensagens e erros na tela.

Como de costume, as implementações de código deste tutorial estão disponíveis no projetoGitHub.

Related