velocity-logo

¿Que es Velocity?

Velocity es un proyecto de Apache para el desarrollo de Templates para la capa de vista dentro del modelo MVC, siendo esta última la mas conocida de todas las formas de uso de Velocity. Pero es mucho mas que eso, podemos usar el motor de Velocity para lo que necesitemos utilizando siempre el concepto de uso de templates.

¿Que es un template?
Como su nombre lo dice es una plantilla, les dejo un ejemplo de como seria una plantilla Velocity para una vista en html:

#set ($hola = "Hola Mundo")
<h1>$hola</h1>
 
## Esto es una macro de Velocity
#d() 
 
<h2>$salida</h2>

Donde:

  • #set es una directiva para settear valores
  • $hola es la variable setteada con el valor Hola Mundo
  • #d() es una Velocimacro
  • $salida es una variable de contexto que sera setteada desde la ejecución de Velocity (ver código fuente de java)

¿Cuando podemos utilizar Templates?, hay un sin número de aplicaciones, por ejemplo:

  • Envío de mails personalizados, en este punto uno podría escribir los templates (email tipo) y dejar ciertos tags de Velocity (llamados directivas) para la personalización.
  • Generar XML’s dinamicos.
  • Generar otro tipo de salidas como por ejemplo JSON.
  • Generar PDF mediante docbok, incluso otro tipo de archivos (rdf, txt)
  • Y el mas usado, escribir templates para ser usados como html en la capa de vista.

Usando Velocity Engine

Primero creamos un proyecto con Maven2 para hacer la vida mas fácil y agregamos las siguientes dependencias:

<dependencies>
	<dependency>
		<groupId>org.apache.velocity</groupId>
		<artifactId>velocity</artifactId>
		<version>1.6.2</version>
	</dependency>
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.5</version>
	</dependency>
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.14</version>
	</dependency>
</dependencies>

Luego creamos la clase que hará la pega de llamar a VelocityEngine, la carga del template y finalmente la salida.

package cl.firefox.pcollaog.velocity;
 
import java.io.StringWriter;
import java.io.Writer;
import java.util.Properties;
 
import org.apache.log4j.Logger;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
 
/**
 * <p>
 * </p>
 * <p>
 * $Id: VelocityEngine.java,v 1.1 2009-04-20 00:21:20 pcollaog Exp $
 * </p>
 * 
 * @author pcollaog
 * @version $Revision: 1.1 $
 */
public class VelocityEngine {
 
	Logger logger = Logger.getLogger(VelocityEngine.class);
 
	private VelocityContext _ctx;
 
	private void init() throws Exception {
		logger.info("Inicializando Velocity");
		Properties prop = new Properties();
 
		// Carga archivo de propiedades de velocity
		prop.load(getClass()
				.getResourceAsStream("/velocity.properties"));
 
		// Inicializa Velocity
		Velocity.init(prop);
 
		_ctx = new VelocityContext();
	}
 
	public String mergeTemplate() throws ResourceNotFoundException,
			ParseErrorException, Exception {
 
		init();
 
		// Carga el template
		Template tpl = Velocity.getTemplate("template.vm");
 
		// Agrega una variable al contexto luego puede ser usada
		// como $salida
		_ctx.put("salida", "OK");
 
		// Creo un Writer para almacenar la salida
		Writer writer = new StringWriter();
 
		// Genero la mezcla del template con sus las variables
		// del contexto y macros de velocity
		tpl.merge(_ctx, writer);
 
		// Finalmente genero un string con la salida
		return writer.toString();
	}
}

Espero que el código se explique por si solo.

Aquí dejo el ejemplo completo hecho con Maven2, para ver la ejecución, dentro del código fuente va un Test Unitario que imprime la salida de los templates.

$ mvn clean compile test

Baja el Source Code Aquí:

Ejemplo de Velocity versión no Servlet

Mas Información en: