Procesos de negocio con Activiti

Como suele suceder con muchas tecnologías en la plataforma Java tenemos varios frameworks entre los cuales podemos elegir. En el ámbito de los BPMS los principales son Bonita, jBPM y Activiti.

Después de leer el libro jBPM Developer Guide intente hacer un hola mundo con jbpm 5, sin embargo, la API explicada en el libro (jBPM 4) y la de la versión actual (jBPM 5) ha cambiado bastante con lo que los ejemplos del libro son muy didácticos a nivel teórico pero son poco prácticos aún así la teoría de fondo es perfectamente válida para cualquier BPMS por lo que el libro sigue siendo bastante interesante. Con lo que la documentación sobre jBPM según mi opinión deja que desea para el que empieza desde cero. Hay un libro sobre jBPM 5 en proyecto que aún no ha sido publicado, probablemente las cosas mejoran en ese momento para jBPM 5. Por otra parte, según lo que he leído Bonita está más centrado en las personas de negocio y el desarrollador no tiene tanto control sobre los procesos de negocio.

Comparando la API de jBPM 4 con la de Activi tienen ciertas similitudes de hecho los autores de Activiti fueron desarrolladores de jBPM 4 y posteriormente al marcharse a trabajar en Alfresco desarrollaron Activiti basándose en la experiencia aprendida de jBPM 4, tanto la documentación como la API de Activiti me parece que está mejor que la de jBPM 5. De documentación en Activiti ademas del libro Activiti in Action también es una buena referencia la documentación del proyecto.

Algunas diferencias entre Activi, Bonita y jBPM están relacionados con quienes forman parte de la comunidad de desarrolladores, soporte de spring, soporte de reglas de negocio, herramientas adicionales de desarrollo y el propio proyecto. jBPM está integrado con el proyecto Drools (reglas de negocio) y Bonita está más centrado en las herramientas gráficas proporcionadas que en el propio desarrollador con que no se tiene tanto control como con Activiti.

Entrando ya en Activiti, está formado por varias herramientas:

• Activiti Engine: es el componente encargado de ejecutar los procesos de negocio en la notación BPMN 2.0.
• Activiti Modeler: es una herramienta con interfaz web para construir procesos en notación BPMN 2.0 que está orientada a los analistas de negocio.
• Activiti Designer: es un plugin de eclipse para desarrollar los procesos de negocio BPMN 2.0. También sirve para hacer pruebas unitarias y crear los artefactos de despliegue. Esta herramienta está orientada a los desarrolladores.
• Activiti Explorer: Es una aplicación web para realizar varias operaciones sobre los procesos de negocio como iniciar instancias de los mismos, obtener una lista de tareas asignadas a un usuario así como la posibilidad de desplegar nuevos procesos de negocio.
• Activiti REST: es una interfaz REST que puede ser consumida por sistemas externos a Activiti. Esta interfaz REST es independiente del lenguaje de programación por lo que puede ser consumida por aplicaciones PHP o .NET. Activiti también, puede ser ejecutado en modo por separado (standalone) o en modo embebido, en un servidor de aplicaciones como Tomcat o JBoss, en el caso del primero podremos acceder a él mediante esta interfaz REST, en el caso del segundo mediante la propia API de Activiti.

Después de descargar Activiti desde la página de descargas podemos empezar a mancharnos las manos rápidamente descomprimiendo el archivo en una carpeta ejecutando la siguiente linea de comando desde la carpeta de $ACTIVITI_HOME/setup:

$ $ANT_HOME/bin/ant demo.start

view raw gistfile1.sh hosted with ❤ by GitHub

Esta demo iniciará todo lo necesario para empezar, arrancará una base de datos H2, creará en ella las tablas con las que trabaja Activiti y lanzará un navegador para que podamos acceder a la herramienta Activiti Explorer en la que podremos iniciar sesión con el usuario kermit y contraseña kermit.

Las tablas de la base de datos de Activiti siguen una nomenclatura según la cual todas las tablas de Activi empiezan por ACT luego tienen un discriminador como HI (de history), RU (de runtime), RE (de repository) e ID (identity, para usuarios y grupos). En estas tablas se guarda la información de las propias definiciones de los procesos, de las variables en su ejecución, datos históricos, etc...

Vamos a ver un ejemplo sencillo de un proceso de negocio con Activi que será el típico Hola Mundo, empezamos por el xml en notación BPMN del proceso:

	<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:activiti="http://activiti.org/bpmn" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.omg.org/spec/BPMN/20100524/MODEL http://www.omg.org/spec/BPMN/2.0/20100501/BPMN20.xsd" targetNamespace="HelloWorldActiviti">
	<process id="helloWorld" name="Hola mundo" isExecutable="true">
	<startEvent id="start" />
	<sequenceFlow id="flow1" sourceRef="start" targetRef="saludarTask" />
	<scriptTask id="saludarTask" scriptFormat="groovy">
	<script>println('Hola Mundo desde el proceso!')</script>
	</scriptTask>
	<sequenceFlow id="flow2" sourceRef="saludarTask" targetRef="end" />
	<endEvent id="end" />
	</process>
	</definitions>

view raw HelloWorld.bpmn20.xml hosted with ❤ by GitHub

Todo procesos comienza con startEvent y acaba con endEvent, contiene varias sequenceFlow para dirigir de un nodo a otro y entre startEvent y endEvent hay una serie de nodos que irán realizando las tareas del proceso, en el ejemplo scriptTask contiene un trozo de código en este caso en lenguaje groovy que emite un mensaje a la consola.

Y ahora el caso de prueba con JUnit:

	package es.com.blogspot.elblogdepicodev.activiti;
	import org.activiti.engine.test.ActivitiRule;
	import org.activiti.engine.test.Deployment;
	import org.junit.Rule;
	import org.junit.Test;
	public class HelloWorldTest extends ActivitiAbstractTest {
	@Rule
	public ActivitiRule activitiRule = new ActivitiRule("activiti-h2.cfg.xml");
	@Test
	@Deployment(resources = "bpmn/HelloWorld.bpmn20.xml")
	public void test1() {
	activitiRule.getRuntimeService().startProcessInstanceByKey("helloWorld");
	System.out.println("Hola Mundo desde el test!");
	}
	}

view raw HelloWorldTest.java hosted with ❤ by GitHub

Lo interesante de este test JUnit está en las anotaciones. @Rule permite inicializar Activiti con cierta configuración y nos proporcionará la referencia al objeto, activitiRule, con la que podremos trabajar en el test con Activiti, @Deployment se encarga de desplegar en Activiti el proceso de negocio indicado y con activitiRule.getRuntimeService().startProcessInstanceByKey iniciamos la ejecución una instancia del proceso. La salida de este proceso sería la siguiente, en ella se ve el mensaje emitido dentro de la ejecución del proceso desde el scriptTask y el mensaje del propio test:

Un programa para ejecutar el proceso sería el siguiente aunque probablemente en un entorno real no necesitásemos hacer algunas cosas como iniciar la base de datos donde se persistirán los datos del proceso (Server.createTcpServer().start()):

	package es.com.blogspot.elblogdepicodev.activiti;
	import org.activiti.engine.ProcessEngine;
	import org.activiti.engine.ProcessEngineConfiguration;
	import org.activiti.engine.ProcessEngines;
	import org.activiti.engine.RepositoryService;
	import org.activiti.engine.RuntimeService;
	import org.h2.tools.Server;
	public class HelloWorld {
	public static void main(String[] args) throws Exception {
	Server server = null;
	try {
	server = Server.createTcpServer().start();
	ProcessEngines.init();
	ProcessEngine processEngine = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti-mysql.cfg.xml").buildProcessEngine();
	RuntimeService runtimeService = processEngine.getRuntimeService();
	RepositoryService repositoryService = processEngine.getRepositoryService();
	repositoryService.createDeployment().addClasspathResource("bpmn/HelloWorld.bpmn20.xml").deploy();
	runtimeService.startProcessInstanceByKey("helloWorld");
	} finally {
	ProcessEngines.destroy();
	if (server != null)
	server.stop();
	}
	}
	}

view raw HelloWorld.java hosted with ❤ by GitHub

Este ejemplo es muy sencillo y sirve principalmente para hacerse una idea del código necesario para trabajar con Activiti pero no muestra todas sus posibilidades que aprovechándolas el código de nuestro proyecto se puede simplificar enormemente y nos permitirá eliminar mucho código spaghetti, será más fácilmente mantenible y probablemente sea menos propenso a errores ante los cambios que se produzcan.
En el siguiente repositorio de GitHub está el código fuente completo del ejemplo junto con otros que vaya añadiendo a medida que vaya aprendiendo más cosas de Activiti.

Referencia:
Conceptos sobre procesos de negocio (BP, BPM, BPMS, ...)
Usar variables en un proceso de negocio con Activiti
Tratamiento de errores en procesos de negocio con Activiti
Reglas de negocio con Drools y Activiti
Código fuente del ejemplo Hola mundo con Activiti