Uso del nodo Process State en jBPM
Este nodo es especialmente util para ir a un sub-flujo y luego volver al flujo original.
Figura 01.Nodo Process State
El uso de este nodo se puede apreciar mejor en un flujo de ejemplo:
Figura 02. Flujo principal
Figura 03. Sub-flujo “Apellido”
Figura 04. Sub-flujo “Edad”
Como se puede apreciar en las anteriores figuras, el flujo principal escala a dos sub-flujos en paralelo, los cuales pueden tener una estructura totalmente diferente del original, y una vez que ambos flujos terminen se procede a la impresion de las variables seteadas en ambos sub-flujos.
PASO DE VARIABLES ENTRE FLUJOS
Para el paso de variables entre flujos realizar lo siguiente desde el IDE apuntandio al nodo “Sub Process”:
Figura 05. Paso de variables de un Flujo a un Sub-flujo
Donde:
01. Nombre del Sub-flujo
02. Version del sub-flujo
03. Variables de ida
04. Variables de vuelta
Como se puede ver en este pequenio tutorial del nodo “Process Sate”, no es necesario el uso de ningun codigo java, y los escalamientos y el paso de variables son transparentes para el usuario final.
Christian
Uso del LDAP para el modulo de autenticaciones en SEAM
LDAP (Lightweight Directory Access Protocol), (Protocolo Ligero de Acceso a Directorios) es un protocolo a nivel de aplicacion que permite el acceso a un servicio de directorio ordenado y distribuido para buscar diversa información en un entorno de red. LDAP también es considerado una base de datos(aunque su sistema de almacenamiento puede ser diferente) a la que pueden realizarse consultas.
Habitualmente, almacena la información de login (usuario y contrasenia) y es utilizado para autenticarse aunque es posible almacenar otra información (datos de contacto del usuario, ubicación de diversos recursos de la red, permisos, certificados, etc).
En conclusión, LDAP es un protocolo de acceso unificado a un conjunto de información sobre una red.
Fuente: Wikipedia
Una ves dada esta pequenia introduccion de lo que es LDAP, ahora procedo a explicar como podemos aprovechar un servidor LDAP para el modulo de autenticacion en SEAM 
Primeramente se necesitara realizar unas cuantas modificaciones al codigo de autenticacion “Authenticator.java” que viene por defecto cuando creamos un proyecto SEAM.
Figura 01. Codigo modificado del “Authenticator.java”
Una ves realizadas dichas “modificaciones” al codigo de autenticacion, se procede a la utilizacion de la pagina “login.xhtml” que ya viene por defecto cuando creamos un proyecto en SEAM:
Figura 02. Pagina de autenticacion “login.xhtml”
Y listo
Una ves que hayas deployado tu proyecto y hayas seguido mis indicaciones al pie de la letra, veras lo siguiente cuando la autenticacion sea erronea:
Figura 03. Contrasenia Incorrecta
Caso contrario podras ver lo siguiente
Figura 04. Contrasenia Correcta
Espero que les haya servido
Christian
Uso de programas java para la asignacion de usuarios en jBPM
Utilizando la interfaz “org.jbpm.taskmgmt.def.AssignmentHandler” es posible asignar un usuario o un grupo de usuarios a una tarea especifica del jBPM.
Lo unico que se tiene que hacer en la opcion de “Assignment” de cada tarea, escoger la opcion “Handler”, tal como se puede apreciar en la siguiente figura:
Figura 01. Task Assignment
El codigo java que ha de asignar un usuario en funcion de una variable es el siguiente:
Figura 02. Codigo java que asigna un solo usuario a una tarea
El codigo java que ha de asignar un grupo de usuarios, es el siguiente:
Figura 03. Codigo java que asigna un grupo de usuarios
Como pueden apreciar, el anterior codigo asigna una tarea a un grupo de usuarios en funcion del grupo al que pertenecen, el cual es extraido de una Base de Datos.
De esta forma es posible asignar usuarios de forma dinamica y lo mas importante la actualizacion de los actores a los cuales es asignada una determinada tarea solo necesita ser actualizada desde una Base de Datos 
sin variar el codigo.
Instanciacion de WorkFlows del jBPM mediante Web Services
Como mucho de ustedes sabran, los Servicios Web son un conjunto de protocolos y estandares que permiten intercambiar datos entre aplicaciones, es de esta manera que de forma estandar podemos realizar la interconexion de diferentes equipos sin tener que preocuparnos de su tecnologia o su procedencia.
En pocas palabras, la definicion de “Web Services” segun la Wikipedia es la siguiente:
Un servicio web (en inglés Web service) es un conjunto de protocolos y estándares que sirven para intercambiar datos entre aplicaciones. Distintas aplicaciones de software desarrolladas en lenguajes de programación diferentes, y ejecutadas sobre cualquier plataforma, pueden utilizar los servicios web para intercambiar datos en redes de ordenadores como Internet. La interoperabilidad se consigue mediante la adopción de estandares abiertos. Las organizaciones OASIS y W3C son los comités responsables de la arquitectura y reglamentación de los servicios Web. Para mejorar la interoperabilidad entre distintas implementaciones de servicios Web se ha creado el organismo WS-I, encargado de desarrollar diversos perfiles para definir de manera más exhaustiva estos estándares.
Una ves dado el breve marco teorico, procedere a explicar la solucion de un problema que me tuvo pensando e investigando por mucho tiempo (al rededor de un mes aproximadamente), mediante el cual es posible instanciar flujos del jBPM desde una aplicacion externa simplemente utlizando Web Services.
Los IDEs que utilice para estas tareas fueron: NetBeans 6.1 (mi preferido) y Eclipse (al cual le estoy empezando a hallar el gustito).
Utilice Eclipse para la elaboracion de mi flujo jBPM y utilice NetBeans 6.1 para la elaboracion del EJB Module el cual sera el que alvergara el Web Services que escuchara nuestros requerimientos.
Este pequeño tutorial se enfocara principalmente en la elaboracion del EJB Module con el cual crearemos el Web Service que podra instanciar flujos de una manera externa al jBPM.
Creacion del EJB Module
En el NetBeans crea un nuevo proyecto de la categoria enterprise tal como se aprecia en la figura:
Figura 01. Creacion del EJB Module
Sigue los mismos pasos descritos en el libro “Building SOA-Based Composite Applications Using NetBeans IDE 6” acerca de la creacion de un “EJB Module”. Este libro es muy bueno si uno quiere meterse en el mundo de SOA tal como lo comente hace un tiempo atras en este mismo Blog.
Pienso que dos partes son muy importantes para que este Servicio Web funcione correctamente:
01) La configuracion correcta de los archivos xml: jbpm.cfg.xml y hibernate.cfg.xml
02) El codigo que instanciara remotamente el flujo
Empecemos por lo primero, es decir los archivos xml.
Los archivos XML
Tu archivo jbpm.cfg.xml debe tener la siguiente estructura:
<jbpm-configuration>
<jbpm-context>
<service name=”persistence”>
<factory>
<bean class=”org.jbpm.persistence.db.DbPersistenceServiceFactory”>
<field name=”isTransactionEnabled”><false/></field>
</bean>
</factory>
</service>
<service name=”tx” factory=”org.jbpm.tx.TxServiceFactory” />
<service name=”message” factory=”org.jbpm.msg.db.DbMessageServiceFactory” />
<service name=”scheduler” factory=”org.jbpm.scheduler.db.DbSchedulerServiceFactory” />
<service name=”logging” factory=”org.jbpm.logging.db.DbLoggingServiceFactory” />
<service name=”authentication” factory=”org.jbpm.security.authentication.DefaultAuthenticationServiceFactory” />
</jbpm-context></jbpm-configuration>
y el archivo hibernate.cfg.xml la siguiente:
<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE hibernate-configuration PUBLIC “-//Hibernate/Hibernate Configuration DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd“>
<hibernate-configuration>
<session-factory name=”Acceso”>
<property name=”show_sql”>false</property>
<property name=”connection.datasource”>java:/dvdDatasource</property>
<property name=”transaction.factory_class”>org.hibernate.transaction.JTATransactionFactory</property>
<property name=”transaction.manager_lookup_class”>org.hibernate.transaction.JBossTransactionManagerLookup</property>
<property name=”cache.provider_class”>org.hibernate.cache.HashtableCacheProvider</property>
<property name=”hbm2ddl.auto”>create-drop</property>
<!–property name=”transaction.flush_before_completion”>true</property
############################################
# mapping files with external dependencies #
############################################
following mapping file has a dependendy on
’bsh-{version}.jar’.
uncomment this if you don’t have bsh on your
classpath. you won’t be able to use the
script element in process definition files –>
<mapping resource=”org/jbpm/graph/action/Script.hbm.xml”/>
<!– following mapping files have a dependendy on
’jbpm-identity.jar’, mapping files
of the pluggable jbpm identity component.
Uncomment the following 3 lines if you
want to use the jBPM identity mgmgt
component.
identity mappings (begin) ===
<mapping resource=”org/jbpm/identity/User.hbm.xml”/>
<mapping resource=”org/jbpm/identity/Group.hbm.xml”/>
<mapping resource=”org/jbpm/identity/Membership.hbm.xml”/>
==== identity mappings (end)
following mapping files have a dependendy on
the JCR API
jcr mappings (begin) ===
<mapping resource=”org/jbpm/context/exe/variableinstance/JcrNodeInstance.hbm.xml”/>
==== jcr mappings (end)
######################
# jbpm mapping files #
######################
hql queries and type defs –>
<mapping resource=”org/jbpm/db/hibernate.queries.hbm.xml”/>
<!– graph.action mapping files –>
<mapping resource=”org/jbpm/graph/action/MailAction.hbm.xml”/>
<!– graph.def mapping files –>
<mapping resource=”org/jbpm/graph/def/ProcessDefinition.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/Node.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/Transition.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/Event.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/Action.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/SuperState.hbm.xml”/>
<mapping resource=”org/jbpm/graph/def/ExceptionHandler.hbm.xml”/>
<mapping resource=”org/jbpm/instantiation/Delegation.hbm.xml”/>
<!– graph.node mapping files –>
<mapping resource=”org/jbpm/graph/node/StartState.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/EndState.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/ProcessState.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/Decision.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/Fork.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/Join.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/MailNode.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/State.hbm.xml”/>
<mapping resource=”org/jbpm/graph/node/TaskNode.hbm.xml”/>
<!– context.def mapping files –>
<mapping resource=”org/jbpm/context/def/ContextDefinition.hbm.xml”/>
<mapping resource=”org/jbpm/context/def/VariableAccess.hbm.xml”/>
<!– taskmgmt.def mapping files –>
<mapping resource=”org/jbpm/taskmgmt/def/TaskMgmtDefinition.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/def/Swimlane.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/def/Task.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/def/TaskController.hbm.xml”/>
<!– module.def mapping files –>
<mapping resource=”org/jbpm/module/def/ModuleDefinition.hbm.xml”/>
<!– bytes mapping files –>
<mapping resource=”org/jbpm/bytes/ByteArray.hbm.xml”/>
<!– file.def mapping files –>
<mapping resource=”org/jbpm/file/def/FileDefinition.hbm.xml”/>
<!– scheduler.def mapping files –>
<mapping resource=”org/jbpm/scheduler/def/CreateTimerAction.hbm.xml”/>
<mapping resource=”org/jbpm/scheduler/def/CancelTimerAction.hbm.xml”/>
<!– graph.exe mapping files –>
<mapping resource=”org/jbpm/graph/exe/Comment.hbm.xml”/>
<mapping resource=”org/jbpm/graph/exe/ProcessInstance.hbm.xml”/>
<mapping resource=”org/jbpm/graph/exe/Token.hbm.xml”/>
<mapping resource=”org/jbpm/graph/exe/RuntimeAction.hbm.xml”/>
<!– module.exe mapping files –>
<mapping resource=”org/jbpm/module/exe/ModuleInstance.hbm.xml”/>
<!– context.exe mapping files –>
<mapping resource=”org/jbpm/context/exe/ContextInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/TokenVariableMap.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/VariableInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/ByteArrayInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/DateInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/DoubleInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/HibernateLongInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/HibernateStringInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/LongInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/NullInstance.hbm.xml”/>
<mapping resource=”org/jbpm/context/exe/variableinstance/ StringInstance.hbm.xml”/>
<!– job mapping files –>
<mapping resource=”org/jbpm/job/Job.hbm.xml”/>
<mapping resource=”org/jbpm/job/Timer.hbm.xml”/>
<mapping resource=”org/jbpm/job/ExecuteNodeJob.hbm.xml”/>
<mapping resource=”org/jbpm/job/ExecuteActionJob.hbm.xml”/>
<!– taskmgmt.exe mapping files –>
<mapping resource=”org/jbpm/taskmgmt/exe/TaskMgmtInstance.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/exe/TaskInstance.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/exe/PooledActor.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/exe/SwimlaneInstance.hbm.xml”/>
<!– logging mapping files –>
<mapping resource=”org/jbpm/logging/log/ProcessLog.hbm.xml”/>
<mapping resource=”org/jbpm/logging/log/MessageLog.hbm.xml”/>
<mapping resource=”org/jbpm/logging/log/CompositeLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/ActionLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/NodeLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/ProcessInstanceCreateLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/ProcessInstanceEndLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/ProcessStateLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/SignalLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/TokenCreateLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/TokenEndLog.hbm.xml”/>
<mapping resource=”org/jbpm/graph/log/TransitionLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/VariableLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/VariableCreateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/VariableDeleteLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/VariableUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/ByteArrayUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/DateUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/DoubleUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/HibernateLongUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/HibernateStringUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/LongUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/context/log/variableinstance/StringUpdateLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/TaskLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/TaskCreateLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/TaskAssignLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/TaskEndLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/SwimlaneLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/SwimlaneCreateLog.hbm.xml”/>
<mapping resource=”org/jbpm/taskmgmt/log/SwimlaneAssignLog.hbm.xml”/>
</session-factory>
</hibernate-configuration>
Ambos archivos debes localizarlos en el directorio “Source Packages” de tu EJB Module
Figura 02. Ubicacion de los archivos xml
El Codigo
El codigo que permitira que tu Servicio Web instancie un flujo remotamente es el siguiente:
Figura 03. Codigo que instancia flujos remotamente
Para concluir en el anterior codigo utilice el exelente Tutorial “jbpm3.2.2-handsontutorial” el cual te lo puedes descargar de la Wiki de jBoss, el cual es tremendamente recomendable si quieres entender la logica de funcionamiento de jBPM.
Y listo, deploya este EJB Module en tu servidor jBoss, y testea el Servicio Web con cualquier programa que realice esto, el que YO utlizo es: “SOAP UI” el cual tambien te lo puedes descargar de la red 
El resultado que obtuve fue el siguiente:
Figura 04. Web Service deployado (http://127.0.0.1:8080/jbossws/services)
Figura 05. Resultado del Servicio Web consumido
Espero que les haya servido
Christian
Importante TIP para utilizar variables de los beans del SEAM con las clases del jBPM
Uno de las grandes posibilidades que nos da SEAM es la posibilidad de integrarlo con el jBPM, es de esta forma que encotre un camino para utilizar las variables seteadas en un Bean del SEAM dentro de una clase del jBPM.
La forma es la siguiente:
01. Seteamos una variable del SEAM a traves de un bean utilizando la siguiente notacion:
@Out(value=“variableX”,scope=ScopeType.BUSINESS_PROCESS)
private boolean valorDeVariableX;
De esta forma “variableX” a de ser el nombre de la variable a ser almacenada en la base de datos del jBPM (Especificamente hablando, esta variable es almacenada en la tabla “jbpm_variableinstance”) y “valorDeVariableX” ha de ser el valor de esa variable.
Figura 01. Tabla de almacenamiento de variables del jBPM
02. Obtener “variableX” utilizando clases del jBPM.
Estas clases pueden ser “DecisionHandler (que en realidad es una interfaz utilizada en el nodo de toma de decisiones)” o la clase “ActionHandler” (que tambien es otra interfaz utlizada para ejecutar una accion en cualquier nodo del jBBPM)
La forma de obtener esta “variableX” sera la siguiente:
boolean decide=(Boolean)Contexts.getBusinessProcessContext().get(“variableX“);
Como pueden apreciar esta no es una forma muy elegante de darle uso al SEAM, pero puesto que soy un Ingeniero Electronico al que principalmente le importa que las cosas funcionen, para mi es una solucion que me quita un problema de la cabeza 
.
Espero que les sirva
Christian
Importante TIP para utilizar variables de los beans del SEAM con las clases del jBPM
Uno de las grandes posibilidades que nos da SEAM es la posibilidad de integrarlo con el jBPM, es de esta forma que encotre un camino para utilizar las variables seteadas en un Bean del SEAM dentro de una clase del jBPM.
La forma es la siguiente:
01. Seteamos una variable del SEAM a traves de un bean utilizando la siguiente notacion:
@Out(value=“variableX”,scope=ScopeType.BUSINESS_PROCESS)
private boolean valorDeVariableX;
De esta forma “variableX” a de ser el nombre de la variable a ser almacenada en la base de datos del jBPM (Especificamente hablando, esta variable es almacenada en la tabla “jbpm_variableinstance”) y “valorDeVariableX” ha de ser el valor de esa variable.
Figura 01. Tabla de almacenamiento de variables del jBPM
02. Obtener “variableX” utilizando clases del jBPM.
Estas clases pueden ser “DecisionHandler (que en realidad es una interfaz utilizada en el nodo de toma de decisiones)” o la clase “ActionHandler” (que tambien es otra interfaz utlizada para ejecutar una accion en cualquier nodo del jBBPM)
La forma de obtener esta “variableX” sera la siguiente:
boolean decide=(Boolean)Contexts.getBusinessProcessContext().get(“variableX“);
Como pueden apreciar esta no es una forma muy elegante de darle uso al SEAM, pero puesto que soy un Ingeniero Electronico al que principalmente le importa que las cosas funcionen, para mi es una solucion que me quita un problema de la cabeza .
Espero que les sirva
Christian
Sugerencia SEAM
Cuando utilicen un Bean para iniciar una tarea del JBPM, es mejor que utilicen la anotacion :
@BeginTask
De esta forma las tareas ya iniciadas (con @BeginTask o @StartTask), pueden ser continuadas 
jBPM + SEAM en 07 pasos (Un simple tutorial para ver la integracion del JBpm en SEAM)
Como mucho de ustedes saben, SEAM es un framework que integra Java EE standards para que trabajen de una forma integrada y armoniosa. Dentro del nucleo de SEAM se encuentran el Enterprise JavaBeans 3 (EJB3), el Java Server Faces (JSF) y una de las mas importantes integraciones (la cual es la razon de este pequeño articulo) es la integracion del JBOSS jBPM. Empezando este pequeño tutorial, primeramente se pasa a explicar la instalación del Eclipse (Un IDE que solo lo utilizo para mis desarrollos relacionados al jBPM, pues no me agrada mucho) con los plugins necesarios para el desarrollo en SEAM 01. Instalacion del IDE – Primero es necesario descargar el IDE (eclipse-jee-europa-winter-win32.zip) y el paquete JBossTools-2.1.1.GA-ALL-win32.zip – Descomprime el Eclipse y copia el contenido del JBossTools en el IDE descompreso, es decir:
Figura 01. Copiado del JBoss-Tools al Eclipse
– Finalmente desde el command pad teclea en la carpeta donde descomprimiste el IDE: >eclipese -clean – Listo, ya tienes el IDE funcionando 
02. Desarrollando el proyecto SEAM
– Primero crea un nuevo proyecto SEAM
Figura 02. Desarrollo de un proyecto SEAM
– Setea el “Target Runtime” y el “Target Server” en funcion del lugar en el que descomprimiste tu JBoss AS y en configuraciones apunta a SEAM 2.0
Figura 03. Seteo del JBoss AS
– Haz click en “Next” hasta llegar a la ventana de “Seam Facet” en donde etableces el tipo de DB con la cual a de funcionar tu proyecto. Como solo estamos probando como funciona SEAM dejalo con la DB HSQL e instala su driver (que te lo tienes que descargar) – Tambien es necesario que descargues “jboss-seam-2.0.2.SP1”, lo descomprimas y establece su ubicacion en “Seam Runtime” como se parecia en la figura.
Figura 04. Seteo del jboss-seam y la Base de Datos
– Ahora ya tienes el proyecto listo para ser utilizado
Figura 05. Estructura del nuevo proyecto 03. Creacion del flujo jBPM
– En la carpeta “resources” crea un jBPM “Process Definition”
Figura 06. Creacion de un nuevo flujo jbpm
Figura 07. Flujo jbpm
– Crea tu flujo
Figura 08. Ubicacion del flujo jbpm
Como pueden apreciar, el mio se llama “Tareas” – Copia y luego pega “processdefinition.xml” a la carpeta “src/model”
Figura 09. Traslado del archivo “processdefinition.xml”
04. Configuracion del archivo “components.xml”
– Ubicacion
Figura 10. Ubicacion del archivo “components.xml”
– Edicion: Descomenta esta seccion del codigo
Figura 11. Edicion del archivo “components.xml”
– Adiciona el nombre del archivo jpdl de tu flujo, en este caso “processdefinition.xml”
Figura 12. Agregacion de “processdefinition.xml” en “components.xml” 05. Creacion de los archivos “hibernate.cfg.xml “ y “jbpm.cfg.xml”
– La forma mas simple es copiar y pegar ambos archivos de uno de los ejemplos que vienen en “jboss-seam-2.0.2.SP1”. El mas completo es el “dvdStore”. – Una vez ubicados ambos archivos, procede a editar el “hibernate.cfg.xml” de la siguiente forma: Primero escribe el nombre de tu proyecto
Figura 13. Edicion del archivo “hibernate.cfg.xml”
Escribe el valor del Datasource en funcion del nombre de tu proyecto, asi si tu proyecto se llama Test, el valor de tu DS sera: java:/TestDatasource
Figura 14. Edicion del “connection.datasource”
– El archivo “jbpm.cfg.xml” dejalo sin modificiaciones. Deberia presentar la siguiente extructura:
Figura 15. El archivo “jbpm.cfg.xml” 06. Desarrollo de Beans y paginas XHTML
– Login: El codigo del login es:
Figura 16. Codigo del bean Login.class
Como se puede apreciar es muy simple y la unica funcion que tiene es setear el actorId en jBPM mediante la clase Actor del SEAM. Una vez invocada la accion “setLog()” la pagina que sera desplegada ha de ser: “TaskPage.xml”
Figura 17. Vista de login.xhtml
– TaskPage:
Esta pagina tiene la funcion de desplegar todas las tareas del actor que se haya logeado en la pagina “login”
Figura 18. Vista de TaskPage.xhtml
El bean correspondiente a esta pagina es:
Figura 19. Codigo del bean TaskRouter.class
Este codigo es muy simple tambien, y las acciones utilizadas iniciaran cada uno de los nodos de tu flujo.
Figura 20. Vista de la accion “Aceptar Importancia”
– Inicio del flujo
Figura 21. Vista de la accion “Esperar respuesta” de “inicio.xhtml”
Figura 22. Codigo del bean Inicio.class
El inicio del flujo es invocado cuando el metodo create() es instanciado. Como se puede apreciar esto es posible gracias a la utilizacion de la anotacion @CreateProcess cuyo argumento es el nombre del flujo anteriormente desarrollado. – ConfirmDate y ConfirmTask Las dos paginas y codigos son similares asi que solo explicare uno de ellos. – ConfrimDate
Figura 23. Vista de la accion “Confirmar Fecha” en “confirmDate.xhtml”
Figura 24. Codigo del bean ConfirmDate.class
Como se puede apreciar en las anteriores figuras, aca no se presenta nada novedoso, con la exepcion de las anotaciones de biyeccion @In y @Out, que cumplen la funcion de introducir variables en el jBPM o extraerlas del mismo. La unica accion que utilizamos aca es la finalizacion del nodo “Fecha” mediante el metodo “endDate()” Como se habran dado cuenta, siempre que iniciamos una tarea en un nodo utilizamos la anotacion @StartTak y cuando la queremos finalizar utilizamos @EndTask, esto es muy importante, pues si falta alguna de ellas el flujo no funciona. – Resultado Finalmente tenemos las pagina que es desplegado cuando estamos en el ultimo nodo de nuestro flujo jBPM, la cual simplemente desplegara toda la informacion apuntada en los anteriores nodos
Figura 25. Vista de la accion “Aceptar!” en “resultado.xhtml”
El bean asociado a esta pagina es Resultado.class
Figura 26. Codigo del bean Resultado.class
Como se puede apreciar, este codigo lo unico que hace es culminar la terea y finalizar el nodo. 07. Probar el proyecto Una vez concluido todas las paginas, configuraciones y beans, inicia el servidor JBoss desde el Eclipse y notaras que tu proyecto ya se encuentra deployado en el mismo
Figura 27. El proyecto SEAM en el servidor JBoss
Despues de haber iniciado el servidor, con un browser entra a la siguiente direccion: http://127.0.0.1:8080/Test01 y listo, se tiene que desplegar la pagina “home.seam” mediante la cual puedes dirigirte a la pagina de “login.seam” para empezar el flujo Para un mayor entendimiento de lo explicado anteriormente, les dejo el codigo del proyecto desarrollado en su totalidad: NUEVO LINK!!!
Espero que les sea de utlidad
Exelente libro sobre el desarrollo de SOA con netbeans
Este libro es muy bueno para comprender mejor todo lo referente a SOA y el uso que se les puede dar al BPEL y al JBI.
PD: Lo más importante es que sus ejemplos Sí funcionan 
Como saltar de un flujo a otro en JBPM
Estoy seguro de que muchos de ustedes han escuchado de JBPM y de lo simple que es realizar Flujos de Trabajo en el mismo.
Uno de los aspectos mas importantes para sacarle el jugo al JBPM es entender su API y es de esta forma que mediante unas cuantas leidas a su tutorial logre realizar un “salto” un flujo a otro sin complicaciones, lo que me significo en la creacion de flujos mas segmentados y mejor organizados.
A continuacion les presento el codigo.
Codigo:
public class GoToProblemManagement implements ActionHandler {
private static final long serialVersionUID = 1L;
public void execute(ExecutionContext context) throws Exception {
long id=context.getProcessInstance().getId(); // ID del flujo de origen
JbpmContext jbpmContext =context.getJbpmContext();
String processName; // Nombre del flujo al cual se quiere “saltar”
String transition; // Nombre de la transicion si es que hay mas de una
processName= “Gestion de Problemas”;
transition=”Enviar”;
ProcessInstance processInstance = jbpmContext.newProcessInstance(processName);
ContextInstance contextB=processInstance.getContextInstance();
contextB.setVariable(”processID”,id); // Seteo de la variable “id” del flujo origen a “processID” del flujo destino
processInstance.signal(transition); // Envio de la señal para pasar el TOKEN
context.leaveNode(); // Dejar el nodo
}
}
Para que funcione este codigo lo unico que tienen que hacer es adjuntar el mismo a un “Nodo” del flujo y setear las variables “processName” y “transition” a su conveniencia. Este codigo es muy util si es que desean implementar flujos ITIL para ir de una gestion a otra, como en mi caso lo utilice para ir de la “Gestion de Incidentes” a la “Gestion de Problemas”.
Espero que les sirva 
-
Archivos
- Octubre de 2008 (9)
- Junio de 2008 (2)
-
Categorías
-
RSS
Subscripciones RSS
RSS de los Comentarios
