Apache Velocity: un template Engine in Java

In questo articolo vedremo le funzionalità di Apache Velocity un template engine Java-based.

Un template engine è un software che processa un template (un modello, ad esempio di una pagina web) e dei dati (contenuto informativo) per produrre un documento, ad esempio una pagina web da visualizzare. Alcuni linguaggi di programmazione come Java supportano nativamente il processamento di template: le Java Server Pages sono un esempio di web template engine.

Velocity è un template engine che permette di referenziare, e quindi di utilizzare, all’interno del template degli oggetti Java. Il suo scopo è quello di assicurare la separazione tra il Presentation Layer (livello di presentazione) con quello di Business (che contiene la logica applicativa) livelli che sono tipici del pattern architetturale del Model View Controller (MVC).

I principali campi di utilizzo di Velocity sono:

  • le Web Applications: i Web designers creano le pagine HTML con i placeholder per le informazioni dinamiche, cioè stabiliscono dei punti in cui dovranno comparire i dati prelevati ad esempio da un DB relazionale. La pagina viene poi processata da una Servlet del framework (la VelocityViewServlet) e riempita (merge) con i dati che gli sviluppatori Java avranno referenziato tramite degli oggetti java;
  • i generatori di codice: Velocity può essere utilizzato per generare codice quale SQL, PostScript o Java stesso;
  • le trasformazioni XML: Velocity fornisce un task Ant chiamato Anakia che legge un file XML e lo rende disponibile ad un template di Velocity.

Possiamo scaricare il file jar del framework all’indirizzo:

http://velocity.apache.org/download.cgi

oltre al framework sono incluse delle librerie da cui esso dipende. Una volta scaricato lo zip file, procediamo nel creare un progetto Java in Eclipse (File -> New -> Java Project).

A questo punto creiamo una cartella lib e vi copiamo le librerie jar contenute nel pacchetto .zip.

La prima cosa da fare è creare un semplice file di template che andremo a popolare con un oggetto Java, il template è il seguente:

#set( $this = "Velocity")
$this is great!
#foreach( $name in $list )
$name is great!
#end
#set( $condition = true)
#if ($condition)
The condition is true!
#else
The condition is false!
#end

Velocity utilizza il carattere # per definire gli statement (o direttive), cioè dei posti dove effettuare delle operazioni, in questo caso la direttiva set usa l’operazione di assegnamento (=) per settare la variabile $this uguale a “Velocity”; il carattere $ definisce appunto le references (o variabili), cioè i punti in cui sarà recuperato un valore (dinamico).

Per poter referenziare con delle variabili un contenuto incluso in un oggetto Java, dobbiamo innanzitutto definire all’interno del codice Java un VelocityContext e poi assegnare ad esso delle coppie chiave-valore tramite il metodo put(); a questi valori potremo accedere dal template chiamando le variabili con lo stesso nome delle chiavi:

import org.apache.velocity.app.Velocity;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.Template;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
import java.io.*;
import java.util.ArrayList;
public class TestVelocity
{
public static void main(String[] args)
{
String templateName = "example.vm";
//creo un array di dati da richiamare nel template
ArrayList<String> list = new ArrayList<String>();
list.add("ArrayList element 1");
list.add("ArrayList element 2");
list.add("ArrayList element 3");
try
{
//Inizializzo la Classe Velocity
Velocity.init();
VelocityContext context = new VelocityContext();
//crea la reference all'array di dati list
context.put("list", list);
Template template =  null;
try
{
//ottieni il template utilizzando il nome del file
template = Velocity.getTemplate(templateName);
}
catch( ResourceNotFoundException rnfe )
{
System.out.println("Example : error : cannot find template " + templateName );
}
catch( ParseErrorException pee )
{
System.out.println("Example : Syntax error in template " + templateName + ":" + pee );
}
BufferedWriter writer = writer = new BufferedWriter(
new OutputStreamWriter(System.out));
//Merge i dati referenziati con il template
if ( template != null)
template.merge(context, writer);
//flush e cleanup
writer.flush();
writer.close();
}
catch( Exception e )
{
System.out.println(e);
}
}
}

Il metodo merge di Template prende in input il Context ed un oggetto di tipo Writer che rappresenta l’output su cui sarà renderizzato il nostro template, nell’esempio verrà visualizzato sul System.out e quindi sulla console.

1 Stella2 Stelle3 Stelle4 Stelle5 Stelle (Nessun voto ancora)
Loading...
You can leave a response, or trackback from your own site.

Leave a Reply

*