JBPM使用详解

1. 工作流基础

1.1. 工作流相关概念

工作流(Workflow),就是“业务过程的部分或整体在计算机应用环境下的自动化”,它主要解决的是“使在多个参与者之间按照某种预定义的规则传递文档、信息或任务的过程自动进行,从而实现某个预期的业务目标,或者促使此目标的实现”。

通俗的说,流程就是多个人在一起合作完成某件事情的步骤,把步骤变成计算机能理解的形式就是工作流。

工作流管理系统(WfMS,Workflow Management System)的主要功能是通过计算机技术的支持去定义、执行和管理工作流,协调工作流执行过程中工作之间以及群体成员之间的信息交互。应能提供以下三个方面的功能支持:

1. 定义工作流:包括具体的活动、规则等

2. 运行控制功能:在运行环境中管理工作流过程,对工作流过程中的活动进行调度

3. 运行交互功能:指在工作流运行中,WfMS与用户(活动的参与者)及外部应用程序工具交互的功能。

一、定义工作流

二、执行工作流

采用工作流管理系统的优点

1. 提高系统的柔性,适应业务流程的变化

2. 实现更好的业务过程控制,提高顾客服务质量

3. 降低系统开发和维护成本

工作流框架有:Jbpm、OSWorkflow、ActiveBPEL、YAWL等

1.2. 开源工作流jBPM4.4介绍

jBPM 即java Business Process Management,是基于java的业务流程管理系统。jBPM是市面上相当流行的一款开源工作流引擎,引擎底层基于Active Diagram模型。jBPM4.4使用了hibernate(3.3.1版),因此可以很好的支持主流数据库。jBPM4.4共有18张表。

jBPM官方主页http://www.jboss.org/jbpm

2. 准备jBPM4.4环境

2.1. jBPM4.4所需环境

jBPM requires a JDK (standard java) version 5 or higher. http://java.sun.com/javase/downloads/index.jsp

To execute the ant scripts, you'll need apache ant version 1.7.0 or higher: http://ant.apache.org/bindownload.cgi

2.2. 下载相关资源

1, jBPM下载地址:http://sourceforge.net/projects/jbpm/files/

2, Eclipse下载地址( Eclipse IDE for Java EE Developers (163 MB),Version:3.5 ):http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo

2.3. 安装流程设计器(GPD,Eclipse插件)

GPD(Graphical Process Designer)是一个Eclipse插件。

安装方法说明(jBPM4.4User Guide, 2.11.2. Install the GPD plugin into eclipse):

Help --> Install New Software...

Click Add...

In dialog Add Site dialog, click Archive...

Navigate to install/src/gpd/jbpm-gpd-site.zip and click 'Open'

Clicking OK in the Add Site dialog will bring you back to the dialog 'Install'

Select the jPDL 4 GPD Update Site that has appeared

Click Next... and then Finish

Approve the license

Restart eclipse when that is asked

clip_image002[4]

查看是否成功安装了插件:WindowàPreference中是否有Jboss jBPM项。

2.4. 在Eclipse中添加jPDL4.4 Schema校验

流程定义文件的xsd文件的路径为:JBPM_HOME/src/jpdl-4.4.xsd。

添加到Eclipse中的方法为(jBPM4.4 User Guide, 2.11.5. Adding jPDL 4 schema to the catalog):

Click Window --> Preferences

Select XML --> XML Catalog

Click 'Add...'

The 'Add XML Catalog Entry' dialog opens

Click the button with the map-icon next to location and select 'File System...'

In the dialog that opens, select file jpdl-4.4.xsd in the src directory of the jBPM installation root.

Click 'Open' and close all the dialogs

clip_image004[4]

2.5. 准备jBPM4.4的开发环境

2.5.1. 添加jBPM4.4的jar包

1. ${JBPM_HOME}/jbpm.jar(核心包)

2. JBPM_HOME/lib/*.jar,不添加以下jar包:servlet-api.jar, junit.jar。其中junit.jar一定不要添加,因为是3.8.2版本,与我们使用的junit4有冲突。

3. 所使用的数据库对应的驱动的jar包(第2步所添加的jar包中已包含mysql的jdbc驱动jar包)。

2.5.2. 添加并定制配置文件

1. 配置文件可以从JBPM_HOME/examples/src/中拷贝: 
jbpm.cfg.xml、 
logging.properties、 
jbpm.hibernate.cfg.xml。

2. 修改logging.properties中的日志输出级别[t1] 为WARNING:java.util.logging.ConsoleHandler.level=WARNING

3. 修改jbpm.hibernate.cfg.xml中的数据库连接信息。如果使用MySql,使用的方言一定要是org.hibernate.dialect.MySQL5InnoDBDialect[t2] 。

4. 数据库连接编码一定要是UTF-8。否则可能会在部署含有中文字符的流程定义时会抛异常,说sql语法错误。

说明:如果要改变jbpm.hibernate.cfg.xml的文件名称,需要做:

1、从JBPM_HOME/src/中拷贝jbpm.tx.hibernate.cfg.xml放到工程的src/下,然后进行修改。

2、修改jbpm.tx.hibernate.cfg.xml中的hibernate主配置文件的路径配置(指定的是相对于classpath的相对路径)。

2.5.3. 初始化数据库

1, 方法一:执行sql脚本文件${JBPM4.4_HOME}/install/src/db/create/jbpm.*.create.sql

2, 方法二:使用Hibernate的自动建表,在jbpm.hibernate.cfg.xml中配置:hibernate.hbm2ddl.auto=update。

例如:

public void testCreateSchema() { // hbm2ddl.auto=update

       new org.hibernate.cfg.Configuration().configure("jbpm.hibernate.cfg.xml").buildSessionFactory();

    }

3. 核心概念与相关API(Service API)

3.1. 概念:Process definition, process instance ,  execution

3.1.1. Process definition

ProcessDefinition,流程定义:

一个流程的步骤说明。如一个请假流程、报销流程、借款流程等,是一个规则。

例:

clip_image006[4]

3.1.2. Process instance

ProcessInstance,流程实例:

代表流程定义的一次执行。如张三昨天按请假流程请了一次假。一个流程实例包括了所有运行阶段, 其中最典型的属性就是跟踪当前节点的指针。

clip_image008[4]

3.1.3. Execution

Execution,执行:

一般情况下,一个流程实例是一个执行树的根节点。

使用树状结构的原因在于, 这一概念只有一条执行路径, 使用起来更简单。 业务API不需要了解流程实例和执行之间功能的区别。 因此, API里只有一个执行类型来引用流程实例和执行。

假设汇款和存档可以同时执行,那么主流程实例就包含了2个用来跟踪状态的子节点:

clip_image010[4]

4.ProcessEngine与Service API

4.1.1. Configuration与ProcessEngine

Interacting with jBPM occurs through services. The service interfaces can be obtained from the ProcessEngine which is build from a Configuration. A ProcessEngine is thread safe and can be stored in a static member field.

使用默认的配置文件(jbpm.cfg.xml)生成Configuration并构建ProcessEngine:

ProcessEngine processEngine = new Configuration()

       .buildProcessEngine();

或是使用如下代码获取使用默认配置文件的、单例的ProcessEngine对象:

ProcessEngine processEngine = Configuration.getProcessEngine();

或是使用指定的配置文件(要放到classPath下):

ProcessEngine processEngine = new Configuration()

      .setResource("my-own-configuration-file.xml")

      .buildProcessEngine();

4.1.2. jBPM Service API

jBPM所有的操作都是通过Service完成的,以下是获取Service的方式:

RepositoryService repositoryService = processEngine

      .getRepositoryService();

ExecutionService executionService = processEngine

      .getExecutionService();

TaskService taskService = processEngine

      .getTaskService();

HistoryService historyService = processEngine

      .getHistoryService();

ManagementService managementService = processEngine

      .getManagementService();

各个Service的作用:

RepositoryService

管理部署对象和流程定义

ExecutionService

管理执行的,包括启动、推进、删除Execution等操作

TaskService

管理任务的

HistoryService

历史管理(执行完的数据管理,主要是查询)

IdentityService

jBPM的用户、组管理

ManagementService

4.1.3. API风格

方法调用链

每一个方法都是流程有关的一个业务操作,默认是一个独立的事务。

4.1.4. 查询的有关API(风格)

功能说明

相应的查询API

查询“流程定义”

ProcessDefinitionQuery processDefinitionQuery =

processEngine.getRepositoryService()

    .createProcessDefinitionQuery();

查询“执行对象”

(流程实例)

ProcessInstanceQuery processInstanceQuery =

processEngine.getExecutionService() //

    .createProcessInstanceQuery();

查询“任务”

TaskQuery taskQuery = //

processEngine.getTaskService()//

    .createTaskQuery();

查询“执行历史”

(流程实例历史)

HistoryProcessInstanceQuery historyProcessInstanceQuery =

processEngine.getHistoryService()

    .createHistoryProcessInstanceQuery();

查询“任务历史”

HistoryTaskQuery historyTaskQuery =

processEngine.getHistoryService()

    .createHistoryTaskQuery();

以上列出的Query对象有:

1. ProcessDefinitionQuery

2. ProcessInstanceQuery

3. TaskQuery

4. HistoryProcessInstanceQuery

5. HistoryTaskQuery

这些Query对象的使用方法都是一致的,如下所示:

1, 添加过滤条件:调用其中的有关方法指定条件即可。如:

a) processDefinitionQuery.processDefinitionKey("设备购置计划")是指定查询key为”设备购置计划”的流程定义;

b) taskQuery.assignee("张三")是指定办理人为”张三”的任务。

2, 添加排序条件:

a) 调用 xxQuery.orderAsc(property),表示按某属性升序排列

b) 调用 xxQuery.orderDesc(property),表示按某属性降序排列

c) 可指定多个排序条件,就是代表第1顺序,第2顺序…等。

d) 属性名在各自的Query对象(接口)中有常量定义,如:

i. ProcessDefinitionQuery.PROPERTY_ID

ii. ProcessDefinitionQuery.PROPERTY_KEY

iii. TaskQuery.PROPERTY_NAME

iv. TaskQuery.PROPERTY_ASSIGNEE

3, 指定分页有关信息:

a) 调用方法xxQuery.page(firstResultmaxResults);

b) 这是指定first与max的值(就是Hibernate中的Query.setFirstResult()与Query.setMaxResults())

c) 如果没有调用这个方法,代表要查询出符合条件的所有记录。

4, 查询得到结果:

a) 调用方法xxQuery.list(); 表示查询列表

b) 调用方法 xxQuery.uniqueResult(); 表示查询唯一的结果

c) 调用方法xxQuery.count(); 表示查询符合条件的记录数量

5. 管理流程定义

没有更新功能

5.1. 部署流程定义

注意区分Deployment与ProcessDefinition

5.1.1. 示例代码1:流程定义有关文件在classpath中

String deploymentId = processEngine.getRepositoryService()

       .createDeployment()

       .addResourceFromClasspath("process/test.jpdl.xml")

.addResourceFromClasspath("process/test.png")

.deploy();

5.1.2. 示例代码2:一次添加多个流程定义有关文件(要先打成zip包)

String deploymentId = processEngine.getRepositoryService()

       .createDeployment()

       .addResourcesFromZipInputStream(zipInputStream)

       .deploy();

5.1.3. 说明

1, .addResourceFromClasspath(resource); 可以调用多次以添加多个文件。文件重复添加也不会报错。

2, .addResourceFromInputStream(resourceName, inputStream)添加一个文件(使用InputStream)

3, .addResourcesFromZipInputStream(zipInputStream)添加多个文件,里面也可以有文件夹。

4, 以上方法可以在一起调用。

5.2. 删除流程定义

5.2.1. 示例代码1:删除流程定义,如果有关联的流程实例信息则报错

repositoryService.deleteDeployment(deploymentId);

5.2.2. 示例代码2:删除流程定义,并删除关联的流程实例与历史信息

repositoryService.deleteDeploymentCascade(deploymentId);

5.3. 查询流程定义

5.3.1. 相关查询API说明:ProcessDefinitionQuery

RepositoryService.createProcessDefinitionQuery()

5.3.2. 示例代码1:查询所有流程定义

// 1,构建查询

ProcessDefinitionQuery pdQuery = processEngine.getRepositoryService()

       .createProcessDefinitionQuery()//

       .orderAsc(ProcessDefinitionQuery.PROPERTY_NAME)//

       .orderDesc(ProcessDefinitionQuery.PROPERTY_VERSION);

// 2,查询出总数量与数据列表

long count = pdQuery.count();

List<ProcessDefinition> list = pdQuery.page(0, 100).list();// 分页:取出前100条记录

// 3,显示结果

System.out.println(count);

for (ProcessDefinition pd : list) {

    System.out.println("id=" + pd.getId()//

           + ",deploymentId=" + pd.getDeploymentId()//

           + ",name=" + pd.getName()//

           + ",version=" + pd.getVersion()//

           + ",key=" + pd.getKey()); //

}

5.3.3. 示例代码2:查询所有最新版本的流程定义列表

// 1,查询,按version升序排序,则最大版本排在最后面

List<ProcessDefinition> all = processEngine.getRepositoryService()//

       .createProcessDefinitionQuery()//

       .orderAsc(ProcessDefinitionQuery.PROPERTY_VERSION)

       .list();

// 2,过滤出所有不同Key的最新版本(因为最大版本在最后面)

Map<String, ProcessDefinition> map = new HashMap<String, ProcessDefinition>(); // map的key是流程定义的key,map的vlaue是流程定义对象

for (ProcessDefinition pd : all) {

    map.put(pd.getKey(), pd);

}

Collection<ProcessDefinition> result = map.values();

// 3,显示结果

for (ProcessDefinition pd : result) {

    System.out.println("deploymentId=" + pd.getDeploymentId()//

           + ",\t id=" + pd.getId()// 流程定义的id,格式:{key}-{version}

           + ",\t name=" + pd.getName()

           + ",\t key=" + pd.getKey()

           + ",\t version=" + pd.getVersion());

}

5.4. 获取部署对象中的文件资源内容

// 资源的名称,就是 jbpm4_lob 表中的 NAME_ 列表值

String deploymentId = "90001";

String resourceName = "test.png";

InputStream in = processEngine.getRepositoryService()

.getResourceAsStream(deploymentId, resourceName);

5.5. 获取流程图中某活动的坐标

String processDefinitionId = "test-1"; // 流程定义的id

String activityName = "start1"; // 活动的名称

ActivityCoordinates c = processEngine.getRepositoryService()

           .getActivityCoordinates(processDefinitionId, activityName);

System.out.println("x=" + c.getX()

+ ",y=" + c.getY()

+ ",width=" + c.getWidth()

+ ",height=" + c.getHeight());

6. 执行流程实例

6.1. 启动流程实例

说明:流程实例创建后,直接就到开始活动后的第一个活动,不会在开始活动停留。

6.1.1. 示例代码1:使用指定key的最新版本的流程定义启动流程实例

ProcessInstance pi = processEngine.getExecutionService()

           .startProcessInstanceByKey(processDefinitionKey);

6.1.2. 示例代码2:使用指定key的最新版本的流程定义启动流程实例,并设置一些流程变量

// 准备流程变量

Map<String, Object> variables = new HashMap<String, Object>();

variables.put("申请人", "张三");

variables.put("报销金额", 1000.00);

// 启动流程实例,并设置一些流程变量

ProcessInstance pi = processEngine.getExecutionService()

       .startProcessInstanceByKey(processDefinitionKey, variables);

6.2. 向后执行一步(Signal)

6.2.1. 示例代码1:向后执行一步,使用唯一的outcome离开活动

processEngine.getExecutionService().signalExecutionById(executionId);

6.2.2. 示例代码2:向后执行一步,使用唯一的outcome离开活动,并设置一些流程变量

Map<String, Object> variables = new HashMap<String, Object>();

variables.put("审批结果", "同意");

processEngine.getExecutionService()

.signalExecutionById(executionId, variables);

6.2.3. 示例代码3:向后执行一步,使用指定的outcome离开活动

String outcome= "to end1";

processEngine.getExecutionService()

.signalExecutionById(executionId, outcome);

6.2.4. 示例代码4:向后执行一步,使用指定的outcome离开活动,并设置一些流程变量

String outcome= "to end1";

Map<String, Object> variables = new HashMap<String, Object>();

variables.put("审批结果", "同意");

processEngine.getExecutionService()

.signalExecutionById(executionId, outcome, variables);

6.3. 查询任务

6.3.1. 查询个人任务列表

方式1:TaskService.findPersonalTasks(userId);

方式2:List<Task> list = taskService.createTaskQuery()

              .assignee(userId)

              .list();

// 显示任务信息

for (Task task : taskList) {

    System.out.println("id=" + task.getId()// 任务的id

       + ",name=" + task.getName()// 任务的名称

       + ",assignee=" + task.getAssignee()// 任务的办理人

       + ",createTime=" + task.getCreateTime() // 任务的创建(生成)的时间

       + ",executionId=" + task.getExecutionId());// 任务所属流程实例的id

}

6.3.2. 查询组任务列表

方式1: taskService.findGroupTasks(userId);

方式2: List<Task> list = processEngine.getTaskService()//

           .createTaskQuery()//

           .candidate(userId)//

           .list();

6.4. 完成任务

6.4.1. 正常完成任务(也可以同时设置一些流程变量)

String taskId = "420001";

processEngine.getTaskService().completeTask(taskId);

processEngine.getTaskService().completeTask(taskId, outcome);

processEngine.getTaskService().completeTask(taskId, outcome, variables);

6.4.2. 自行控制任务完成后是否可向后流转

String taskId = "420001";

// 1,设置为false代表:办理完任务后不向后移动(默认为true)

TaskImpl taskImpl = (TaskImpl) processEngine

.getTaskService().getTask(taskId);

taskImpl.setSignalling(false);

// 2,办理完任务

processEngine.getTaskService().completeTask(taskId);

6.5. 拾取任务

1, TaskService.takeTask(taskId, userId),拾取组任务到个人任务列表中,如果任务有assignee,则会抛异常。

2, processEngine.getTaskService().assignTask(taskId, userId),转交任务给其他人,(如果任务有assignee,则执行这个方法代表重新分配。也可以把assignee设为null表示组任务没有人办理了)

6.6. 设置与获取流程变量

6.6.1. 设置流程变量
6.6.1.1. 方式1:根据 executionId 设置或获取流程变量

ExecutionService.setVariable(executionId, name, value);

Object obj = executionService.getVariable(executionId, name);

6.6.1.2. 方式2:根据 taskId 设置或获取流程变量

TaskService.setVariables(taskId, variables); // 一次设置多个变量

Object obj = executionService.getVariable(executionId, name);

6.6.1.3. 流程变量所支持的值的类型(jBPM User Guide,7.2. Variable types)

7.2. Variable types

jBPM supports following Java types as process variables:

java.lang.String

java.lang.Long

java.lang.Double

java.util.Date

java.lang.Boolean

java.lang.Character

java.lang.Byte

java.lang.Short

java.lang.Integer

java.lang.Float

byte[] (byte array)

char[] (char array)

hibernate entity with a long id

hibernate entity with a string id

serializable

For persistence of these variable, the type of the variable is checked in the order of this list. The first match will determine how the variable is stored.

6.7. 直接结束流程实例(自己手工结束)

String processInstanceId = "test.10001";

processEngine.getExecutionService()

.endProcessInstance(processInstanceId, ProcessInstance.STATE_ENDED);

7. jBPM4.4的流程定义语言(设计流程)

7.1. process(流程)

是.jpdl.xml的根元素,可以指定的属性有:

属性名

作用说明

name

流程定义的名称,用于显示。

key

流程定义的key,用于查询。

如未指定,则默认为name的值。

version

版本,如果指定,则不能与已有的流程定义的版本重复;如未指定,则此key的流程定义的第1个为版本1,以后的是版本递增(每次加1)

7.2. transition(连线、转移)

1, 一个活动中可以指定一个或多个Transition(Start中只能有一个,End中没有)。

a) 开始活动中只能有一个Transition。

b) 结束活动中没有Transition。

c) 其他活动中有1条或多条Transition

2, 如果只有一个,则可以不指定名称(名称是null);如果有多个,则要分别指定唯一的名称。

7.3. 流转控制活动

7.3.1. start(开始活动)

代表流程的开始边界,一个流程有且只能有一个Start活动。开始活动只能指定一个Transition。在流程实例启动后,会自动的使用这个唯一的Transition离开开始活动,到一下个活动。

7.3.2. end、end-error、end-cancel(结束活动)

代表流程的结束边界,可以有多个,也可以没有。如果有多个,则到达任一个结束活动,整个流程就都结束了;如果没有,则到达最后那个没有Transition的活动,流程就结束了。

7.3.3. state(状态活动)

功能:等待。

7.3.4. task(任务活动)

分配任务:

1, actor=#{String型的变量}

2, AssignmentHandler,需要在<task>元素中写<assignment-handler class="AssignmentHandlerImpl"/>子元素。

a) 指定的类要实现AssignmentHandler接口

b) 在其中可以使用Assignable.setAssignee(String),分配个人任务。

7.3.5. decision(判断活动)

1,使用expression,如:expr="#{'to state2'}"

2,使用Handler,要实现DecisionHandler接口

3,如果同时配置了expression与Handler,则expression有效,忽略Handler。

7.3.6. fork、join(分支/聚合活动)

这是多个分支并行(同时)执行的,并且所有的分支Execution都到Join活动后才离向后执行。

7.4. 自定义活动(Custom)

1,在<custom>元素中指定class属性为指定的类。

2,这个类要实现ExternalActivityBehaviour接口,其中有两个方法:

       1,execute(ActivityExecution),节点的功能代码

       2,signal(ActivityExecution, String, Map),在当前节点等待时,外部发信号时的行为

       3,在execute()方法中,可以调用以下方法对流程进行控制

              1,ActivityExecution.waitForSignal(),在当前节点等待。

              2,ActivityExecution.takeDefaultTransition(),使用默认的Transition离开,当前节点中定义的第一个为默认的。

              3,ActivityExecution.take(String transitionName),使用指定的Transition离开

              4,ActivityExecution.end(),结束流程实例

       4,也可以实现ActivityBehaviour接口,只有一个方法execute(ActivityExecution),这样就不能等待,否则signal时会有类转换异常。

7.5. 事件

1, 在根元素中,或在节点元素中,使用<on event="">元素指定事件,其中event属性代表事件的类型。

2, 在<on>中用子元素<event-listener class="EventListenerImpl" />,指定处理的类,要求指定的类要实现EventListener接口

3, 事件类型:

a) <on>元素放在根元素(<process>)中,可以指定event为start或end,表示流程的开始与结束。

b) <on>元素放在节点元素中,可以指定event为start或end,表示节点的进入与离开

c) 在Start节点中只有end事件,在End节点中只有start事件。

d) 在<transition>元素中直接写<event-listener class="">,就是配置事件。(因为在这里只有一个事件,所以不用写on与类型)

e) 在<task>元素中还可以配置assign事件,是在分配任务时触发的。

8. jBPM4.4应用

8.1. 与Spring集成(jBPM4.4 Developers Guide, Chapter 17. Spring Integration)

8.1.1. 在jbpm.cfg.xml中

1,删除配置:<import resource="jbpm.tx.hibernate.cfg.xml" />

2,增加配置:<import resource="jbpm.tx.spring.cfg.xml" />

8.1.2. 在applicationContext.xml中配置

<!-- 配置ProcessEngine(整合jBPM4) -->

<!-- jbpmCfg是相对于classpath的相对路径,默认值为jbpm.cfg.xml -->

<bean id="springHelper"

class="org.jbpm.pvm.internal.processengine.SpringHelper">

    <property name="jbpmCfg" value="jbpm.cfg.xml"></property>

</bean>

<bean id="processEngine" factory-bean="springHelper"

factory-method="createProcessEngine" />

8.1.3. 测试

@Test // 测试ProcessEngine

public void testProcessEngine() {

    ProcessEngine processEngine = (ProcessEngine)ac.getBean("processEngine");

    Assert.assertNotNull(processEngine);

}

8.1.4. 注意事项

如果做了JBPM4.4与Spring整合(使用了jbpm.tx.spring.cfg.xml),则在程序中就一定要使用Spring注入ProcessEngine,千万不能使用Configuration.getProcessEngine()生成ProcessEngine,因为这时内部的代码有以下逻辑:如果整合了Spring但没有ApplicationContext,就默认读取applicationContext.xml创建ApplicationContext实例并从中获取名为”ProcessEngine”的对象。而这时如果把pe = Configuration.getProcessEngine()写成某Spring中管理的bean的初始化代码,就会有无限循环,不停的创建ApplicationContext了!

8.2. 自行控制事务

1, 修改 jbpm.tx.hibernate.cfg.xml

a) 不让jBPM自行管理事务:去掉<standard-transaction-interceptor />

b) 让Jbpm使用SessionFactory.getCurrentSession():修改为 <hibernate-session current="true" />

2, 配置可以使用SessionFactory.getCurrentSession(),在jbpm.hibernate.cfg.xml 中配置:<property name="hibernate.current_session_context_class">thread</property>

3, 要使用同一个SessionFactory,且都要使用 SessionFactory.getCurrentSession() 获取 Session:

a) 同一个SessionFactory:SessionFactory sf = processEngine.get(SessionFactory.class)

b) 在 BaseDaoImpl 中增加:

i. getSession() { return HibernateUtils.getSessionFactory().getCurrentSession(); }

ii. getProcessEngine(){ return org.jbpm.api.Configuration.getProcessEngine(); }

4, 统一的打开与提交或回滚事务:使用 OpenSessionInViewFilter 控制事务。

8.3. 启动Tomcat后,访问JSP时(使用的是MyEclipse自带的Tomcat,是6.0的版本),报错:   Caused by: java.lang.LinkageError: loader constraints violated when linking javax/el/ExpressionFactory class

       at org.apache.jsp.WEB_002dINF.jsp.UserAction.loginUI_jsp._jspInit(loginUI_jsp.java:39)

       at org.apache.jasper.runtime.HttpJspBase.init(HttpJspBase.java:52)

       at org.apache.jasper.servlet.JspServletWrapper.getServlet(JspServletWrapper.java:159)

       at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:329)

       at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:320)

       at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:266)

       ... 40 more

说明:原因是Jbpm的juel.jar, juel-engine.jar, juel-impl.jar包和Tomcat6.0中的el-api.jar包冲突了。

有三个解决办法:

       1,方法一:在MyEclipse的Preferences -> MyEclipse -> Application Servers -> Tomcat -> .. -> Paths 中配置 Append to classpath,选中 juel.jar, juel-engine.jar, juel-impl.jar 这三个jar包就可以了。

       2,方法二:将 juel.jar, juel-engine.jar, juel-impl.jar 这三个包复制到tomcat6下 lib/ 中,并删除原来的el-api.jar,

切记还要把工程中 WEB-INF\lib 下的 juel.jar, juel-engine.jar, juel-impl.jar 删除,不然还是要冲突。

       3,方法三:换成tomcat5.5,就没有问题了。

8.4. 完成流程实例中的最后一个任务时报错(任务实例结束时),或删除流程定义级联删除流程实例时,报错如下:

com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (`itcastoa_20100909/jbpm4_execution`, CONSTRAINT `FK_EXEC_INSTANCE` FOREIGN KEY (`INSTANCE_`) REFERENCES `jbpm4_execution` (`DBID_`))

解决办法:把方言设为 MySQL5InnoDBDialect,不能是 MySQLDialect。

[t1]在java.util.logging.Level的javadoc中列出了可配置的所有输出级别为(由高到低):

· SEVERE (highest value)

· WARNING

· INFO

· CONFIG

· FINE

· FINER

· FINEST (lowest value)

[t2]如使用MySQLDialect,就会在流程实例结束时抛异常:com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException: Cannot delete or update a parent row: a foreign key constraint fails (`jbpm44_20101028/jbpm4_execution`, CONSTRAINT `FK_EXEC_INSTANCE` FOREIGN KEY (`INSTANCE_`) REFERENCES `jbpm4_execution` (`DBID_`))。

1.JPDL的程定义元素 1)第一层:GraphElement 这个容易理解,因为在画程定义时,每个拖拉的对象都是一个graph的元素。GraphElement有四个属性: (1)processDefine 表示当前元素属于哪个程定义 (2)events 表示可以接收哪些event (3)name 名字 (4)exceptionHandlers 异常处理类集合(List) 2)第二层:node、processDefinition、Transition、Task 它们都继承自GraphElement (1)processDefinition表示程定义(implements NodeCollection),它有下面的属性:name、version、nodes、startState。nodes表示程中所有的node,startState用于启动程时找到首节点。 (2)Transition表示转移,它有三个属性:from(Node),to(Node),supportedEventTypes表示支持的event类型 (3)node表示节点,它有四个属性:leaving transitions、arriving transitions、action、superState。 (4)Task 定义任务 3)第三层:各种不同的node 它们都继承自node。 Decision、EndState、Fork、Join、Merge、Milestone、 InterleaveEnd、InterleaveStart、ProcessState、State。 2.jBPM的token jbpm中最重要的概念,应该是令牌(Token)和信令(Signal)。在整个程实例运行过程中,我们可以迅速的利用token得到其当前的current state。在解决“并行”等(比如Fork)问题时,jBpm让Token对象维护了父子关系,这种关系在涉及到Fork的时候会产生。 jBpm让Token这个对象身兼了多种使命: (1)快速定位current state (2)用于fork,join算法 (3)用于告知任务执行者的任务索引。 如下代码: //pd是process definition,pi是process instance ProcessInstance pi = new ProcessInstance( pd ); //得到根令牌 Token token = pi.getRootToken(); //发信令 token.signal(); Token的signal方法也可以传入transition参数,这个方法把信令发送给Token,这样,令牌将被激活,并沿指定的transition离开当前的状态(如果没有指定transition,将沿缺省的transition 离开当前状态)。 jbpm是怎么实现的呢?其实很简单: 1)Token记录了当前的状态(current state),只有当前的状态(或称节点)拥有该令牌 2)向TOKEN发signal后,当前状态收到该signal 3)当前状态把令牌传给signal中指定的transition 4)transition收到令牌后,不强占,马上把令牌传给下个状态. 5)根据令牌的位置,程的状态已经发生改变. 3.process definition 一个process definition代表了一个正式的业务流程,它以一个程图为基础。这个程图由许多node和transition组成。每个node在这个程图里都有着各自特殊的类型,这些不同的类型决定了node在运行时的不同行为。一个process definition只有一个start state 。 4.token 一个token代表了一条执行路径,它包含了这条执行路径的当前的执行状态(current state)。 5.process instance 一个process instance(程实例)即一个process definition(程定义)的程执行实例。一个process definition可以对应多个process instance。当一个process instance被创建的时候,一个主执行路径token同时被创建,这个token叫做root token,它指向程定义的start state(processDefinition.getStartState()==token.getNode())。 6.signal 一个signal 发送给token通知token 继续程的执行。如果signal 没有指定transition,token将沿缺省的transition离开当前状态,如果signal 指定transition,token将沿指定的transition离开当前的状态。看源代码可以看到发给process instance的signal 其实都是发送给了root token。 7.Actions jbpm提供了灵活的action ,当程执行,token 进入node和transition时,会触发相应的一些event(事件)。在这些event上附上我们自己写的action,就会带动action 的执行。action里是我们自己的相关java操作代码,非常方便。注意的是event(事件)是内置的,无法扩展。另外,action也可以直接挂在node上,而不依赖于event(事件)的触发,这个很重要。 8.node 一个程图由许多node和transition组成。每个node都有一种类型,这个类型决定了当程执行到这个node时的不同行为。jbpm有一组node type可以供你选择,当然你可以定制自己node 。 node的作用 node有两个主要的作用: 1)执行java代码,比如说创建task instance(任务实例)、发出通知、更新数据库等等。很典型的就是在node 上挂上我们的action 2) 控制程的执行: A、等待状态:程进入到这个node时将处于等待状态,直到一个signal 的发出 B、程将沿着一个leaving transition越过这个node,这种情况特殊一点,需要有个action挂在这个node上(注意这个action不是event触发的!),action中将会调用到API里 executionContext.leaveNode(String transitionName),transitionName即这里的leaving transition名字。 C、创建新的执行路径: 很典型的就是fork node。程在这里会分叉,产生新的执行路径。这样就创建了新的token,每个新的token代表一个新的执行路径。注意的是,这些新的token和产生前的token是父子关系! D、结束执行路径:一个node可以结束一条执行路径,这同样意味着相应的token的结束和程的结束。 9.程图中的node type 1)task-node 一个task-node可以包含一个或多个task,这些task分配给特定的user。当程执行到task-node时,task instance将会被创建,一个task对应一个task instance。task instances 创建后,task-node就处于等待状态。当所有的task instances被特定的user执行完毕后,将会发出一个新的signal 到token,即程继续执行。 2)state state是一个纯粹的wait state(等待状态)。它和task-node的区别就是它不会创建task instances。很典型的用法是,当进入这个节点时(通过绑定一个action到node-enter event),发送一条消息到外部的系统,然后程就处于等待状态。外部系统完成一些操作后返回一条消息,这个消息触发一个signal 到token,然后程继续执行。(不常用) 3)decision 当需要在程中根据不同条件来判断执行不同路径时,就可以用decision节点。两种方法:最简单的是在transitions里增加condition elements(条件),condition是beanshell script写的,它返回一个boolean。当运行的时候,decision节点将会在它的 leaving transitions里循环,同时比较 leaving transitions里的condition,最先返回'true'的condition,那个leaving transitions将会被执行;作为选择,你可以实现DecisionHandler接口,它有一个decide()方法,该方法返回一个String(leaving transition的名字)。 4)fork fork节点把一条执行路径分离成多条同时进行(并发)的执行路径,每条离开fork节点的路径产生一个子token。 5)join 默认情况下,join节点会认为所有到达该节点的token都有着相同的父token。join 节点会结束每一个到达该节点的token,当所有的子token都到达该节点后,父token会激活。当仍然有子token处于活动状态时,join 节点是wait state(等待状态)。 6)node node节点就是让你挂自己的action用的(注意:不是event触发!),当程到达该节点时,action会被执行。你的action要实现ActionHandler接口。同样,在你的action里要控制程。 10. Actions的说明 存在两种action,一种是 event触发的action,一种是挂在node 节点的action。要注意它们的区别,event触发的action无法控制程,也就是说它无法决定程经过这个节点后下一步将到哪一个leaving transition;而挂在node 节点的action就不同,它可以控制程。不管是哪一种action都要实现ActionHandler接口。 11. Task(任务) jbpm一个相当重要的功能就是对任务进行管理。Task(任务)是程定义里的一部分,它决定了task instance的创建和分配。Task(任务)可以在task-node节点下定义,也可以挂在process-definition节点下。最普遍的方式是在task-node节点下定义一个或多个任务。默认情况下,程在task-node节点会处于等待状态,直到所有的任务被执行完毕。任务的名称在整个程中必须是唯一的。一个TaskNode对应多个Task。 对于这样的程定义: xml 代码 1. <task-node name='a'> 2. <task name='laundry' /> 3. <task name='dishes' /> 4. <task name='change nappy' /> 5. <transition to='b' /> 6. </task-node> 只有当节点中的三个任务都完成后,程才进入后面的节点 对于这样的程定义: xml 代码 1. <task-node name='a' signal='first'>> 2. <task name='laundry' /> 3. <task name='dishes' /> 4. <task name='change nappy' /> 5. <transition to='b' /> 6. </task-node> 当第一个任务完成后,token就指向后面的节点 对于这样的程定义: xml 代码 1. <task-node name='a' signal='never'>> 2. <task name='laundry' /> 3. <task name='dishes' /> 4. <task name='change nappy' /> 5. <transition to='b' /> 6. </task-node> 三个任务都完成后,token仍然不会指向后面的节点;需要自己手动调用processInstance.signal()才会驱动程到下面的节点。 对于这样的程定义: xml 代码 1. <task-node name='a' signal='unsynchronized'>> 2. <task name='laundry' /> 3. <task name='dishes' /> 4. <task name='change nappy' /> 5. <transition to='b' /> 6. </task-node> token不会在本节点停留,而是直接到后面的节点 12. jbpm的任务管理实现 一个Task instance(任务实例)可以被分配给一个actorId (java.lang.String)。所有的Task instance都被保存在数据库中的表jbpm_taskinstance里。当你想得到特定用户的任务清单时,你就可以通过一个与用户关联的actorId来查询这张表。 一个程定义有一个TaskMgmtDefinition;一个TaskMgmtDefinition对应多个swimlane,同时对应多个task;一个swimlane有多个task,可以从TaskMgmtDefinition中通过task的名称直接获取相应的task; swimlane对象有四个属性,分别是name(名字)、assignmentDelegation(分配代理类)、taskMgmtDefinition、tasks(Set 对应多个task),可以增加task task对象主要的属性:taskMgmtDefinition、swimlane、assignmentDelegation、taskNode,需要注意的是swimlane和assignmentDelegation中间只是可以一个属性有值,因为它们都和任务的分配有关系。 一个程实例有一个TaskMgmtInstance;一个TaskMgmtInstance对应多个swimlaneInstance,同时对应多个taskInstance;一个swimlaneInstance有多个taskInstance,可以从TaskMgmtInstance中直接获取相应的taskInstance; swimlaneInstance对象主要有五个属性,分别是name、actorId、pooledActors(Set)、swimlane、taskMgmtInstance。 taskInstance对象的主要属性:name、actorId、task、swimlaneInstance、taskMgmtInstance、pooledActors。 当对任务进行分配时,一般需要实现AssignmentHandler这个接口,这个接口的方法只有一个: void assign( Assignable assignable, ExecutionContext executionContext) throws Exception; 一个典型的实现(把名字是'change nappy'的任务交给NappyAssignmentHandler这个类来分配) xml 代码 1. <task name='change nappy'> 2. <assignment class='org.jbpm.tutorial.taskmgmt.NappyAssignmentHandler' /> 3. task> NappyAssignmentHandler类: java 代码 1. public void assign(Assignable assignable, ExecutionContext executionContext) { 2. assignable.setActorId("papa"); 3. } 同样,Assignable只是一个接口,它有两个方法:setActorId()和setPooledActors(),Assignable的具体实现类也是两个:swimlaneInstancehe和taskInstance。这样就不不难理解整个任务分配程了: 1、程进入TaskNode节点,执行TaskNode类的execute()方法,该方法首先获得TaskMgmtInstance实例,然后通过它来创建TaskInstance。taskMgmtInstance.createTaskInstance(task, executionContext); 2、在上面的createTaskInstance(task, executionContext)里,该方法调用了taskInstance.assign(executionContext)对taskInstance进行分配。 3、在assign(executionContext)方法里,首先会判断task属性里是否存在swimlane,如果有的话,这个taskInstance就会分配给swimlane指定的ActorId或 PooledActors;如果不存在,再去找task属性里 assignmentDelegation(分配代理类)通过代理类(即我们自己写的实现AssignmentHandler这个接口的类)指定ActorId或 PooledActors。 13. jbpm的用户角色管理 jbpm在用户角色管理上共设计了四个类:Entity、Membership、Group、User。 Entity类是其他三个类的父类,它包含了两个属性:name(String)、permissions(Set); User类继承Entity类,包含三个属性:password(String)、email(String)、memberships(Set); Group类继承Entity类,包含四个属性: type(String)、parent(Group)、children(Set)、memberships(Set); Membership类继承Entity类,包含三个属性:role(String)、user(User)、group(Group) 很明显,一个user对应一个用户,一个group对应一个用户组,它们之间通过membership关联,并且一个user可以属于多个不同类型(type)的group,user和 group之间是多对多的关系。Membership类的role属性个人感觉用途不大,反倒是name属性代表了user在group里的role(角色)。
参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值