Manual de introduccion a JBoss jBPM

8,815 views

Published on

Manual de introduccion a JBoss jBPM.

Published in: Technology
0 Comments
5 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
8,815
On SlideShare
0
From Embeds
0
Number of Embeds
48
Actions
Shares
0
Downloads
366
Comments
0
Likes
5
Embeds 0
No embeds

No notes for slide

Manual de introduccion a JBoss jBPM

  1. 1. MANUAL DE INTRODUCCIÓN A JBOSS jBPM 3.x Jorge Roldán Barrio
  2. 2. Índice de contenidoControl de versiones.............................................................................................................................31. Introducción......................................................................................................................................42. Instalación.........................................................................................................................................5 2.1 Instalación del servidor de aplicaciones JBoss..........................................................................5 2.2 Ejecución del instalador jBPM..................................................................................................5 2.3 Instalación de un servidor de base de datos MySQL.................................................................5 2.4 Instalación del plugin para Eclipse Jboss Tools ........................................................................6 2.5 Comprobación del conjunto de la instalación............................................................................63. Modelado de procesos en jBPM.......................................................................................................8 3.1 Nodos.........................................................................................................................................8 3.1.1 Nodo de inicio (start).........................................................................................................8 3.1.2 Nodo de tarea (task-node)..................................................................................................8 3.1.3 Nodo de estado (state) .......................................................................................................8 3.1.4 Nodo de decisión (decision)...............................................................................................8 3.1.5 Nodo fork .........................................................................................................................9 3.1.6 Nodo join ...........................................................................................................................9 3.1.7 Nodo node..........................................................................................................................9 3.1.8 Nodo de fin (end)...............................................................................................................9 3.2 Transiciones...............................................................................................................................9 3.3 Acciones ....................................................................................................................................94. Ejemplo de proceso simple.............................................................................................................105. Persistencia de procesos.................................................................................................................136. Uso de un nodo node......................................................................................................................167. Uso de un nodo de decisión............................................................................................................178. Uso de un nodo de tarea.................................................................................................................209. Uso de un nodo de correo...............................................................................................................23 9.1 Instalación de un servidor de correo – Apache James Server..................................................23 9.2 Implementación del proceso de ejemplo.................................................................................2510. Consola de administración de jBPM............................................................................................27 10.1 Registro de usuario en la consola de administración de jBPM..............................................27 10.2 Ejemplo de uso de la consola de administración de jBPM....................................................28Conclusiones.......................................................................................................................................34
  3. 3. Control de versionesFecha Autor Observaciones10/08/09 Jorge Roldán Barrio Versión inicial del documento13/08/09 Jorge Roldán Barrio - Inclusión del capítulo sobre el uso de un nodo node - Reorganización de los capítulos de uso de los tipos de nodos - Cambio de nombre del documento para resaltar que se hace referencia a la versión 3.x de jBPM17/08/09 Jorge Roldán Barrio Inclusión del capítulo sobre la consola de administración de jBPM20/08/09 Jorge Roldán Barrio Inclusión del capítulo sobre el uso de un nodo de correo
  4. 4. Manual de introducción a JBoss jBPM1. IntroducciónLa lógica de negocio se puede definir en forma de una serie de tareas relacionadas que se debenejecutar, si se cumplen unas determinadas condiciones, de forma secuencial o paralela, omantenerse en espera de algún evento que reanude su ejecución.Al conjunto de estas tareas se le conoce como proceso de negocio.La gestión de procesos denegocio (BPM – Business Process Management) se encarga del modelado de los procesos denegocio, y define el flujo de trabajo (workflow) que rige su funcionamiento. Un workflow modelade forma gráfica las relaciones entre las distintas tareas.Un sistema de gestión de procesos de negocio (BPMS - Business Process Management System) esuna aplicación que gestiona estos flujos de trabajo, y se encarga de automatizar la secuencia deacciones, actividades o tareas que componen del proceso y se encarga de la persistencia de suestado. Esta automatización permite integrar los procesos de la empresa y rediseñarlos de acuerdo anuevas estrategias.Existen varios sistemas de gestión de procesos de negocio, y uno de ellos es JBoss jBPM, cuyaprincipal ventaja para aquellos que quieren aprender esta tecnología es que es open-source. En elpresente manual se pretende introducir al lector en el uso de esta herramienta. 4 de 34
  5. 5. Manual de introducción a JBoss jBPM 3.x2. InstalaciónAntes de empezar a trabajar con jBPM, se va a proceder a la instalación de dicha herramienta y deun conjunto de utilidades que facilitan el desarrollo jBPM en Eclipse llamadas jBoss Tools.La instalación comprende los siguientes pasos: − Instalación del servidor de aplicaciones Jboss. − Ejecución del instalador de jBPM. − Instalación de un servidor de base de datos MySQL. − Instalación del plugin para Eclipse Jboss Tools. − Comprobación del conjunto de la instalación.Es necesaria la instalación de un JDK en el equipo si es que no se encuentra ya instalado. Durante larealización de este manual, se ha a realizado la instalación en un equipo Windows XP que tieneinstalada la versión 1.6.0_04-b12 de la JDK de Sun.2.1 Instalación del servidor de aplicaciones JBossSe debe descargar la versión 5.0.1.GA del servidor de aplicaciones Jboss de jboss.org. El archivodescargado es un .zip que se debe descomprimir en el directorio que se desee. En este caso, todoslos archivos del servidor se van encontrar en la carpeta C:JBossjboss-5.0.1.GA. Haciendo dobleclic sobre el archivo C:JBossjboss-5.0.1.GAbinrun.bat se arranca el servidor con laconfiguración por defecto. Se trata de un servidor de aplicaciones completo pero sinfuncionalidades de cluster, webservices, etc.2.2 Ejecución del instalador jBPMA continuación se debe descargar el instalador de jBPM de la dirección sourceforge.net.Seleccionamos el archivo jbpm-installer-3.2.6.SP1.jar. Al ejecutarse este instalador permite instalarla suite de jBPM sobre distintas versiones del servidor de aplicaciones de Jboss y distintas bases dedatos como Hypersonic o MySQL.Se ejecuta el instalador de jBPM. Lo primero que pide es la ruta de instalación, que en este caso vaa ser C:javajbpm. A continuación pregunta por los paquetes a instalar, pero lo dejaremos tal ycomo está y pulsaremos “Next”. Ahora se debe elegir la versión del servidor en la que estamosrealizando la instalación, después la base de datos y finalmente la ruta del servidor. Tras esto ya sepasa a realizar la instalación.2.3 Instalación de un servidor de base de datos MySQLLo más sencillo sería realizar la instalación utilizando la base de datos Hypersonic. Hypersonic esuna base de datos que se almacena en memoria, usada para desarrollo. Sin embargo, la informaciónalmacenada se va a perder cada vez que se pare el servidor. Por ello, en nuestro caso, vamos arealizar la instalación sobre MySQL.Si no se dispone de un servidor de base de datos MySQL instalado, se descarga de 5 de 34
  6. 6. Manual de introducción a JBoss jBPMdev.mysql.com/downloads/ el servidor MySQL Community Server y las herramientas deadministración GUI Tools. Una vez descargados se procede a su instalación.Ahora habría que crear el esquema de base de datos que usa jBPM. Por sencillez, se va a mantenerla configuración por defecto para la fuente de datos que utiliza jBPM. Para hacer que funcione, sedebe ir al MySQL Administrator y crear un nuevo catálogo llamado jbpmtest y un nuevo usuario denombre jbpmtest y sin password. Se asigna a este usuario todos los permisos de la tabla jbpmtest.En la ruta de instalación de jbpm (C:javajbpm) hay, entre otras cosas, scripts de creación delesquema usado por jBPM. Si se va al MySQL Query Browser y se realiza la conexión al esquemajbpmtest, a través de File → Open Script se puede seleccionar el script para la creación de las tablasen MySQL, C:javajbpmdatabasejbpm.jpdl.mysql.sql.Con la ejecución de este script, se habrá finalizado la instalación de jBPM con MySQL.2.4 Instalación del plugin para Eclipse Jboss ToolsPara el desarrollo en jBPM es útil contar con una herramienta de modelado gráfico que simplifiquelas cosas. Para ello se va a instalar Jboss Tools, que es un conjunto de herramientas para Eclipse.Entre estas herramientas, Jboss Tools dispone dispone de plugins que proporcionan soporte enEclipse para Hibernate, JBoss AS, Drools, jBPM, JSF, (X)HTML, Seam, Smooks, JBoss ESB oJBoss Portal, entre otros.Se puede obtener Jboss Tools de la dirección http://www.jboss.org/tools/download.html. Se puederealizar la descarga de forma directa o seguir las instrucciones para realizar la actualización desdeEclipse.2.5 Comprobación del conjunto de la instalaciónUna vez instalado Jboss Tools, ya se puede crear un proyecto jBPM de ejemplo en Eclipse de lasiguiente manera: − Ir a File → New Project. − Desplegar Jboss jBPM y seleccionar Process Project. − Introsucir el nombre del proyecto, por ejemplo, simple. − Seleccionar la ruta el entorno de ejecución de Jboss jBPM, que en este caso se encuentra en C:javajbpm. − Asegurarse de que está habilitado el check para que cree la definición de proceso de prueba. Por último, pulsar Finish.Con esto se debería haber creado un proyecto de ejemplo que tiene una definición de un procesosimple en el archivo processdefinition.xml del paquete simple de la carpeta src/main/jpdl. Si elpaquete simple estuviese vacío, se pueden recuperar los archivos que se encuentran en la carpetaC:javajbpmexamplessrctestresourcessimple y dejarlos en el paquete simple.Si aparece un error en el proyecto que hace referencia a que falta la libreríaC:javajbpmlibactivation.jar, se debe arreglar yendo al archivoC:javajbpmsrcresourcesgpdversion.info.xml y eliminando la línea que hace referencia a esta 6 de 34
  7. 7. Manual de introducción a JBoss jBPM 3.xlibrería. Al hacer un “clean” del proyecto el error debería haber desaparecido.Si se hace doble clic sobre el archivo processdefinition.xml se abrirá el jBPM Graphical ProcessDesigner con la descripción gráfica del proceso de ejemplo.El siguiente paso a dar es desplegar esta definición de proceso en el servidor jBPM para podertrabajar con ella. Para ello hay que ir a la pestaña deployment y revisar los datos en el apartadoDeployment Server Settings para que coincidan con los del servidor de aplicaciones, que deberáestar arrancado. Pulsando en Deploy Process Archive se realizará el despliegue, se puedecomprobar verificando que esta definición se ha guardado en la tablaJBPM_PROCESSDEFINITION de la base de datos.Ya se dispone del entorno de trabajo configurado y una definición de proceso desplegada. 7 de 34
  8. 8. Manual de introducción a JBoss jBPM3. Modelado de procesos en jBPMA continuación se va a describir los elementos que definen un proceso en jBPM. Un proceso estádefinido a partir de sus nodos, transiciones y acciones. Para representar un proceso en formagráfica, se puede utilizar el jBPM Graphical Process Designer de Jboss Tools.3.1 NodosDefinen los pasos que que se tienen que seguir durante la ejecución de un proceso, y pueden ser delos siguientes tipos: − Nodos de inicio y fin − Nodo de tarea − Nodo de estado − Nodo de decisión − Nodos fork y join − Nodos node3.1.1 Nodo de inicio (start)Los nodos de inicio delimitan el comienzo de la ejecución de un proceso. Un proceso debe tener unúnico nodo de inicio.En el nodo de inicio se puede configurar una tarea. Si no se configura esta tarea, el nodo se quedaen estado de espera de una señal externa para continuar con la ejecución del proceso.3.1.2 Nodo de tarea (task-node)Representa una o varias tareas que deben ser ejecutadas por una persona. Cuando la ejecución delproceso llega a un nodo de tarea, se crea una instancia de cada tarea (task) en las listas de tareas delos miembros del proceso. El nodo se quedará en estado de espera hasta que el usuario informe de larealización de la tarea.3.1.3 Nodo de estado (state)Es un estado de espera que no requiere de la ejecución de ninguna tarea. Permanece a la espera deuna señal que lance la continuación del proceso.3.1.4 Nodo de decisión (decision)Una decisión se puede modelar de dos formas distintas, en función de si es el proceso o una entidadexterna quien debe tomar la decisión.Si es el propio proceso quien debe tomar la decisión se debe usar un nodo de decisión. Los criteriosde la decisión se pueden especificar: − Añadiendo condiciones a las transiciones, mediante beanshell scripts que devuelven un 8 de 34
  9. 9. Manual de introducción a JBoss jBPM 3.x boolean. Los nodos recorreran sus transiciones examinando las condiciones hasta encontrar la primera transición que cumpla las condiciones. − Mediante una clase DecissionHandler que devuelva la transición a seguir.Si es una entidad externa quien debe tomar la decisión se deberían usar varias transiciones quesalgan de un estado de espera. A este estado de espera se le indicará cual es la transición a seguircuando se relance la ejecución del proceso.3.1.5 Nodo forkUn nodo fork divide la ejecución de un proceso en múltiples ejecuciones concurrentes.3.1.6 Nodo joinUn nodo join recoge todas estas ejecuciones concurrentes antes de continuar con la ejecución delproceso.3.1.7 Nodo nodePermite definir el comportamiento del nodo mediante un elemento Action que se ejecuta cuando elproceso llega al nodo.3.1.8 Nodo de fin (end)Los nodos de fin delimitan el final de la ejecución de un proceso. Un proceso puede tener variosnodos de fin, a los que puede llegar en función de las condiciones de ejecución del proceso. Alllegar a cualquiera de ellos finaliza la ejecución de este flujo.3.2 TransicionesIndican el camino a seguir desde un nodo a otro dentro del proceso. Pueden tener condiciones deguarda las restringen.3.3 AccionesUna acción se ejecuta cuando ocurren determinados eventos en la ejecución de un proceso.Principalmente cuando se entra o se sale de un nodo y cuando se toma una transición. Estasacciones no tienen influencia sobre el flujo de control del proceso. 9 de 34
  10. 10. Manual de introducción a JBoss jBPM4. Ejemplo de proceso simpleUna vez realizada la instalación de la herramienta jBPM y de haber visto los componentes de unproceso de negocio, se va a proceder a presentar un ejemplo de un proceso en jBPM. En el artículode instalación de Jboss Tools se creó un proyecto Simple que definía en proceso simple en jBPM. Seva a estudiar este ejemplo para empezar a comprender cómo trabajar con jBPM.En primer lugar hay que ir a la definición de dicho proceso, que se encuentra en el archivoprocessdefinition.xml del paquete simple del directorio src/main/jpdl. Al hacer doble clic sobre estearchivo se puede ver este proceso modelado de forma gráfica en el jBPM Graphical ProcessDesigner:El proceso simple está compuesto de tres nodos y dos transiciones: − Nodo start: Nodo inicial. − Nodo first: Nodo intermedio de estado. − Nodo end: Nodo final del proceso. − Transición to_state: Transición que lleva del nodo start al nodo first. − Transición to_end: Transición que va del nodo first al nodo end.Las dos transiciones tienen asociadas una acción definida a través del manejadorMessageActionHandler:package com.sample.action;import org.jbpm.graph.def.ActionHandler;import org.jbpm.graph.exe.ExecutionContext; 10 de 34
  11. 11. Manual de introducción a JBoss jBPM 3.xpublic class MessageActionHandler implements ActionHandler { private static final long serialVersionUID = 1L; /** * The message member gets its value from the configuration in the * processdefinition. The value is injected directly by the engine. */ String message; /** * A message process variable is assigned the value of the message * member. The process variable is created if it doesnt exist yet. */ public void execute(ExecutionContext context) throws Exception { context.getContextInstance().setVariable("message", message); }}Esta acción guarda en el contexto de la instancia de proceso la variable message, cuyo valor estádefinido dentro de las propiedades de la acción.Vamos a probar la ejecución de este proceso mediante la clase de test SimpleProcessTest:package com.sample;import junit.framework.TestCase;import org.jbpm.graph.def.ProcessDefinition;import org.jbpm.graph.exe.ProcessInstance;public class SimpleProcessTest extends TestCase { public void testSimpleProcess() throws Exception { // Extract a process definition from the processdefinition.xml file. ProcessDefinition processDefinition = ProcessDefinition. parseXmlResource("simple/processdefinition.xml"); assertNotNull("Definition should not be null", processDefinition); // Create an instance of the process definition. ProcessInstance instance = new ProcessInstance(processDefinition); assertEquals( "Instance is in start state", instance.getRootToken().getNode().getName(), "start"); assertNull( "Message variable should not exist yet", instance.getContextInstance().getVariable("message")); // Move the process instance from its start state to the first state. // The configured action should execute and the appropriate message // should appear in the message process variable. 11 de 34
  12. 12. Manual de introducción a JBoss jBPM instance.signal(); assertEquals( "Instance is in first state", instance.getRootToken().getNode().getName(), "first"); assertEquals( "Message variable contains message", instance.getContextInstance().getVariable("message"), "Going to the first state!"); // Move the process instance to the end state. The configured action // should execute again. The message variable contains a new value. instance.signal(); assertEquals( "Instance is in end state", instance.getRootToken().getNode().getName(), "end"); assertTrue("Instance has ended", instance.hasEnded()); assertEquals( "Message variable is changed", instance.getContextInstance().getVariable("message"), "About to finish!"); }}Lo primero que hace este método de prueba es leer la definición del proceso del archivosimple/processdefinition.xml. A continuación crea un nueva instancia del proceso simple ydespués manda una señal a la instancia creada para que pase al primer estado. Por último, se envíaotra señal a la instancia para que vaya al estado final y termine la ejecución del proceso.En este ejemplo se ha visto cómo crear instancias de un proceso a partir de un archivo de definiciónde proceso, que puede ser creado de forma gráfica. También se ha visto cómo se realiza la ejecuciónde un proceso. 12 de 34
  13. 13. Manual de introducción a JBoss jBPM 3.x5. Persistencia de procesosEn el apartado anterior se ha visto cómo ir recorriendo el flujo de ejecución de una instancia de unproceso de forma local. El estado de esta ejecución se guarda en memoria y cuando esta termina noqueda rastro de ella.Sin embargo, lo normal es que un proceso no se ejecute de esta forma, sino que haya ocasiones enque se mantenga a la espera de que ocurra algún evento o de que algún actor realice una tarea antesde reanudar la ejecución. Por ello, toda la información relativa a la ejecución del proceso debepersistir en una base de datos de la que poder recuperar cuando sea preciso.Para la persistencia en bases de datos, jBPM utiliza Hibernate. Por tanto, lo primero que hay quehacer es realizar la configuración adecuada para la base de datos en el archivo hibernate.config.xml.Dentro del proyecto que hemos creado, en la carpeta src/main/config se pueden encontrar variosejemplos de configuración para las distintas bases de datos soportadas. Hay que sustituir elcontenido del archivo hibernate.config.xml por el de hibernate.config.mysql.xml y hacer un cambiopara que no se vuelva a crear el esquema de la base de datos cada vez que se cargue laconfiguración, que va a ser comentar la línea:<property name="hibernate.hbm2ddl.auto">create</property>También hay que añadir la librería del conector de MySQL que contiene el driver JDBC a la base dedatos.Una vez hecho esto, se va a ver cómo se maneja la persistencia en jBPM. Lo primero es cargar laconfiguración de jBPM, que se guarda en el archivo jbpm.cfg.xml, de la siguiente manera:// Se carga la configuración de jBPMJbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();Para poder realizar operaciones de persistencia se debe crear un contexto jBPM:// Se crea un contexto jBPMJbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();Una vez creado este contexto, se pueden realizar operaciones de persistencia. Cuando se hayanfinalizado estas operaciones, se debe cerrar el contexto:// Se cierra el contexto jBPMjbpmContext.close();Como ejemplo vamos a crear una instancia del proceso simple:// Se obtiene un GraphSession que prmite realizar operaciones adicionales// sobre los grafos de procesos 13 de 34
  14. 14. Manual de introducción a JBoss jBPMGraphSession graphSession = jbpmContext.getGraphSession();// Busca la última versión del proceso simpleProcessDefinition processDefinition = graphSession.findLatestProcessDefinition("simple");// Se crea una nueva instancia del proceso simpleProcessInstance processInstance = new ProcessInstance(processDefinition);// Se buscan las instancias del proceso simpleList processInstances = graphSession.findProcessInstances(processDefinition.getId());for (Object object : processInstances) { processInstance = (ProcessInstance)object; System.out.println("Se ha creado la instancia: " + processInstance.getId() + " del proceso: " + processDefinition.getName());}Ahora se puede revisar la base de datos y comprobar la creación de esta instancia en la tablaJBPM_PROCESSINSTANCE. También se puede ver en la tabla JBPM_TOKEN el token deejecucion de esta instancia. En el campo NODE de esta tabla se indica en que nodo del flujo seencuentra la ejecución de este proceso.De esta manera, se ha creado una instancia del proceso simple que está preparada para su ejecución.Para ello, un usuario debería recuperar esta instancia del contexto de la siguiente forma:// Se carga la configuración de jBPMJbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();// Se crea un contexto jBPMJbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();// Se obtiene un GraphSession que permite realizar operaciones adicionales// sobre los grafos de procesosGraphSession graphSession = jbpmContext.getGraphSession();// Busca la última versión del proceso simpleProcessDefinition processDefinition = graphSession.findLatestProcessDefinition("simple"); 14 de 34
  15. 15. Manual de introducción a JBoss jBPM 3.x// Se buscan las instancias del proceso simpleList processInstances = graphSession.findProcessInstances(processDefinition.getId());for (Object object : processInstances) { ProcessInstance processInstance = (ProcessInstance)object; // Se comprueba si esta instancia ha concluido if(!processInstance.hasEnded()) { System.out.println( "Se va a enviar una señal a la instancia: " + processInstance.getId()); // Se arranca la ejecución de esta instancia processInstance.signal(); System.out.println( "Se ha enviado una señal a la instancia: " + processInstance.getId()); } else { System.out.println( "Ya ha terminado la instancia: " + processInstance.getId()); }}Con esto se ha visto cómo usar la persistencia de jBPM para crear una instancia de un proceso yposteriormente recuperar esta instancia y continuar con su ejecución. 15 de 34
  16. 16. Manual de introducción a JBoss jBPM6. Uso de un nodo nodeUn nodo node permite definir su comportamiento mediante un elemento Action que se ejecutacuando el proceso llega al nodo.La acción que se ejecuta se puede definir de dos formas: − Mediante una expresión bean shell script. − A través de una manejador de acción, una clase que implementa la interfaz ActionHandler.A continuación se va a crear como ejemplo un proceso que contiene un nodo node que utiliza unaimplementación de ActionHandler para conocer la transición a seguir.En la siguiente imagen se puede ver el proceso de ejemplo:Este proceso empieza en un nodo de inicio ya pasa a un nodo node donde se realiza la acciondefinida por la clase Accion que implementa la interfaz ActionHandler:public class Accion implements ActionHandler { @Override public void execute(ExecutionContext executionContext) throws Exception { System.out.println("Se realiza la accion programada..."); // Se pasa automáticamente al siguiente nodo executionContext.getProcessInstance().signal(); }}La última línea de esta acción provoca un salto inmediato al siguiente nodo, que en este caso setrata del nodo final fin. 16 de 34
  17. 17. Manual de introducción a JBoss jBPM 3.x7. Uso de un nodo de decisiónUn nodo de decisión se usa para modelar un punto en el flujo en que el propio proceso toma unadecisión sobre el camino a seguir. Los criterios de la decisión se pueden especificar de las siguientesformas: − Añadiendo condiciones a las transiciones o beanshell scripts que devuelven un boolean. Los nodos recorreran sus transiciones examinando las condiciones hasta encontrar la primera transición que cumpla las condiciones. − Mediante una implementación de la interfaz de DecissionHandler que devuelve la transición a seguir.A continuación se va a crear como ejemplo un proceso que contiene un nodo de decisión que utilizauna implementación de DecissionHandler para conocer la transición a seguir.En la siguiente imagen se puede ver el proceso de ejemplo:Este proceso empieza en un nodo de inicio del que se sale mediante la transición comenzar. Estatransición tiene una acción crearvalor manejada por la clase ValorAction, que se encarga deintroducir en el contexto de ejecución una variable valor:public class ValorAction implements ActionHandler { public String valor; @Override public void execute(ExecutionContext executionContext) throws Exception { executionContext.getContextInstance().setVariable("valor", valor); }}A continuación se llega a un nodo de decision manejado por una clase Decisor, que comprueba si enel contexto de ejecución existe una variable valor con un valor asignado. Si existe esta variable seabandona el nodo por la transición terminar1 y si no, por la transición terminar2:public class Decisor implements DecisionHandler { public Decisor(String info) { super(); } @Override 17 de 34
  18. 18. Manual de introducción a JBoss jBPM public String decide(ExecutionContext executionContext) throws Exception { String valor = (String)executionContext.getContextInstance().getVariable("valor"); if(valor != null) { return "terminar1"; } else { return "terminar2"; } }}Por último, al llegar a cualquiera de los nodos finales se lanza una acción que muestra en que nodoestá terminando la ejecución del flujo, manejada por la clase MostrarMensajeAction:public class MostrarMensajeAction implements ActionHandler { public MostrarMensajeAction(String info) { super(); } @Override public void execute(ExecutionContext executionContext) throws Exception { System.out.println( "Se sale del flujo por el nodo: " + executionContext.getNode().getName()); }}Se puede ejecutar este proceso mediante una clase de test como esta:public void testSimpleProcess() throws Exception { // Extraer la definicion de proceso del archivo processdefinition.xml. ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("decision/processdefinition.xml"); assertNotNull("La definicion debe no ser nula", processDefinition); // Create an instance of the process definition. 18 de 34
  19. 19. Manual de introducción a JBoss jBPM 3.x ProcessInstance instance = new ProcessInstance(processDefinition); assertEquals( "La instancia está en el estado inicial", instance.getRootToken().getNode().getName(), "inicio"); assertNull( "La variable valor no debe existir todavía", instance.getContextInstance().getVariable("valor")); // Mueve la instancia de proceso desde el estado inicial al primer estado. instance.signal();}Si en la configuración se ha introducido un valor para la variable valor, por la consola se verá unmensaje que indica que ha terminado en el nodo final1. En caso contrario se termina en el nodofinal2. 19 de 34
  20. 20. Manual de introducción a JBoss jBPM8. Uso de un nodo de tareaA continuación se va a exponer cómo crear tareas en jBPM y asignar qué actor o actores las debenrealizar. Esto permite a los actores responsables de su realización recoger las tareas pendientes queexistan en un determinado momento para completar su ejecución.En primer lugar vamos a crear una definición de proceso llamada tarea formada por un nodo inicial,un nodo de tarea y un nodo final:Como ya se ha mencionado anteriormente, un nodo de tarea representa una o varias tareas quedeben ser ejecutadas por una persona. Cuando la ejecución del proceso llega a un nodo de tarea, secrea una instancia de una tarea (task) en la lista de los miembros del workflow. El nodo se quedaráen estado de espera hasta que el usuario informe de la realización de la tarea.Para crear una tarea en un nodo de tarea, vamos a las propiedades de este nodo. En la tabla de tareaspulsamos el botón derecho del ratón y seleccionamos New Task. Le damos nombre a esta tarea, eneste caso algoquehacer y descripción si queremos. En el apartado Assignment, vemos que hayvarias formas de asignar un tarea: − Actor: Se le indica el actorId, que es un String que identifica el actor responsable de la tarea. Cuando se crea la tarea al entrar al nodo de tarea, esta tarea pasa inmediatamente a la lista de actividades pendientes de este actor. − Pooled Actor: Se le indica una secuencia de actorId separados por comas. Esta tarea al ser creada no es asignada a la lista de ningún actor. Un actor la debe recuperar de la lista de tareas pendientes para el pool de actores y asignarsela para que forme parte de su lista de tareas. − Swimlane: Un swimlane o carril sirve para definir una asignación que es la misma para varias tareas de un proceso. − Expression: Se le indica una expresión de asignación evaluada por el componente de identidad de jBPM. Permite realizar asignaciones en función del usuario, grupo o rol. − Handler: Se le indica una clase manejadora, que será la que realice la asignación de la tarea.Para mantener el ejemplo sencillo vamos a realizar la asignación de la tarea a un actor, al que vamosa llamar user1:Después de desplegar este proceso en el servidor, vamos a realizar una prueba en dos pasos. En elprimer paso vamos a crear una instancia de este proceso tarea y a iniciar su ejecución. Esto es algoque ya hemos visto:// Se carga la configuración de jBPMJbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();// Se crea un contexto jBPM 20 de 34
  21. 21. Manual de introducción a JBoss jBPM 3.xJbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();// Se obtiene un GraphSession que permite realizar operaciones adicionales// sobre los grafos de procesosGraphSession graphSession = jbpmContext.getGraphSession();// Busca la última versión del proceso simpleProcessDefinition processDefinition = graphSession.findLatestProcessDefinition("tarea");// Se crea una nueva instancia del proceso simpleProcessInstance processInstance = new ProcessInstance(processDefinition);// Se pasa al nodo tareaprocessInstance.signal();// Se cierra el contexto jBPMjbpmContext.close();Se puede ver en la tabla JBPM_TASKINSTANCES de la base de datos una instancia de la tareaalgoquehacer asignada al usuario user1 pendiente de ser ejecutada, es decir, no esta marcada comoterminada. Vamos a recuperar los procesos pendientes para el usuario user1 gracias a la claseTaskManagementSession y a informar de la finalización de esta tarea:// Se carga la configuración de jBPMJbpmConfiguration jbpmConfiguration = JbpmConfiguration.getInstance();// Se crea un contexto jBPMJbpmContext jbpmContext = jbpmConfiguration.createJbpmContext();TaskMgmtSession tms = jbpmContext.getTaskMgmtSession();String actorId = "user1";List instances = tms.findTaskInstances(actorId);for (TaskInstance taskInstance : instances) { System.out.println( "Tarea pendiente de ejecutar por " + actorId +":" 21 de 34
  22. 22. Manual de introducción a JBoss jBPM + taskInstance.getName() + taskInstance.getId()); // Se informa de la finalización de la tarea taskInstance.end();}// Se cierra el contexto jBPMjbpmContext.close();Se ha visto como asignar una tarea a un actor y de como recuperar las tareas pendientes de un actoren un proceso posterior para llevar a cabo su ejecución. 22 de 34
  23. 23. Manual de introducción a JBoss jBPM 3.x9. Uso de un nodo de correoEn este artículo se muestra un ejemplo de uso de un nodo node dentro de un proceso.Para poder probar el funcionamiento del envío de mensajes, lo primero que se va a hacer es instalarun servidor de correo.9.1 Instalación de un servidor de correo – Apache James ServerEl servidor Apache James es un servidor de correo electrónico implementado en Java muy fácil deinstalar.En primer lugar se obtienen los archivos binarios de la última versión (2.3.1) de la direcciónhttp://james.apache.org/download.cgi#Apache%20James%20Server. Se tiene así un archivocomprimido que podemos descomprimir en la ruta que nos plazca.Una vez descomprimido, vamos a la carpeta bin y ejecutamos el archivo run.bat (si estamos enWindows). Con ello se arranca el servidor, apareciendo una pantalla como la siguiente:Lo siguiente es la configuración de usuarios de correo. Para ello se abre una ventana de terminal yse ejecuta >telnet localhost 4555. Con ello se accede a la herramienta de administración remota delservidor, en la que hay que registrarse como usuario root con el mismo password root. Acontinuación se crean dos usuarios user y user2 que se van a usar para las pruebas:En un cliente de correo electrónico, como Thunderbird, se configura la cuenta de correo de 23 de 34
  24. 24. Manual de introducción a JBoss jBPMelectrónico para el usuario user. El password es también user y todos los servidores que se pidenson localhost. Así, el usuario user ya puede enviar y recibir correo a través del servidor que hemosinstalado.Para probar esta configuración, se va a crear un proyecto en eclipse, con una clase de prueba queenvía un correo electrónico del usuario user2 al usuario user:import java.util.*;import javax.mail.*;import javax.mail.internet.*;public class MailClientextends Authenticator{ protected String from; protected Session session; protected PasswordAuthentication authentication; public MailClient(String user, String host) { this(user, host, false); } public MailClient(String user, String host, boolean debug) { from = user + @ + host; authentication = new PasswordAuthentication(user, user); Properties props = new Properties(); props.put("mail.user", user); props.put("mail.host", host); props.put("mail.debug", debug ? "true" : "false"); props.put("mail.store.protocol", "pop3"); props.put("mail.transport.protocol", "smtp"); session = Session.getInstance(props, this); } public void sendMessage( String to, String subject, String content) throws MessagingException { System.out.println("SENDING message from " + from + " to " + to); System.out.println(); MimeMessage msg = new MimeMessage(session); msg.addRecipients(Message.RecipientType.TO, to); msg.setSubject(subject); msg.setText(content); Transport.send(msg); } public static void main(String[] args) throws Exception { MailClient user2Client = new MailClient("user2", "localhost"); user2Client.sendMessage( "user@localhost", "Prueba", "Mensaje de prueba"); 24 de 34
  25. 25. Manual de introducción a JBoss jBPM 3.x }}Ahora, al ejecutar esta clase de ejemplo, se debería recibir un mensaje en el cliente de correo en quese ha configurado la cuenta del usuario user:9.2 Implementación del proceso de ejemploUna vez configurado el servidor de correo, se va a crear un proceso de prueba, formado por un nodode inicio, un nodo de correo y un nodo de fin:Se configura el nodo de correo para que envíe un correo al usuario user, como se ha mostrado en laimagen anterior. 25 de 34
  26. 26. Manual de introducción a JBoss jBPMPara probar este proceso se crea una clase de prueba que únicamente crea una instancia del procesoy lanza su ejecución:package com.sample;import junit.framework.TestCase;import org.jbpm.graph.def.ProcessDefinition;import org.jbpm.graph.exe.ProcessInstance;public class ProcessTest extends TestCase { public void testProcess() throws Exception { // Obtener la definición del proceso ProcessDefinition processDefinition =ProcessDefinition.parseXmlResource("nodocorreo/processdefinition.xml"); // Crear una instancia del proceso ProcessInstance instance = new ProcessInstance(processDefinition); // Saltar desde el nodo de inicio instance.signal(); }}Si se ejecuta esta prueba, se debería recibir un mensaje en el cliente de correo en que se haconfigurado la cuenta del usuario user: 26 de 34
  27. 27. Manual de introducción a JBoss jBPM 3.x10. Consola de administración de jBPMLa instalación de jBPM en JBoss incluye una aplicación web de administración de jBPM, llamadajBPM Administration Console, a la que se puede acceder a través de la URLhttp://localhost:8080/jbpm-console. Esta aplicación, implementada en JSF, permite controlargrupos, usuarios, procesos, tareas y trabajos(jobs).Antes de empezar a trabajar con ella, en primer lugar hay que crear varias entidades, puesto que estaaplicación requiere registro de usuario.10.1 Registro de usuario en la consola de administración de jBPMLa consola de administración tiene una serie de roles definidos que permiten realizar determinadascategorías: − admin: Administrador de la herramienta. Permite la administración de usuarios y procesos (creación y eliminación de los mismos). − manager: Gestor de procesos y tareas. Permite desplegar y arrancar procesos y reasignar tareas. − user: Usuario de la herramienta. Solamente podrá realizar las tareas que se le hayan asignado.Para cada estos roles se va a crear un grupo con el mismo nombre, de tipo security-role, que indicaque se trata de una agrupación relacionada con la seguridad de la aplicación:INSERT INTO JBPM_ID_GROUP VALUES(1,G,admin,security-role,NULL);INSERT INTO JBPM_ID_GROUP VALUES(2,G,manager,security-role,NULL);INSERT INTO JBPM_ID_GROUP VALUES(3,G,user,security-role,NULL);Para cada estos grupos se crea un usuario con el mismo nombre:INSERT INTO JBPM_ID_USER VALUES(1,U,admin,admin@sample.domain,admin);INSERT INTO JBPM_ID_USERVALUES(2,U,manager,manager@sample.domain,manager);INSERT INTO JBPM_ID_USER VALUES(3,U,user,user@sample.domain,user);Se establece una relación de pertenencia entre cada usuario del grupo del mismo nombre y de todoslos usuarios con el grupo user:INSERT INTO JBPM_ID_MEMBERSHIP VALUES(1,M,NULL,NULL,1,1);INSERT INTO JBPM_ID_MEMBERSHIP VALUES(2,M,NULL,NULL,1,3);INSERT INTO JBPM_ID_MEMBERSHIP VALUES(3,M,NULL,NULL,2,2);INSERT INTO JBPM_ID_MEMBERSHIP VALUES(4,M,NULL,NULL,2,3);INSERT INTO JBPM_ID_MEMBERSHIP VALUES(5,M,NULL,NULL,3,3);A partir de este momento ya se puede usar la aplicación. 27 de 34
  28. 28. Manual de introducción a JBoss jBPM10.2 Ejemplo de uso de la consola de administración de jBPMAhora se va a mostrar un ejemplo de manejo de un proceso a través de la consola de administraciónde jBPM.En primer lugar, se crea un proceso con un nodo de inicio (Comenzar proceso), un nodo de tarea(Realizar tarea) y un nodo de fin (Fin proceso):Se configura la tarea del nodo de inicio para que se realice la asignación por actor. No se defineningún actor, puesto será el actor que inicie el proceso al que se asignará esta tarea:Se crea una tarea en el nodo de tarea y se asigna al actor user: 28 de 34
  29. 29. Manual de introducción a JBoss jBPM 3.xA continuación se despliega el proceso. Una vez desplegado se entra en la consola deadministración como usuario manager. Dentro del apartado de procesos se mostrará una lista de losprocesos desplegados:Pulsando en Start dentro del proceso asignaciontareas se lanzará una nueva ejecución de esteproceso: 29 de 34
  30. 30. Manual de introducción a JBoss jBPMEsto ha llevado a la página que muestra la información relacionada con la ejecución de proceso quese acaba de lanzar. Si se selecciona Process Image se puede ver la situación actual de estaejecución:Como se puede apreciar, esta ejecución todavía se mantiene en el estado inicial. Se puede ir aPersonal/Group Tasks para ver las tareas que tiene pendientes el usuario manager: 30 de 34
  31. 31. Manual de introducción a JBoss jBPM 3.xEl usuario manager tiene asignada la tarea de comenzar el proceso. Para comenzar la realización deesta tarea, se pincha en Start:Ahora el usuario manager realizaría las operaciones necesarias para la ejecución de esta tarea. Unavez que se hayan realizado, se pulsa en End y se ve que la tarea pendiente ha desaparecido de lalista de tareas pendientes del usuario manager.Yendo a Processes aparecería de nuevo la lista de procesos desplegados. Pinchando en Examinesobre el proceso desplegado, se pueden ver las ejecuciones en activo de este proceso:Pinchando en Examine sobre la ejecución en activo de este proceso, se pueden ver las tareaspendientes de esta ejecución: 31 de 34
  32. 32. Manual de introducción a JBoss jBPMSe aprecia que existe una tarea pendiente asignada al usuario user. El usuario manager tienepermisos para ejecutar cualquier tarea en nombre de otro usuario, por eso aparece la opción Startpara esta tarea. Si pinchamos en Process Image, se puede ver la situación actual de esta instanciadel proceso:Hay que desconectarse y a volver a registrarse como usuario user para realizar la tarea que tieneasignada. Si vamos a la lista de tareas de este usuario: 32 de 34
  33. 33. Manual de introducción a JBoss jBPM 3.xAhora se podría realizar esta tarea de la misma manera que hizo antes el usuario manager. Una vezrealizada esta tarea la instancia del proceso pasaría al nodo final y terminaría su ejecución. 33 de 34
  34. 34. Manual de introducción a JBoss jBPMConclusionesEl presente manual está siendo realizado durante el aprendizaje de la herramienta jBPM. No es másque la compilación de los pequeños artículos que estoy escribiendo en mi blog(http://tratandodeentenderlo.blogspot.com). Estoy tratando de plasmar en ellos la experienciaadquirida durante el aprendizaje de jBPM, aunque mi intención es escribir sobre otros temas deinterés, también relacionados con el mundo Java.Aunque este manual contiene suficiente información para ayudar a los usuarios inexpertos en suintroducción a jBPM, es mi intención seguir ampliándolo. Para ello agradecería que todo aquellector que tenga alguna duda o sugerencia sobre el material presentado en este documento me lahiciese llegar por correo electrónico (jorge.roldan@gmail.com) o como comentarios a través de miblog. 34 de 34

×