Groovy - Modelli di motori

Il motore dei modelli di Groovy funziona come una stampa unione (l'aggiunta automatica di nomi e indirizzi da un database a lettere e buste per facilitare l'invio di posta, soprattutto pubblicità, a molti indirizzi) ma è molto più generale.

Modelli semplici in stringhe

Se prendi il semplice esempio riportato di seguito, definiamo prima una variabile di nome per contenere la stringa "Groovy". Nell'istruzione println, stiamo usando $ symbol per definire un parametro o un modello in cui è possibile inserire un valore.

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

Se il codice sopra viene eseguito in groovy, verrà mostrato il seguente output. L'output mostra chiaramente che $ name è stato sostituito dal valore assegnato dall'istruzione def.

Motore di modelli semplice

Di seguito è riportato un esempio di SimpleTemplateEngine che consente di utilizzare scriptlet simili a JSP ed espressioni EL nel modello per generare testo parametrizzato. Il motore di modelli consente di associare un elenco di parametri e i loro valori in modo che possano essere sostituiti nella stringa che ha i segnaposto definiti.

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 il codice sopra viene eseguito in groovy, verrà mostrato il seguente output.

Usiamo ora la funzionalità di template per un file XML. Come primo passo aggiungiamo il codice seguente a un file chiamato Student.template. Nel file seguente noterai che non abbiamo aggiunto i valori effettivi per gli elementi, ma i segnaposto. Quindi $ name, $ is e $ subject sono tutti messi come segnaposto che dovranno essere sostituiti in fase di runtime.

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

Ora aggiungiamo il nostro codice di script Groovy per aggiungere la funzionalità che può essere utilizzata per sostituire il modello sopra con i valori effettivi. Le seguenti cose dovrebbero essere annotate sul codice seguente.

• La mappatura dei segnaposto ai valori effettivi viene eseguita tramite un'associazione e un SimpleTemplateEngine. L'associazione è una mappa con i segnaposto come chiavi e le sostituzioni come valori.

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 il codice sopra viene eseguito in groovy, verrà mostrato il seguente output. Dall'output si può vedere che i valori vengono sostituiti con successo nei relativi segnaposto.

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

StreamingTemplateEngine

Il motore StreamingTemplateEngine è un altro motore di modelli disponibile in Groovy. Questo è un po 'equivalente al SimpleTemplateEngine, ma crea il modello utilizzando chiusure scrivibili rendendolo più scalabile per modelli di grandi dimensioni. In particolare, questo motore di modelli può gestire stringhe più grandi di 64k.

Di seguito è riportato un esempio di come vengono utilizzati 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)

Se il codice sopra viene eseguito in groovy, verrà mostrato il seguente output.

This Tutorial is Groovy The Topic name is Templates

XMLTemplateEngine

XmlTemplateEngine viene utilizzato in scenari di modelli in cui sia l'origine del modello che l'output previsto devono essere XML. I modelli usano le normali notazioni $ {espressione} e $ variabile per inserire un'espressione arbitraria nel modello.

Di seguito è riportato un esempio di come viene utilizzato 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()

Se il codice sopra viene eseguito in groovy, verrà mostrato il seguente output

Joe
    
    
   1
    
    
   Physics