jBPM实现高级交互模式详解

JBPM是目前应用广泛的Java工作流管理系统，在51CTO之前报道的J2EE工作流管理系统JBPM详解中，我们曾详细介绍过JBPM的工作原理和工作流应用方案。今天通过对JBPM中的四眼原则、任命和上报的实现来详细讲解如何使用JBPM实现高级交互模式。

#t#

许多通用业务流程都包含人类参与者。人类活动，从简单场景（如人工批准）到复杂场景（涉及复杂的数据输入），在流程实现中引入了新的方面，如人类交互模式。人类交互模式的一个典型集合包括：

1、四眼原则（The 4-eyes principle），通常又被称为“职责分离”，它是决策由多人彼此独立作出时的一个常见场景。在很多情况下，很容易就能得到另一个观点/签名。

2、任命（Nomination）是指上级根据团队成员的任务安排、工作负荷或经验人工地将任务分配给他的情形。

3、任务通常被建模来表达一种预期：它们将在确定时间段内完成。如果任务没有按预期地进展，就需要一种上报（escalation）机制。两种典型的上报实现是：重新分配任务，并常常附带一个上报已经发生的通知；或任务未按时完成的通知（通常发给经理）。

4、链状执行（Chained execution）是一个流程（片断），其中的一系列步骤是由同一个人来完成。

在本文中，我将讨论如何实现JBPM高级交互模式。

JBPM中的任务管理

JBPM的一个核心功能2是为人类管理任务和任务列表。JBPM允许将任务和任务节点作为整个流程设计的一部分使用。

任务一般在JBPM中定义成任务节点。单个任务节点可以包含一个或多个任务。包含任务节点的JBPM流程的一个公共行为就是等待任务节点中的全部任务完成，然后继续执行。某个任务可被分配3 给个人、用户组或泳道：

假如任务被分配给某个特定用户，那么就只有这个使用者可以执行它。

假如任务被分配给某个用户组，那么这个组内的任何参与者都能执行这个任务。JBPM使用的是参与者池（pooled actors）符号（它可以包含组名、组名列表和参与者个人列表等），而不是组ID。如果用户开始执行在他们组任务列表中的任务，最终可能会引起冲突4——可能有多人开始执行相同的任务。为了避免这种情况，在开始执行任务之前，用户应该将任务从组任务列表移动到他们自己的任务列表中。

泳道代表一个流程角色，它通常被分配给一个用户组。它是一种指定流程中的多个任务要由同一参与者完成的机制5。因此，在第一个任务被分配给某个泳道之后，流程就会记住所有在相同泳道内的后续任务都将由同一参与者完成。

JBPM提供了两种定义任务分配的基本方法：作为流程定义的一部分或通过编程实现。如果是作为流程定义的一部分，分配可以通过指定具体用户、用户组或泳道完成。此外，可以使用表达式根据流程变量动态确定某个具体用户。完整的编程实现是基于分配处理器（assignment handler）的6，它允许任务根据任意的计算规则去查找用户ID。那么如何才能很好的实现JBPM高级交互模式这一功能呢，让我们继续往下看。

流程定义描述流程实例的方式类似任务描述任务实例的方式。当流程执行时，一个流程实例——流程的运行时表示——就会被创建。类似，一个任务实例——任务的运行时表示——就会被创建。根据任务定义，任务实例被分配给一个参与者/参与者组。

任务实例的一个作用就是支持用户交互——把数据显示给用户并从用户那里收集数据。一个JBPM任务实例拥有访问流程（令牌）变量7的全部权限，而且还可以有自己的变量。任务能够拥有自己的变量对于以下场景非常有用：

在任务实例中创建流程变量的副本，这样对任务实例变量的即时更新只有在该任务完成且这些副本被提交给流程变量时才会影响流程变量。

创建更好支持用户活动的“派生（计算）”变量。

任务自己的变量在JBPM中是通过任务控制器处理器（task controller handler）支持的，它可以在任务实例创建时生成任务实例数据（从流程数据），并在任务实例完成时将任务实例数据提交给流程变量。

#p#

扩展Task类

JBPM高级交互模式的实现操作中任务的定义被包含在org.JBPM.taskmgmt.def.Task类中。为了支持四眼原则，我们需要给类增加以下的字段/方法（清单1）：

protected int numSignatures = 1;  
public int getNumSignatures(){  
return numSignatures;  
}  
public void setNumSignatures
(int numSignatures){  
this.numSignatures = 
numSignatures;  
} 

清单1 给Task类增加字段和方法

这个新的参数允许指定任务完成所需的JBPM高级交互模式任务处理人数量。缺省值为1，这意味着，只有1个用户应该/可以处理这个任务。

JBPM使用Hibernate来向数据库保存和读取数据。为了让我们新加的变量持久化，我们需要更新Task类的Hibernate配置文件（Task.hbm.xml），它在org.JBPM.taskmgmt.def文件夹中，增加代码如下（清单2）

<   property name="numSignatures" 
column="NUMSIGNATURES_" /> 

清单2 在Task映射文件中指定新增域

为了让我们新加的属性能被流程定义和数据库正确读取，我们需要修改org.JBPM.jpdl.xml.JpdlXmlReader类以正确地读取我们的新属性（清单3）

String numSignatureText = 
taskElement.attributeValue
("numSignatures");  
if (numSignatureText != null) {  
try{  
task.setNumSignatures
(Integer.parseInt(num
SignatureText));  
}  
catch(Exception e){}  
} 

清单3 读取numSignature属性

最后，因为JpdlXmlReader根据模式来验证XML，因此我们需要在jpdl-3.2.xsd中增加一个属性定义（清单4）：

<   xs:element name="task"> 
………………….  
<   xs:attribute name=
"numSignatures" type=
"xs:string" /> 

清单4 在jpdl-3.2.xsd中增加numSignatures属性

当完成这些工作，JBPM高级交互模式的任务定义就被扩展可以使用numSignatures属性（清单5）：

<   task name="task2" 
numSignatures = "2">   
<   assignment pooled-actors
="Peter, John"> 
<   /assignment>   
<   /task> 

清单5 给任务定义增加numSignatures属性

#p#

扩展TaskInstance类

在JBPM高级交互模式实现操作到此处时，扩展完任务类后，我们还需要创建一个自定义的任务实例类来跟踪分配给该任务实例的参与者，并确保所有被分配的参与者完成类执行（清单6）。

package com.navteq.JBPM.extensions;  
import java.util.Date;  
import java.util.LinkedList;  
import java.util.List;  
import org.JBPM.JBPMException;  
import org.JBPM.taskmgmt.exe.TaskInstance;  
public class AssignableTaskInstance 
extends TaskInstance {  
private static final long 
serialVersionUID = 1L;  
private List<  Assignee> assignees = 
new LinkedList<  Assignee>();  
private String getAssigneeIDs(){  
StringBuffer sb = new StringBuffer();  
boolean first = true;  
for(Assignee a : assignees){  
if(!first)  
sb.append(" ");  
else   
first = false;  
sb.append(a.getUserID());  
}  
return sb.toString();  
}  
public List<  Assignee> getAssignees() {  
return assignees;  
}  
public void reserve(String userID) 
throws JBPMException{  
if(task == null)  
throw new JBPMException("can't 
reserve instance with no task");  
// Duplicate assignment is ok  
for(Assignee a : assignees){  
if(userID.equals(a.getUserID()))  
return;  
}  
// Can we add one more guy?  
if(task.getNumSignatures() > 
assignees.size()){  
assignees.add(new Assignee(userID));  
return;  
}  
throw new JBPMException("task 
is already reserved by " +  
getAssigneeIDs());  
}  
public void unreserve(String userID){  
for(Assignee a : assignees){  
if(userID.equals(a.getUserID())){  
assignees.remove(a);  
return;  
}  
}  
}  
private void completeTask(Assignee 
assignee, String transition){  
assignee.setEndDate(new Date());  
// Calculate completed assignments  
int completed = 0;  
for(Assignee a : assignees){  
if(a.getEndDate() != null)  
completed ++;  
}  
if(completed <   task.getNumSignatures())  
return;  
if(transition == null)  
end();  
else   
end(transition);  
}  
public void complete(String userID, 
String transition) throws JBPMException{  
if(task == null)  
throw new JBPMException("can't 
complete instance with no task");  
// make sure it was reserved  
for(Assignee a : assignees){  
if(userID.equals(a.getUserID())){  
completeTask(a, transition);  
return;  
}  
}  
throw new JBPMException("task 
was not reserved by " + userID);  
}  
public boolean isCompleted(){  
return (end != null);  
}  
} 

清单6 扩展TaskInstance类

这个JBPM高级交互模式的操作实现扩展了JBPM提供的TaskInstance类，并跟踪完成该实例所需的参与者个数。它引入了几个新方法，允许参与者预留（reserve）/退还（unreserve）任务实例，以及让指定参与者完成任务执行。

#p#

JBPM高级交互模式的实现操作中，清单6的实现依赖一个支持类Assignee（清单7）

package com.navteq.JBPM.extensions;  
import java.io.Serializable;  
import java.text.DateFormat;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
public class Assignee implements 
Serializable{  
private static final long 
serialVersionUID = 1L;  
private static final DateFormat 
dateFormat = new   
SimpleDateFormat("yyyy/MM/dd HH:mm:ss");  
long id = 0;  
protected String startDate = null;  
protected String userID = null;  
protected String endDate = null;  
public Assignee(){}  
public Assignee(String uID){  
userID = uID;  
startDate = dateFormat.format(new Date());  
}  
//////Setters and Getters //////  
public long getId() {  
return id;  
}  
public void setId(long id) {  
this.id = id;  
}  
public String getStartDate() {  
return startDate;  
}  
public void setStartDate(String startDate) {  
this.startDate = startDate;  
}  
public String getUserID() {  
return userID;  
}  
public void setUserID(String id) {  
userID = id;  
}  
public String getEndDate() {  
return endDate;  
}  
public void setEndDate(String endDate) {  
this.endDate = endDate;  
}  
public void setEndDate(Date endDate) {  
this.endDate = dateFormat.format(endDate);  
}  
public void setEndDate() {  
this.endDate = dateFormat.format(new Date());  
}  
public String toString(){  
StringBuffer bf = new StringBuffer();  
bf.append(" Assigned to ");  
bf.append(userID);  
bf.append(" at ");  
bf.append(startDate);  
bf.append(" completed at ");  
bf.append(endDate);  
return bf.toString();  
}  
} 

清单7 Assignee类

#p#

JBPM高级交互模式自定义的TaskInstance类和Assignee类都必须保存到数据库中。这意味着需要给这两个类实现Hibernate映射14 （清单8，9）：

<  ?xml version="1.0"?>   
<  !DOCTYPE hibernate-mapping PUBLIC "-
//Hibernate/Hibernate Mapping DTD 3.0
//EN" "http://hibernate.sourceforge.net
/hibernate-mapping-3.0.dtd">   
<  hibernate-mapping auto-import="false" 
default-access="field">   
<  subclass namename="com.navteq.JBPM.
extensions.AssignableTaskInstance" 
extends="org.JBPM.taskmgmt.exe.
TaskInstance" discriminator-value="A">   
<  list name="assignees" cascade="all" >   
<  key column="TASKINSTANCE_" />   
<  index column="TASKINSTANCEINDEX_"/>   
<  one-to-many class="com.navteq.
JBPM.extensions.Assignee" />   
<  /list>   
<  /subclass>   
<  /hibernate-mapping> 

清单8 自定义任务实例的Hibernate映射文件

<  ?xml version="1.0"?>   
<  !DOCTYPE hibernate-mapping PUBLIC "-
//Hibernate/Hibernate Mapping DTD 3.0
//EN" "http://hibernate.sourceforge.net
/hibernate-mapping-3.0.dtd">   
<  hibernate-mapping auto-import=
"false" default-access="field">   
<  class name="com.navteq.JBPM.
extensions.Assignee" table=
"JBPM_ASSIGNEE">   
<  cache usage="nonstrict-read-write"/>   
<  id name="id" column="ID_"> 
<  generator class="native" /> 
<  /id> <  !-- Content -->   
<  property name="startDate" 
column="STARTDATE_" />   
<  property name="userID" 
column="USERID_" />   
<  property name="endDate" 
column="ENDDATE_" />   
<  /class>   
<  /hibernate-mapping> 

清单9 Assignee类的Hibernate映射文件

要让JBPM高级交互模式的实现操作能够使用我们的自定义任务实例实现，我们还需要提供一个自定义的任务实例工厂（清单10）。

package com.navteq.JBPM.extensions;  
import org.JBPM.graph.exe.ExecutionContext;  
import org.JBPM.taskmgmt.TaskInstanceFactory;  
import org.JBPM.taskmgmt.exe.TaskInstance;  
public class AssignableTaskInstanceFactory 
implements TaskInstanceFactory {  
private static final long serialVersionUID = 1L;  
@Override  
public TaskInstance createTaskInstance
(ExecutionContext executionContext) {  
return new AssignableTaskInstance();  
}  
} 

清单10 自定义的任务实例工厂

最后，为了让JBPM运行时使用正确的任务实例工厂（清单10），还必须创建一个新的JBPM配置（清单11）。

<  JBPM-configuration>   
<  bean name="JBPM.task.instance.
factory" class="com.navteq.JBPM.
extensions.AssignableTask
InstanceFactory" singleton="true" />   
<  /JBPM-configuration> 

清单11 JBPM配置

完成所有这些变更之后（清单1-11），一个典型的任务处理显示如下：

List<  String> actorIds = 
new LinkedList<  String>();  
actorIds.add("Peter");  
List<  TaskInstance> cTasks = 
JBPMContext.getGroupTaskList(actorIds)  
TaskInstance cTask = cTasks.get(0);  
AssignableTaskInstance aTask = 
(AssignableTaskInstance)cTask;  
try{  
aTask.reserve("Peter");  
// Save  
JBPMContext.close();  
}  
catch(Exception e){  
System.out.println("Task " + 
cTask.getName() + " is already reserved");  
e.printStackTrace();  
} 

清单12 处理可分配任务实例

这里，在得到某个用户的任务实例并将其转变成可分配任务实例之后，我们将试着预留它15。一旦预留成功，我们将关闭JBPM高级交互模式运行时以提交事务。

#p#

实现任命

JBoss JBPM可以非常轻易的实现手动将任务分配给特定用户。根据JBPM提供的简单API，可以完成将任务实例从一个任务列表移动到另一个任务列表，因此给某个用户分配任务相当直接（清单13）

List< String> actorIds = 
new LinkedList< String>();  
actorIds.add("admins");  
String actorID = "admin";  
List< TaskInstance> cTasks = 
JBPMContext.getGroupTaskList(actorIds);  
TaskInstance cTask = cTasks.get(0);  
cTask.setPooledActors((Set)null);  
cTask.setActorId(actorID); 

 

清单13 将任务重新分配给指定用户

在JBPM高级交互模式的操作中，提供了2类不同的API来设置参与者池：一类接收字符串id数组，另一类则接收id集合。如果要清空一个池，就要使用那个接收集合的API（传入一个null集合）。

实现上报

前面已经说过，上报一般被实现为任务的重新分配，并常常附带一个上报已发生的通知；或是实现成一个任务未及时完成的通知。

实现为重新分配的上报

尽管JBPM不直接支持上报，但它提供了2个基本的机制：超时和重新分配（参见上节）。粗一看，实现上报只需将这二者结合即可，但是仔细一想还是存在一些困难：

JBPM实现中的关系并不总是双向的。如，从一个任务节点我们可以找到所有这个节点定义的任务，但是从一个任务，并没有API可以完成找到包含它的任务节点的工作16；由某个任务实例，你可以得到一个任务，但是没有由某个任务得到所有实例的API，诸如此类。

超时不是发生在任务自身，而是发生在任务节点上。由于某个节点可以关联多个任务，并且JBPM关系实现并不是双向的（见上），因此要跟踪当前任务实例就需要其他的支持手段。
以重新分配实现的上报的整个实现17涉及3个处理器：

负责给任务分配参与者的分配处理器。这个处理器跟踪它是一个首次任务调用还是一个上报任务调用。清单14给出了一个分配处理器的例子。

package com.sample.action;  
import org.JBPM.graph.def.Node;  
import org.JBPM.graph.exe.
ExecutionContext;  
import org.JBPM.taskmgmt.def.
AssignmentHandler;  
import org.JBPM.taskmgmt.exe.
Assignable;  
public class EscalationAssi
gnmentHandler implements 
AssignmentHandler {  
private static final long 
serialVersionUID = 1L;  
@Override  
public void assign(Assignable assignable, 
ExecutionContext context)  
throws Exception {  
Node task = context.getToken().getNode();  
if(task != null){  
String tName = task.getName();  
String vName = tName + "escLevel";  
Long escLevel = (Long)context.
getVariable(vName);  
if(escLevel == null){  
// First time through  
assignable.setActorId("admin");  
}  
else{  
// Escalate  
assignable.setActorId("bob");  
}  
}  
}  
} 

清单14 分配处理器示例

在JBPM高级交互模式的实现操作中我们尝试得到一个包含了给定任务上报次数的流程变量。如果变量未定义，则就分配“admin”为任务拥有者，否则任务就被分配给“bob”。在这个处理器中可以使用任何其他的分配策略。

任务实例创建动作处理器（清单15），它保存流程实例上下文的任务实例id

package com.sample.action;  
import org.JBPM.graph.def.ActionHandler;  
import org.JBPM.graph.def.Node;  
import org.JBPM.graph.exe.ExecutionContext;  
import org.JBPM.taskmgmt.exe.TaskInstance;  
public class TaskCreationActionHandler 
implements ActionHandler {  
private static final long 
serialVersionUID = 1L;  
@Override  
public void execute(ExecutionContext 
context) throws Exception {  
Node task = context.getToken().getNode();  
TaskInstance current = 
context.getTaskInstance();  
if((task == null) || (current == null))  
return;  
String tName = task.getName();  
String iName = tName + "instance";  
context.setVariable(iName, 
new Long(current.getId()));  
}  
} 

清单15 任务实例创建处理器

JBPM高级交互模式中任务节点计时器触发调用的超时处理器（清单16）。

package com.sample.action;  
import org.JBPM.graph.def.ActionHandler;  
import org.JBPM.graph.def.GraphElement;  
import org.JBPM.graph.exe.ExecutionContext;  
import org.JBPM.taskmgmt.exe.TaskInstance;  
public class EscalationActionHandler 
implements ActionHandler {  
private static final long 
serialVersionUID = 1L;  
private String escalation;  
@Override  
public void execute(ExecutionContext 
context) throws Exception {  
GraphElement task = context.getTimer().
getGraphElement();  
if(task == null)  
return;  
String tName = task.getName();  
String vName = tName + "escLevel";  
long escLevel = (long)context.
getVariable(vName);  
if(escLevel == null)  
escLevel = new long(1);  
else  
escLevel += 1;  
context.setVariable(vName, escLevel);  
String iName = tName + "instance";  
long taskInstanceId = (long)
context.getVariable(iName);  
TaskInstance current =   
context.getJBPMContext().
getTaskInstance(taskInstanceId);  
if(current != null){  
current.end(escalation);  
}  
}  
} 

清单16 超时处理器

这个处理器首先记录上报计数器，接着完成此节点关联的任务实例。任务实例的完成伴随有一个变迁（一般是回到任务节点）。

使用以上描述的处理器实现JBPM高级交互模式的上报的简单流程例子显示在清单17中。

< ?xml version="1.0" encoding="UTF-8"?>   
< process-definition xmlns="urn:JBPM.
org:jpdl-3.2" name="escalationHumanTaskTest">   
< start-state name="start">   
< transition to="customTask"> 
< /transition>   
< /start-state>   
< task-node name="customTask">   
< task name="task2">   
< assignment class="com.sample.action.
EscalationAssignmentHandler"> 
< /assignment>   
< /task>   
< event type="task-create">   
< action name="Instance Tracking" 
class="com.sample.action.
TaskCreationActionHandler"> 
< /action>   
< /event>   
< timer duedate="10 second" 
name="Escalation timeout">   
< action class="com.sample.action.
EscalationActionHandler"> < escalation>   
escalation   
< /escalation>   
< /action>   
< /timer>   
< transition to="end" name="to end"> 
< /transition>   
< transition to="customTask" 
name="escalation"> 
< /transition>   
< /task-node>   
< end-state name="end"> 
< /end-state>   
< /process-definition> 

清单17 简单流程的上报

实现成通知的上报

JBPM为邮件传递提供了强大支持18，这使得实现成通知的上报变得极其简单。邮件传递可由给节点附加定时器，然后触发，它使用已经写好的邮件动作来完成通知传递。

实现链状执行

链状执行直接由JBPM泳道支持，并不需要额外的开发。

总结

不管我们在自动化方面投入多少努力，面对复杂的业务流程，总免不了要有人工介入的可能。在这篇JBPM高级交互模式的操作介绍的文章中，我给出了一系列已建立的高级人工交互模式，并展示了用JBPM完成它是多么轻而易举。