Groovy - motores de modelo

O mecanismo de modelo do Groovy opera como uma mala direta (a adição automática de nomes e endereços de um banco de dados a cartas e envelopes para facilitar o envio de correspondência, especialmente publicidade, para muitos endereços), mas é muito mais geral.

Modelagem Simples em Strings

Se você pegar o exemplo simples abaixo, primeiro estamos definindo uma variável de nome para conter a string “Groovy”. Na instrução println, estamos usando $ symbol para definir um parâmetro ou modelo onde um valor pode ser inserido.

def name = "Groovy" 
println "This Tutorial is about ${name}"

Se o código acima for executado no groovy, a seguinte saída será mostrada. A saída mostra claramente que o $ name foi substituído pelo valor que foi atribuído pela instrução def.

Motor de modelo simples

A seguir está um exemplo de SimpleTemplateEngine que permite usar scriptlets semelhantes a JSP e expressões EL em seu modelo para gerar texto parametrizado. O mecanismo de modelagem permite vincular uma lista de parâmetros e seus valores para que possam ser substituídos na string que possui os espaços reservados definidos.

def text ='This Tutorial focuses on $TutorialName. In this tutorial you will learn 

about $Topic'  

def binding = ["TutorialName":"Groovy", "Topic":"Templates"]  
def engine = new groovy.text.SimpleTemplateEngine() 
def template = engine.createTemplate(text).make(binding) 

println template

Se o código acima for executado no groovy, a seguinte saída será mostrada.

Vamos agora usar o recurso de modelagem para um arquivo XML. Como primeira etapa, vamos adicionar o código a seguir a um arquivo chamado Student.template. No arquivo a seguir, você notará que não adicionamos os valores reais para os elementos, mas os marcadores. Portanto, $ name, $ is e $ subject são colocados como marcadores que precisarão ser substituídos em tempo de execução.

<Student> 
   <name>${name}</name> 
   <ID>${id}</ID> 
   <subject>${subject}</subject> 
</Student>

Agora vamos adicionar nosso código de script Groovy para adicionar a funcionalidade que pode ser usada para substituir o modelo acima por valores reais. As seguintes coisas devem ser observadas sobre o código a seguir.

O mapeamento dos marcadores de posição para valores reais é feito por meio de um binding e um SimpleTemplateEngine. A ligação é um mapa com os marcadores de posição como chaves e as substituições como os valores.

import groovy.text.* 
import java.io.* 

def file = new File("D:/Student.template") 
def binding = ['name' : 'Joe', 'id' : 1, 'subject' : 'Physics']
				  
def engine = new SimpleTemplateEngine() 
def template = engine.createTemplate(file) 
def writable = template.make(binding) 

println writable

Se o código acima for executado no groovy, a seguinte saída será mostrada. Na saída, pode-se ver que os valores foram substituídos com êxito nos marcadores de posição relevantes.

<Student> 
   <name>Joe</name> 
   <ID>1</ID> 
   <subject>Physics</subject> 
</Student>

StreamingTemplateEngine

O mecanismo StreamingTemplateEngine é outro mecanismo de modelos disponível no Groovy. Isso é equivalente ao SimpleTemplateEngine, mas cria o modelo usando fechamentos graváveis, tornando-o mais escalonável para modelos grandes. Especificamente, este mecanismo de modelo pode lidar com strings maiores que 64k.

A seguir está um exemplo de como StreamingTemplateEngine são usados -

def text = '''This Tutorial is <% out.print TutorialName %> The Topic name 

is ${TopicName}''' 
def template = new groovy.text.StreamingTemplateEngine().createTemplate(text)
  
def binding = [TutorialName : "Groovy", TopicName  : "Templates",]
String response = template.make(binding) 
println(response)

Se o código acima for executado no groovy, a seguinte saída será mostrada.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

O XmlTemplateEngine é usado em cenários de modelos em que tanto a origem do modelo quanto a saída esperada devem ser XML. Os modelos usam as notações normais $ {expression} e $ variable para inserir uma expressão arbitrária no modelo.

A seguir está um exemplo de como XMLTemplateEngine é usado.

def binding = [StudentName: 'Joe', id: 1, subject: 'Physics'] 
def engine = new groovy.text.XmlTemplateEngine() 

def text = '''\
   <document xmlns:gsp='http://groovy.codehaus.org/2005/gsp'>
      <Student>
         <name>${StudentName}</name>
         <ID>${id}</ID>
         <subject>${subject}</subject>
      </Student>
   </document> 
''' 

def template = engine.createTemplate(text).make(binding) 
println template.toString()

Se o código acima for executado no groovy, a seguinte saída será mostrada

Joe
    
    
   1
    
    
   Physics