Como veis hay un paquete basico.init donde se va a iniciar la aplicación, un paquete basico.action donde está el handle de las acciones que definamos en los workflows y un directorio almacen-jPDL donde voy a almacenar el/los workflow/s que vayamos haciendo.

Para crear un nuevo workflow… botón derecho sobre el directorio donde lo quereis crear y elegir New, Other,  process definition.

El workflow es muy simple, simplemente simulará el encendido de un botón y finalizará el workflow

Después de dibujarlo, hay que añadir las acciones… a mi me resulta más comodo hacerlo por código, modificar el xml directamente. El contenido es el siguiente :

<?xml version=”1.0″ encoding=”UTF-8″?>

<process-definition  xmlns=”urn:jbpm.org:jpdl-3.3″  name=”Boton”>
<start-state name=”Inicio”>
<transition to=”Boton ON” name=”Pulsa Boton”>
<action name=”action” class=”basico.action.MessageActionHandler”>
<message>Pulsando Boton</message>
</action>
</transition>
</start-state>
<node name=”Boton ON”>
<action name=”action” class=”basico.action.MessageActionHandler”>
<message>Boton en posicion ON</message>
</action>
<transition to=”Fin” name=”Fin”>
<action name=”action” class=”basico.action.MessageActionHandler”>
<message>Proceso terminado</message>
</action>
</transition>
</node>
<end-state name=”Fin”></end-state>
</process-definition>

La aplicación donde cargaremos y ejecutaremos el workflow es la siguiente :

package basico.init;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;

public class Start {

public static void main(String[] args) throws FileNotFoundException {
FileInputStream fis = new FileInputStream(“almacen-jPDL/Boton/processdefinition.xml”);
ProcessDefinition processDefinition = ProcessDefinition.parseXmlInputStream(fis);
ProcessInstance instance = new ProcessInstance(processDefinition);
instance.signal(“Pulsa Boton”);
instance.signal(“Fin”);
}
}

Simplemente cargamos el fichero processdefinition.xml, parseamos el xml en la estructura ProcessDefinition y creamos una instancia del workflow. Con esto ya tendremos nuestro workflow preparado para recibir las ordenes.

La primera es “Pulsa Boton” que nos llevará al nodo Boton ON y ejecutará una acción… esta acción se define aqui :

package basico.action;

import org.jbpm.graph.def.ActionHandler;
import org.jbpm.graph.exe.ExecutionContext;

public class MessageActionHandler implements ActionHandler {

private static final long serialVersionUID = 1L;

String message;

public void execute(ExecutionContext context) throws Exception {
context.getContextInstance().setVariable(“message”, message);
System.out.println(message);
}
}

El resultado final una vez ejecutado el workflow son los siguientes mensajes en la pantalla

Pulsando Boton
Boton en posicion ON
Proceso terminado

Fácil no?

Ahora os podeis bajar el código del ejemplo aquí

Lo primero, vamos a iniciar el proyecto…

Elegimos Process Project y procedemos a darle un nombre

Nos pide configurar el JBoss jBPM Runtime… asi que buscamos el directorio donde nos hayamos instalado

el jBPM, sigo a partir del tutorial donde explico la instalacion del jBPM 3.3.0GA.

El nombre se lo poneis vosotros… que sea un nombre característico, porque ireis actualizando las librerias con nuevas versiones que si no vais con un poco de cuidado se lia bastante la cosa.

A continuación elegis el Core jBPM al que le habeis dado nombre en el paso anterior y seleccionais el cuadro para que te genere el simple process definition, action handler y JUnit test. Generalmente es más fácil empezar con esto aunque para el ejemplo básico voy a crear el proyecto totalmente vacio.

Le dais a finalizar y ya teneis la estructura necesaria para empezar.

He encontrado también un video bastante majo para empezar, aunque es de una versión más antigua, os puede ayudar bastante. Aprovecha toda la estructura visual de eclipse… se configura todo por menus y tal… el mio será totalmente por código.

Demo jBPM

Hace poco salió el jBPM 3.3.0GA, y ha tocado pelearse un poco por un par de problemillas… Lo primero es que ya te viene con un bonito instalador con el que tropecé un par de veces (alguna torpeza mia, alguna error que otro del jbpm y algún error que otro de descarga de paquetes…).
En el menú te permite descargarte opcionalmente el Eclipse, el JBoss 4.2.2 y la GWT Console… si estais empezando de cero, bajaros todo… aunque recomiendo bajaros aparte el Eclipse, por claridad más que nada.

Una vez instalado todo, podeis seguir las instrucciones que puse en el post anterior “Instalando jBPM en eclipse 3.4″. a partir de la instalación de las jBossTools.

Eso si… en esta versión hay un pequeño (o gran) error por ahi, como bien nos comentan en el foro de jboss jBPM

“Problems with jBPM 3.3.0 GA and the GPD” . La solución es bien sencilla… simplemente modificar el archivo ‘version.info.xml’ en ’src/resources/gpd’ por esto :

<jbpm-version-info name="jBPM3" namespace="urn:jbpm.org:jpdl-3.3">

  <classpathentry path="lib/jbpm-jpdl.jar" src="src/jbpm-jpdl-sources.jar" />
  <classpathentry path="lib/jbpm-identity.jar" src="src/jbpm-identity-sources.jar" />

  <classpathentry path="lib/antlr.jar" />
  <classpathentry path="lib/asm.jar"/>
  <classpathentry path="lib/bsh.jar"/>
  <classpathentry path="lib/cglib.jar"/>
  <classpathentry path="lib/commons-collections.jar"/>
  <classpathentry path="lib/commons-logging.jar"/>
  <classpathentry path="lib/dom4j.jar"/>
  <classpathentry path="lib/hibernate.jar"/>
  <classpathentry path="lib/hsqldb.jar"/>
  <classpathentry path="lib/junit.jar"/>
  <classpathentry path="lib/log4j.jar"/>

  <config path="config"/>
  <examples path="examples" />

</jbpm-version-info>

También ha salido hace prácticamente una semana el jBPM 4.0.0Alpha, pero mejor me espero un poquillo que los “Alpha” son muy traicioneros…

Process definition : Representa una especificacion formal de un proceso de negocio y esta basado en un grafo dirigido. El grafo esta compuesto por nodos y transiciones. Cada nodo en el grafo es de un tipo específico y este define su comportamiento en tiempo de ejecución.

Token : Es la ejecucion de un “camino” o “ruta”. Un token es el concepto en tiempo de ejecucion que mantiene un puntero a un nodo en el grafo.

Process Instance : Ejecucion de un process definition. Cuando una instancia se crea, lo hace tambien un token, este es llamado por el “root” token de la instancia del proceso que lo posicionara en el estado inicial.

Signal : Insta al token a continuar la ejecucion del grafo. Digamos que es la señal que ahce que avance nuestro camino por el grafo. Si hay varias transiciones el signal deberia estar acompañado de un identificador que le diga que camino seguir, sino por defecto seguira el primero definido.

Nodes : Cuando un token entra en un nodo, este se ejecuta, son los responsables ellos mismos de la continuacion de la ejecucion del grafo. Como he dicho antes cada tipo de nodo implementa un comportamiento diferente de la ejecucion del grafo. Un nodo que no propaga su ejecución se comportará como un State.

El nodo tiene dos funciones principales:

    * Ejecutar codigo java (que hará la funcion del nodo)

    * Propagar la ejecucion del grafo, y ante esto tiene varias opciones :

• No propagarlo : Con lo que se quedaria como un estado de espera.
• Propagarlo a través de una transición
• Crear una nueva ruta de ejecución. Un nodo puede crear un nuevos tokens y tener nuevas rutas (como lo hace el fork)
• Finalizar la ruta de ejecucion.

- En general, un nodo puede cambiar la estructura entera de la instancia del proceso. La estructura en tiempo de ejecucion es una instancia de proceso que contiene un arbol de tokens. Cada token representa una ruta de ejecucion. Un nodo puede crear y finalizar tokens, poner cada token en un nodo del grafo y lanzar tokens sobre transiciones.

Tipos: Ya os comentaré los tipos de nodos y su función dentro del modelado de procesos. Por ahora os nombro los que son :

    * Node Task

    * State

    * Fork and Join

    * Decision

    * Node

Transitions : Las transiciones tienen un nodo origen y uno destino, puede tener un nombre (lo mas recomendable es darle un nombre siempre, porque mas de un problema he tenido por esto ). En caso de que tengan el mismo nombre dos transiciones siempre cogerá la primera transición que se definió.

Actions : Codigo java que se ejecutan en los eventos producidos en la ejecución del proceso. Digamos que son los detalles tecnicos y estos no se contemplan graficamente. Hay que diferenciar entre las acciones que se disparan mediante eventos y las acciones que se colocan en un nodo. Las primeras no tienen influciencia sobre el flujo del proceso mientras que la accion que se pone en el nodo tiene la responsabilidad de propagar la ejecución.

Events : Son las ocurrencias definidas en el grafo, los principales son entrar en un nodo, dejar el nodo o coger una transicion.

Swimlanes : Representa roles y su mision principal es dar tareas a una persona o grupo de personas. No son visuales, así que no podremos ver a quien corresponde cada tarea simplemente viendo la representación del grafo.

Process Variables : Datos contextuales que una instancia de proceso construye durante su ejecución.

Process State : Usado cuando necestamos modelar subprocesos que ajusten con procesos de mas alto nivel. Permite mayor abstraccion para proyectos de gran envergadura.

Super State : Es una manera de modelar un grupo de nodos, esto nos ayudará a crear una jerarquía dentro del process definition.

Process graph : Grafo hecho con nodos y transiciones. En jBPM viene especificado por el fichero processdefinition.xml.

Un libro muy ameno e interesante, hecho para los analistas de negocio (bussiness analysts) o para programadores que empiezan a iniciarse en este mundillo.

La cosa es que el libro empieza planteandote un proyecto software, dando detalles de todo tipo, desde las personas que deberian participar en el proyecto hasta la instalación y programación del jbpm y mysql. Eso si, sin una sola línea de código, cosa que agradeceran los analistas y que igual se le queda un poco corto a los programadores, aunque cuando terminas el libro sabes usar perfectamente la interfaz jBPM y entiendes la estructura y lo que pretendian los programadores de jBPM al hacer cada pestaña del workframe.

También como he dicho se toca la parte de base de datos, hace un repasito de Hypersonic y se pone a trabajar con mySQL creando e insertando tablas,recuperando datos… vamos lo justito para que se pueda entender todo.

Y para finalizar, jugamos un poco monitorizando la aplicación, y nos presenta la plataforma SeeWhy para estas lides y para interpretar los datos que nos vienen del servidor jbpm.

En conclusion un libro muy interesante que nos presenta un proyecto muy bien elaborado y organizado, desde su etapa de recogida de requerimientos hasta la puesta en marcha y presentacion de datos finales.

Para ver un poco que puede hacer, vamos a jugar un poco con el HSQL Database Manager, el cual esta muy bien escondidito entre los recursos del JBoss. Lo primero de todo es encender el JBoss application server que hay incorporado en la distribución de jBPM (JBPM_PATH\server\start.bat). Este ya tiene todo configurado para que su gestor de base de datos por defecto sea Hypersonic.

En la dirección http://localhost:8080/jmx-console/ podemos arracar esta aplicación, simplemente hay que pinchar en la linea que pone database = jbpmDB, service = Hypersonic en el apartado jboss.

Te llevara a una pagina con las funciones disponibles para el hypersonic, ahí le damos al botón Invoke en la linea que pone startDatabaseManager(). A los pocos segundos verás aparecer en tu pantalla la aplicación.

Es bastante sencillita y si estas familiarizado con SQL no creo que tengas ningún problema en probar cosas.

Puedes probar con un Select * from PUBLIC.JBPM_ID_GROUP para ver que grupos por defecto estan definidos en jBPM, si quieres añadir alguno nuevo y quieres acceder al jBPM-console para jugar con  tu workflow favorito, acuerdate de modificar (mas bien añadir) el grupo en el archivo web.xml, dentro del paquete jbpm-console.war (el .war puedes descomprimirlo con el winrar mismo) en jbpm-jpdl-3.2.3\server\server\jbpm\deploy.  Miraros ahi las etiquetas <security-role> y <security-constraint>.

Si queremos algo mas robusto, como ya dije, tenemos que ir a parar a MySQL por ejemplo (jBPM también soporta otros muchos gestores que se pueden utilizar como Oracle, DB2, MSQL…)

Lo primero es bajarse el MySQL, la versión más recomendable a fecha de hoy es el 5.0 (http://dev.mysql.com/downloads/mysql/5.0.html).
La Instalacion es bastante sencilla e intuitiva, recomiendo instalar también el MySQL Administrator que viene por separado para tener una ventana gráfica para administrar el gestor, aunque por línea de comando también puedes hacer todo, de hecho lo haré así…

La primera vez que arrancas el MySQL command Line Client te pedirá la contraseña que pusiste durante la instalación, desde aquí ya puedes crear la base de datos que usará jBPM:

Lo siguiente crear la infraestructura que utiliza jBPM, para esto usaremos el fichero jbpm.jpdl.mysql.sql (jBPM_PATH\db) donde estan contenidas todas las tablas y las relaciones necesarias. Así que las siguientes ordenes serán:

mysql>USE jbpmbackend

mysql>source JBPM_PATH\db\jbpm.jpdl.mysql.sql

Si todo va bien veras un montón de Querys OK aparecer por pantalla, cuando todo va bien no deja de ser bonito verlo

También tendrás que añadir tus usuarios, para esto si seria mejor que tuvieras el administrador de mySQL, ten en cuenta el fichero web.xml dentro de jbpm-console.war.

Una vez lista la base de datos hay que decirle al señor JBoss que queremos usar MySQL como gestor de base de datos. Al xml que configura esto se le llama JNDI Data source y se configura en JBPM_PATH\server\server\jbpm\deploy\jbpm-ds.xml (puedes crear otro archivo siempre que termine en -ds.xml)

El contenido del archivo debe quedar mas o menos de la siguiente manera:

<?xml version=”1.0″ encoding=”UTF-8″?>
<datasources>
<local-tx-datasource>
<jndi-name>MySqlDS</jndi-name>
<connection-url>jdbc:mysql://localhost:3306/jbpmbackend</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>root</user-name>
<password>tu_password</password>
<metadata>
<type-mapping>mySQL</type-mapping>
</metadata>

</local-tx-datasource>

</datasources>

Y ya que estamos modificando ficheros, vamos a cambiar un par más…

JBPM_PATH\server\server\jbpm\conf\login-config.xml

<application-policy name = “jbpm”>
<authentication>
<login-module code=”org.jboss.security.auth.spi.DatabaseServerLoginModule”
flag=”required”>
<module-option name=”dsJndiName”>java:/MySqlDS</module-option>
<module-option name=”principalsQuery”>
SELECT PASSWORD_ FROM JBPM_ID_USER WHERE NAME_=?
</module-option>
<module-option name=”rolesQuery”>
SELECT g.NAME_ ,’Roles’
FROM JBPM_ID_USER u,
JBPM_ID_MEMBERSHIP m,
JBPM_ID_GROUP g
WHERE g.TYPE_=’security-role’
AND m.GROUP_ = g.ID_
AND m.USER_ = u.ID_
AND u.NAME_=?
</module-option>
</login-module>
</authentication>
</application-policy>

Aqui insertamos el modo de autenticación del modulo de login, creo que está por defecto, sino lo insertamos, teniendo en cuenta el nombre jndi que hayamos puesto en la configuración anterior.

Y por ultimo el fichero de configuración de Hibernate contenido dentro del jbpm-console.war (en WEB-INF\classes). Hibernate es el que se encarga de la persistencia en jBPM, con lo cual es un archivo de configuración muy importante.

Debe quedar algo tal que así (solo pongo el trocillo que he modificado):

<!– hibernate dialect –>
<property name=”hibernate.dialect”>org.hibernate.dialect.MySQL5Dialect</property>

<!– JDBC connection properties (begin) –>
<property name=”hibernate.connection.url”>jdbc:mysql://localhost:3306/jbpmbackend</property>
<property name=”hibernate.connection.username”>root</property>
<property name=”hibernate.connection.password”>tu_password</property>

<!– JDBC connection properties (end) –>

<property name=”hibernate.cache.provider_class”>org.hibernate.cache.HashtableCacheProvider</property>

<!– DataSource properties (begin) == –>
<property name=”hibernate.connection.datasource”>java:/MySqlDS</property>

A continuación será necesario bajarse el driver de mySQL (creo que no te viene por defecto), se llama MySQL Connector/J y lo podemos encontrar en la siguiente dirección http://dev.mysql.com/downloads/connector/j/5.1.html, lo que necesitamos es el archivo .jar que lo copiaremos en jbpm/lib/mysql-connector-java-5.1.7-bin.jar

Y ya está , en principio debería funcionar, por lo menos a mi si me funciona correctamente. Es un poco mareo todo y hay que ser muy cuidadoso en todos los pasos pero una vez lo configuras ya funciona bien para siempre

Animo con el blog y sigue jugando con jBpm!

( http://salaboy.wordpress.com/ )

Pattern 1 (Sequence)

_______________________________________________________________________

<process-definition
xmlns=”urn:jbpm.org:jpdl-3.1″
name=”simple”>
<start-state name=”start”>
<transition name=”to_state” to=”first”>
<action name=”action” class=”com.sample.action.MessageActionHandler”>
<message>Going to the first state!</message>
</action>
</transition>
</start-state>
<state name=”first”>
<transition name=”to_end” to=”end”>
<action name=”action” class=”com.sample.action.MessageActionHandler”>
<message>About to finish!</message>
</action>
</transition>
</state>
<end-state name=”end”></end-state>
</process-definition>

_______________________________________________________________________

public class SimpleProcessTest extends TestCase {

// Pattern １：Sequence

public void testSimpleProcess() throws Exception {

FileInputStream fis = new FileInputStream(“processes/simple/processdefinition.xml“);
ProcessDefinition processDefinition = ProcessDefinition.parseXmlInputStream(fis);

processInstance instance = new ProcessInstance(processDefinition);
assertEquals(“start state”,instance.getRootToken().getNode().getName(), “start”);

instance.signal();
assertEquals(“first state”,instance.getRootToken().getNode().getName(), “first”);

instance.signal();
assertEquals(“Instance is in end state”,instance.getRootToken().getNode().getName(), “end”);
assertTrue(“Instance has ended”, instance.hasEnded());
}
}

Vamos a ello :

Hay que bajarse la nueva versión de Eclipse :
http://www.eclipse.org/downloads/

Y te la copias donde gustes… asegurate eso si de dejarte un enlace en el escritorio al eclipse.exe, por aquello de la comodidad y tal.

También nos tenemos que bajar el jbpm :

http://www.jboss.org/jbossjbpm/

Y aqui en el apartado downloads tenemos un buen manojo de ficheros a elegir… para no complicarse lo mejor es elegir el suite, que esta todo y bien ordenadito. Te bajas el archivo y lo descomprimes donde quieras, por ejemplo en C:\jBPM\jbpm-jpdl-3.2.3

Ahora añadimos el JBossTools, que es un conjunto de herramientas diseñadas para el servidor JBoss, entre ellas el jBPM y el Hibernate (http://www.jboss.org/tools/download/index.html).

Yo por si acaso siempre me bajo las cosas estables , en este caso esta disponible el JBossTools 2.1.2.GA

Ejecutas Eclipse y te vas directo a Help/Software Updates, vamos a la pestaña Available Software y le das al botón Add new Site y agregas la dirección del repositorio donde se encuentra:

http://download.jboss.org/jbosstools/updates/stable

Y listo, así de simple, si quereis un nuevo proyecto jBPM vais a File, New, Other, buscais la carpeta jBoss jBPM, Process Project y a jugar!

La primera vez que hagais un nuevo proyecto os preguntará donde están los ficheros del jbpm… una pantallita tal que asi :

Teneis que poner la ruta donde habeis instalado el jbpm y ya está.