Groovy - Template Engines

Die Vorlagen-Engine von Groovy funktioniert wie ein Seriendruck (das automatische Hinzufügen von Namen und Adressen aus einer Datenbank zu Briefen und Umschlägen, um das Senden von E-Mails, insbesondere von Werbung, an viele Adressen zu erleichtern), ist jedoch viel allgemeiner.

Einfaches Templating in Strings

Wenn Sie das folgende einfache Beispiel verwenden, definieren wir zunächst eine Namensvariable, die die Zeichenfolge „Groovy“ enthält. In der println-Anweisung verwenden wir das $ -Symbol, um einen Parameter oder eine Vorlage zu definieren, in die ein Wert eingefügt werden kann.

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

Wenn der obige Code in Groovy ausgeführt wird, wird die folgende Ausgabe angezeigt. Die Ausgabe zeigt deutlich, dass der Name $ durch den Wert ersetzt wurde, der durch die Anweisung def zugewiesen wurde.

Einfache Vorlagen-Engine

Im Folgenden finden Sie ein Beispiel für die SimpleTemplateEngine, mit der Sie JSP-ähnliche Scriptlets und EL-Ausdrücke in Ihrer Vorlage verwenden können, um parametrisierten Text zu generieren. Mit der Vorlagen-Engine können Sie eine Liste von Parametern und deren Werten binden, damit sie in der Zeichenfolge mit den definierten Platzhaltern ersetzt werden können.

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

Wenn der obige Code in Groovy ausgeführt wird, wird die folgende Ausgabe angezeigt.

Verwenden wir nun die Vorlagenfunktion für eine XML-Datei. Als ersten Schritt fügen wir den folgenden Code zu einer Datei mit dem Namen Student.template hinzu. In der folgenden Datei werden Sie feststellen, dass wir nicht die tatsächlichen Werte für die Elemente, sondern Platzhalter hinzugefügt haben. $ Name, $ is und $ subject werden also alle als Platzhalter gesetzt, die zur Laufzeit ersetzt werden müssen.

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

Fügen wir nun unseren Groovy-Skriptcode hinzu, um die Funktionalität hinzuzufügen, mit der die obige Vorlage durch tatsächliche Werte ersetzt werden kann. Die folgenden Dinge sollten über den folgenden Code beachtet werden.

Die Zuordnung der Platzhalter zu tatsächlichen Werten erfolgt über eine Bindung und eine SimpleTemplateEngine. Die Bindung ist eine Karte mit den Platzhaltern als Schlüssel und den Ersetzungen als Werten.

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

Wenn der obige Code in Groovy ausgeführt wird, wird die folgende Ausgabe angezeigt. Aus der Ausgabe ist ersichtlich, dass die Werte in den entsprechenden Platzhaltern erfolgreich ersetzt wurden.

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

StreamingTemplateEngine

Die StreamingTemplateEngine-Engine ist eine weitere in Groovy verfügbare Template-Engine. Dies entspricht in etwa der SimpleTemplateEngine, erstellt die Vorlage jedoch mithilfe beschreibbarer Verschlüsse, sodass sie für große Vorlagen skalierbarer ist. Insbesondere kann diese Vorlagen-Engine Zeichenfolgen verarbeiten, die größer als 64 KB sind.

Im Folgenden finden Sie ein Beispiel für die Verwendung von 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)

Wenn der obige Code in Groovy ausgeführt wird, wird die folgende Ausgabe angezeigt.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

Die XmlTemplateEngine wird in Template-Szenarien verwendet, in denen sowohl die Vorlagenquelle als auch die erwartete Ausgabe XML sein sollen. Vorlagen verwenden die normalen Notationen $ {expression} und $ variable, um einen beliebigen Ausdruck in die Vorlage einzufügen.

Im Folgenden finden Sie ein Beispiel für die Verwendung von 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()

Wenn der obige Code in Groovy ausgeführt wird, wird die folgende Ausgabe angezeigt

Joe
    
    
   1
    
    
   Physics