Groovy - Motores de plantillas

El motor de plantillas de Groovy funciona como una combinación de correspondencia (la adición automática de nombres y direcciones de una base de datos a cartas y sobres para facilitar el envío de correo, especialmente publicidad, a muchas direcciones) pero es mucho más general.

Plantillas simples en cadenas

Si toma el ejemplo simple a continuación, primero estamos definiendo una variable de nombre para contener la cadena "Groovy". En la declaración println, estamos usando $ symbol para definir un parámetro o plantilla donde se puede insertar un valor.

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

Si el código anterior se ejecuta en groovy, se mostrará el siguiente resultado. La salida muestra claramente que $ name fue reemplazado por el valor asignado por la declaración def.

Motor de plantilla simple

A continuación, se muestra un ejemplo de SimpleTemplateEngine que le permite usar scriptlets y expresiones EL similares a JSP en su plantilla para generar texto parametrizado. El motor de plantillas le permite vincular una lista de parámetros y sus valores para que puedan reemplazarse en la cadena que tiene los marcadores de posición 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

Si el código anterior se ejecuta en groovy, se mostrará el siguiente resultado.

Usemos ahora la función de creación de plantillas para un archivo XML. Como primer paso, agreguemos el siguiente código a un archivo llamado Student.template. En el siguiente archivo, notará que no hemos agregado los valores reales de los elementos, sino marcadores de posición. Entonces, $ name, $ is y $ subject se colocan como marcadores de posición que deberán reemplazarse en tiempo de ejecución.

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

Ahora agreguemos nuestro código de secuencia de comandos Groovy para agregar la funcionalidad que se puede usar para reemplazar la plantilla anterior con valores reales. Se deben tener en cuenta las siguientes cosas sobre el siguiente código.

La asignación de los marcadores de posición a los valores reales se realiza a través de un enlace y un SimpleTemplateEngine. El enlace es un mapa con los marcadores de posición como claves y los reemplazos como 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

Si el código anterior se ejecuta en groovy, se mostrará el siguiente resultado. En la salida se puede ver que los valores se reemplazan correctamente en los marcadores de posición relevantes.

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

StreamingTemplateEngine

El motor StreamingTemplateEngine es otro motor de plantillas disponible en Groovy. Esto es equivalente a SimpleTemplateEngine, pero crea la plantilla utilizando cierres que se pueden escribir, lo que la hace más escalable para plantillas grandes. Específicamente, este motor de plantillas puede manejar cadenas de más de 64k.

A continuación se muestra un ejemplo de cómo se utilizan StreamingTemplateEngine:

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)

Si el código anterior se ejecuta en groovy, se mostrará el siguiente resultado.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngine se usa en escenarios de creación de plantillas en los que tanto el origen de la plantilla como el resultado esperado deben ser XML. Las plantillas usan las notaciones normales $ {expresión} y $ variable para insertar una expresión arbitraria en la plantilla.

A continuación se muestra un ejemplo de cómo se utiliza XMLTemplateEngine.

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

Si el código anterior se ejecuta en groovy, se mostrará el siguiente resultado

Joe
    
    
   1
    
    
   Physics

↰ Previous page Next page ↱