Usando Apache Velocity

2 minuto de lectura

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 más conocida de todas las formas de uso de Velocity. Pero es mucho más 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)

¿Cuándo podemos utilizar Templates?

Hay un sin número de aplicaciones, como 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 docbook, incluso otro tipo de archivos (rdf, txt)
  • Y el más 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á el trabajo 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 código fuente aquí:

Mas Información en:

Comentar