Reglas de negocio con Drools y Activiti

Los procesos de negocio pueden tener varios caminos de ejecución distintos. En algunos casos la decisión que determina el camino de ejecución del proceso de negocio puede estar determinado por una decisión de negocio. Por ejemplo, si se determina que un cliente es VIP se puede querer dirigir el flujo del proceso de negocio por un camino alternativo para tratarle de forma especial por su condición de cliente VIP, esta decisión se puede realizar mediante una regla de negocio («business rule»). También, el propio hecho de determinar si el cliente es VIP puede ser realizado por otra regla de negocio. Con lo que podemos aplicar las reglas de negocio al menos a dos escenarios:

Para dirigir el flujo de un proceso de negocio. A este tipo de reglas de negocio se les denomina reglas con lógica de decisión («Decision logic rules»).
Para tratar información en base a definiciones, operaciones y restricciones. A este tipo de reglas se les denomina reglas con lógica de negocio («Business logic rules»).

Una regla de negocio con lógica de decisión que podría dirigir el flujo de un proceso de negocio podría ser:

Si el cliente es VIP enviar paquete por transporte urgente.

La regla de negocio que determina si el cliente es VIP y una regla con lógica de negocio podrían ser:

Si el cliente ha realizado una compra por importe superior a 100€ el cliente es VIP.
Si el cliente es VIP aplicar un descuento de 10€.

Estos son unas pocas reglas de negocio y bastante sencillas, en un sistema real podría haber muchas más y más complicadas. Por ejemplo, se podría querer aplicar descuentos a ciertos tipos de productos como libros o DVDs o descuentos cuando se compren varios productos relacionados a la vez. Esto se puede complicar suficientemente para que si se realizan las reglas de negocio mediante código de un lenguaje de programación tradicional como Java o C#, el código se convierta en poco mantenible y que pondría dificultades para adaptar una aplicación suficientemente rápido a los cambios que se producen en negocio.

Algunas ventajas de las reglas de negocio son:

Están documentadas y puede ser gestionadas, no es un conocimiento que posean las personas en sus cabezas.
Las reglas de negocio puede estar escritas en un lenguaje entendible por las personas de negocio. La gente de negocio puede verificar la lógica y cambiarla.
No se utiliza código de programa en algún lenguaje de programación que probablemente con el tiempo se convierta en código spaghetti y que no es entendible por las personas de negocio.
Es más fácil, flexible y rápido modificar las reglas de negocio que el código de programa equivalente en Java o C#. Se pueden modificar independientemente del código ya que las reglas no se encuentran en la aplicación.

En el siguiente enlace puedes encontrar otros motivos y ventajas, ¿Por qué usar reaglas de negocio?. Las reglas en definitiva contienen parte del conocimiento del negocio, los sistemas que se encargan de aplicarlas son denominados BRMS («Business Rule Management Systems»). Un ejemplo de BRMS es Drools y este puede ser usado en combinación con Activiti encargándose de esta forma cada unos de ellos del área especifica para el que están destinados, Drools para las reglas y Activiti para los procesos.

Veamos ahora un ejemplo similar al realizado en Usar variables en un proceso de negocio con Activiti pero usando reglas de negocio. El diagrama del proceso de negocio es el siguiente:

Mediante la tarea «Determinar Tipo Cliente» se determina el tipo de cliente en función del importe de la compra de un cliente valor que se toma de una variable del proceso de negocio del mismo nombre. En la tarea «Determinar Descuento» se determina el descuento a aplicar en función del tipo de cliente asignado en la tarea anterior. Estas dos tareas son ejemplos de reglas con lógica de negocio. Finalmente, el envío se realiza también en función del tipo de cliente dirigiendo el flujo del proceso mediante un gateway exclusivo, «Envío Normal» si el cliente es normal o «Envío Urgente» si el cliente es VIP. Este es un ejemplo de regla de negocio con lógica de decisión.

Veamos ahora el proceso de negocio en notación BPMN:

	<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="reglasDeNegocio" name="Reglas de negocio" isExecutable="true">
	<startEvent id="start" />
	<sequenceFlow id="flow1" sourceRef="start" targetRef="determinarTipoClienteTask" />

	<businessRuleTask id="determinarTipoClienteTask" activiti:ruleVariablesInput="${cliente},${importe}" activiti:rules="TipoClienteVIP,TipoClienteNormal" />
	<sequenceFlow id="flow2" sourceRef="determinarTipoClienteTask" targetRef="determinarDescuentoTask" />

	<businessRuleTask id="determinarDescuentoTask" activiti:ruleVariablesInput="${cliente},${output}" activiti:rules="DescuentoClienteVIP,DescuentoClienteNormal" />
	<sequenceFlow id="flow3" sourceRef="determinarDescuentoTask" targetRef="determinarTipoEnvioTask" />

	<businessRuleTask id="determinarTipoEnvioTask" activiti:ruleVariablesInput="${cliente},${output}" activiti:rules="TipoEnvioClienteVIP,TipoEnvioClienteNormal" />
	<sequenceFlow id="flow4" sourceRef="determinarTipoEnvioTask" targetRef="tipoEnvioGateway" />

	<exclusiveGateway id="tipoEnvioGateway" />
	<sequenceFlow sourceRef="tipoEnvioGateway" targetRef="envioNormalTask">
	<conditionExpression xsi:type="tFormalExpression">${output.tipoEnvio == 'normal'}</conditionExpression>
	</sequenceFlow>
	<sequenceFlow sourceRef="tipoEnvioGateway" targetRef="envioUrgenteTask">
	<conditionExpression xsi:type="tFormalExpression">${output.tipoEnvio == 'urgente'}</conditionExpression>
	</sequenceFlow>

	<scriptTask id="envioNormalTask" scriptFormat="groovy">
	<script>println('Envío normal')</script>
	</scriptTask>
	<sequenceFlow id="flow5" sourceRef="envioNormalTask" targetRef="end" />

	<scriptTask id="envioUrgenteTask" scriptFormat="groovy">
	<script>println('Envío urgente')</script>
	</scriptTask>
	<sequenceFlow id="flow6" sourceRef="envioUrgenteTask" targetRef="end" />

	<endEvent id="end" />
	</process>
	</definitions>

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

En esta definición la etiqueta «businessRuleTask» se encarga de ejecutar las reglas de negocio indicadas en el atributo «activiti:rules» con los siguientes hechos (denominados facts en la jerga de los sistemas de reglas) o variables «${cliente},${importe}» indicados en «activiti:ruleVariablesInput». Tambien se ve como es un gateway exclusivo en el xml, de él parten dos «sequenceFlow», se tomará el camino para el que se cumpla su «conditionExpression».

Ahora el código de las reglas de negocio para determinar el tipo de cliente, las reglas para determinar el descuento y el tipo de envío son muy parecidas y pueden verse en el código fuente del ejemplo:

	package es.com.blogspot.elblogdepicodev.activiti

	import java.math.BigDecimal;

	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente;
	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente.Tipo;

	rule "TipoClienteVIP"
	when
	BigDecimal(this.compareTo(new BigDecimal('100')) == 1)
	c: Cliente()
	then
	c.setTipo(Tipo.VIP);
	end

	rule "TipoClienteNormal"
	when
	BigDecimal(this.compareTo(new BigDecimal('100')) <= 0)
	c: Cliente()
	then
	c.setTipo(Tipo.NORMAL);
	end

view raw TipoCliente.drl hosted with ❤ by GitHub

Una regla de negocio es básicamente una condición que se evalúa para los hechos insertados en la base de conocimiento y en caso de cumplirse se ejecuta su parte then. Veamos ahora los teses unitarios para probar este proceso de negocio.

	package es.com.blogspot.elblogdepicodev.activiti;

	import java.math.BigDecimal;
	import java.util.HashMap;
	import java.util.Map;

	import org.activiti.engine.RuntimeService;
	import org.activiti.engine.test.ActivitiRule;
	import org.activiti.engine.test.Deployment;
	import org.junit.Assert;
	import org.junit.Rule;
	import org.junit.Test;

	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente;
	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente.Tipo;

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public class ReglasDeNegocioTest extends ActivitiAbstractTest {

	@Rule
	public ActivitiRule activitiRule = new ActivitiRule("activiti-h2.cfg.xml");

	@Test
	@Deployment(resources = { "bpmn/ReglasDeNegocio.bpmn20.xml", "rules/TipoCliente.drl", "rules/Descuento.drl", "rules/TipoEnvio.drl" })
	public void testNormal() {
	Cliente cliente = new Cliente();
	Map output = new HashMap();

	Map variables = new HashMap();
	variables.put("cliente", cliente);
	variables.put("importe", new BigDecimal("50"));
	variables.put("output", output);

	RuntimeService rs = activitiRule.getRuntimeService();
	rs.startProcessInstanceByKey("reglasDeNegocio", variables);

	Assert.assertEquals(cliente.getTipo(), Tipo.NORMAL);
	Assert.assertEquals(BigDecimal.ZERO, output.get("descuento"));
	Assert.assertEquals("normal", output.get("tipoEnvio"));
	}

	@Test
	@Deployment(resources = { "bpmn/ReglasDeNegocio.bpmn20.xml", "rules/TipoCliente.drl", "rules/Descuento.drl", "rules/TipoEnvio.drl" })
	public void testVIP() {
	Cliente cliente = new Cliente();
	Map output = new HashMap();

	Map variables = new HashMap();
	variables.put("cliente", cliente);
	variables.put("importe", new BigDecimal("150"));
	variables.put("output", output);

	RuntimeService rs = activitiRule.getRuntimeService();
	rs.startProcessInstanceByKey("reglasDeNegocio", variables);

	Assert.assertEquals(cliente.getTipo(), Tipo.VIP);
	Assert.assertEquals(new BigDecimal("10"), output.get("descuento"));
	Assert.assertEquals("urgente", output.get("tipoEnvio"));
	}
	}

view raw ReglasDeNegocioTest.java hosted with ❤ by GitHub

Las reglas de negocio para los teses se añaden a activiti como deployments de la misma forma que se hace para los procesos de negocio. Para que los deployments de las reglas de negocio de drools sean detectados correctamente hay que asignar un «customPostDeployer» al bean «processEngineConfiguration». También hay que añadir las siguientes dependencias al proyecto «org.drools:drools-core:5.4.0.Final», «org.drools:drools-compiler:5.4.0.Final» tal y como se puede ver en el archivo build.gradle del código fuente del proyecto.

	<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="processEngineConfiguration" class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
	...
	<property name="customPostDeployers">
	<list>
	<ref bean="rulesDeployer" />
	</list>
	</property>
	</bean>

	...
	<bean id="rulesDeployer" class="org.activiti.engine.impl.rules.RulesDeployer" />
	</beans>

view raw activiti-h2.cfg.xml hosted with ❤ by GitHub

Finalmente, el programa para ejecutar este proceso de negocio y su salida:

	package es.com.blogspot.elblogdepicodev.activiti;

	import java.math.BigDecimal;
	import java.util.HashMap;
	import java.util.Map;

	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.activiti.engine.runtime.ProcessInstance;
	import org.h2.tools.Server;

	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente;
	import es.com.blogspot.elblogdepicodev.activiti.misc.Cliente.Tipo;

	public class ReglasDeNegocio {

	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/ReglasDeNegocio.bpmn20.xml").addClasspathResource("rules/TipoCliente.drl")
	.addClasspathResource("rules/Descuento.drl").addClasspathResource("rules/TipoEnvio.drl").deploy();

	Cliente cliente = new Cliente(Tipo.NORMAL);
	Map variables = new HashMap();
	Map output = new HashMap();
	variables.put("cliente", cliente);
	variables.put("importe", new BigDecimal("150"));
	variables.put("output", output);

	ProcessInstance pi = runtimeService.startProcessInstanceByKey("reglasDeNegocio", variables);

	System.out.println("Tipo cliente: " + cliente.getTipo());
	System.out.println("Descuento aplicado: " + output.get("descuento"));
	} finally {
	ProcessEngines.destroy();
	if (server != null)
	server.stop();
	}
	}
	}