JBPM4工作流应用(二）

 5.task人工任务活动
   1）、使用task活动的assignee属性进行任务分配

 

 

<task name="review" assignee="#{order.owner}"> 
<transition to="wait" /> 
</task>

 

   Assignee属性默认会被作为EL表达式来执行，任务被分配给#{order.owner}。

  

Map<String, Object> variables = new HashMap<String, Object>(); 
variables.put("order", new Order("johndoe")); 
//当一个新流程实例会被创建， 把order 作为一个流程变量分配给它 
ProcessInstance processInstance = executionService 
.startProcessInstanceByKey("TaskAssignee", variables); 
//获取johndoe的任务列表 
List<Task> taskList = taskService.findPersonalTasks("johndoe"); 

 

   2）任务侯选者（candidate-groups,candidate-users）
      candidate-groups:一个使用逗号分隔的组id 列表,所有组内的用户将会成为这个任务的 候选人。
      candidate-users: 一个使用逗号分隔的用户id 列表,所有的用户将会成为这个任务的候选人。

 

<task name="review" candidate-groups="sales-dept> 
<transition to="wait" />
 </task>

 

   部分事例代码如下：

 

// 创建sales-dept组 
dept = identityService.createGroup("sales-dept"); 
// 创建用户johndoe,并加入sales-dept组
 identityService.createUser("johndoe", "John", "Doe"); 
identityService.createMembership("johndoe", dept, "developer");
 // 创建用户joesmoe,并加入sales-dept组 
identityService.createUser("joesmoe", "Joe", "Smoe"); 
identityService.createMembership("joesmoe", dept, "developer"); 
//在流程创建后， 任务会出现在johndoe 和joesmoe 用户的分组任务列表中 
List<Task> taskList = taskService.findGroupTasks("joesmoe"); 
List<Task> taskList = taskService.findGroupTasks("johndoe"); 
//候选人在处理任务之前，必须先接受任务，接受任务后，就会由任务的候选者变成 
// 任务的分配者。同时，此任务会从所有候选者的任务列表中消失。 
taskService.takeTask(task.getId(), "johndoe");

 

 

   3）任务分配处理器(AssignmentHandler)

 

<task name="review">
 <!--assignment-handler 是任务元素的一个子元素,它指定用户代码对象 --> 
<assignment-handler 
class="org.jbpm.examples.task.assignmenthandler.AssignTask"> 
<field name="assignee"> 
<string value="johndoe" /> 
</field> 
</assignment-handler> 
<transition to="wait" /> 
</task>

 

   AssignTask类必须实现AssignmentHandler类，代码如下：

  

//默认AssignmentHandler 实现可以使用使用流程变量 
public class AssignTask implements AssignmentHandler { 
     String assignee;
     public void assign(Assignable assignable, OpenExecution execution) { 
       assignable.setAssignee(assignee);
     }
 }

  

   4）任务泳道(Swimlanes)
     泳道可以理解为流程定义的”全局用户组”，也可以被当作一个流程规则。流程定义中的多个任务需要被分配或候选给
      同一个群用户，统一将这个“同一群用户”定义为“一个泳道”。

 

<!—-在这里定义泳道，属全局用户组--> 
<swimlane name="sales representative" candidate-groups="sales-dept" /> 
<!-- swimlane 引用一个定义在流程中的泳道 --> 
<task name="enter order data" swimlane="sales representative"> 
<transition to="calculate quote"/>
 </task> 
<task name="calculate quote" swimlane="sales representative"> 
</task>

 

 

   泳道中的用户组中的用户在接受任务后成为任务的分配者，同时泳道也会发生变化，接收任务者在流程实例中会被固化为分配者。

taskService.takeTask(taskId, "johndoe");
 assertEquals(0, taskService.findGroupTasks("johndoe").size()); 
taskList = taskService.findPersonalTasks("johndoe"); 
assertEquals(1, taskList.size()); 

  

6.子流程活动(sub-process)

   1)父子流程间的数据交换（parameter-in，parameter-out）
       父流程SubProcessDocument定义JPDL:

<process name="SubProcessDocument" xmlns="http://jbpm.org/4.4/jpdl"> 
<start> 
<transition to="review" /> 
</start> 
<sub-process name="review" sub-process-key="SubProcessReview"> 
<parameter-in var="document" subvar="document" /> 
<parameter-out var="reviewResult" subvar="result" /> 
<transition to="wait" />
 </sub-process> 
<state name="wait"/> 
</process>

 

    子流程SubProcessReview定义JPDL:

<process name="SubProcessReview" xmlns="http://jbpm.org/4.4/jpdl"> 
<start>
 <transition to="get approval"/> 
</start>
 <task name="get approval" assignee="johndoe"> 
<transition to="end"/>
 </task> 
<end name="end"/> 
</process>
 

   流程变量是父子流程用来沟通的纽带。父流程在子流程启动时将自己的“父流程变量”输入子流程，
   反之，子流程在结束时可以将自己的“子流程变量”返回父流程，从而实现父子流程间的数据交换。
    部分事例代码如下：

// 分别部署子流程跟父流程 
String subProcessReviewDeploymentId = repositoryService.createDeployment() 
.addResourceFromClasspath("org/jbpm/examples/subprocess/variables/SubProcessReview.jpdl.xml")
 .deploy(); 
String subProcessDocumentDeploymentId = repositoryService.createDeployment() 
.addResourceFromClasspath("org/jbpm/examples/subprocess/variables/SubProcessDocument.jpdl.xml") 
.deploy(); 
Map<String, Object> variables = new HashMap<String, Object>(); 
variables.put("document", "This document describes how we can make more money..."); 
//设置父流程的变量document ProcessInstance processInstance = executionService
 .startProcessInstanceByKey("SubProcessDocument", variables); 
List<Task> taskList = taskService.findPersonalTasks("johndoe"); Task task = taskList.get(0);
 // 父流程的变量document会被传入子流程，此处为获取子流程的变量document 
String document = (String) taskService
.getVariable(task.getId(), "document"); 
variables = new HashMap<String, Object>(); 
variables.put("result", "accept"); 
// 在子流程中设置流程变量result,该流程变量可在父流程中获取 taskService.setVariables(task.getId(), variables);
 taskService.completeTask(task.getId());
 processInstance = executionService.findProcessInstanceById(processInstance.getId()); 
// 在父流程中获取子流程中设置的流程变量result,名称为reviewResult 
String result = (String) executionService
.getVariable(processInstance.getId(), "reviewResult"); 
assertEquals("accept", result);

 

 

   2）通过outcome属性影响父流程的流程转移
      父流程SubProcessReview定义：

 

<!--父流程中的outcome属性引用名称为result的子流程变量
 <sub-process name="review" sub-process-key="SubProcessReview" outcome="#{result}">
 <!—如果result值等于ok,则流向此转移--> 
<transition name="ok" to="next step" /> 
<transition name="nok" to="update" /> 
<transition name="reject" to="close" /> 
</sub-process>

 

   子流程SubProcessReview定义：

<start> 
<transition to="get approval"/>
 </start> 
<task name="get approval" assignee="johndoe"> 
<transition to="end"/> 
</task> 
<end name="end" />

 

   部分事例代码如下：

ProcessInstance processInstance = executionService 
.startProcessInstanceByKey("SubProcessDocument");
 List<Task> taskList = taskService.findPersonalTasks("johndoe"); 
Task task = taskList.get(0);
 Map<String, Object> variables = new HashMap<String, Object>(); 
variables.put("result", "ok");
 // 在子流程中设置流程变量result值为ok,这个ok值会被传递给outcome属性以决定父流程的走向。 
taskService.setVariables(task.getId(), variables); 
taskService.completeTask(task.getId()); 
processInstance = executionService.findProcessInstanceById
(processInstance.getId()); 
assertNotNull(processInstance.findActiveExecutionIn("next step")); 

 

    3）设置不同的子流程end活动名称自动关联父流程的流出转移

      父流程SubProcessReview定义：

<sub-process name="review" sub-process-key="SubProcessReview"> 
<transition name="ok" to="next step" /> 
<transition name="nok" to="update" /> 
<transition name="reject" to="close" /> 
</sub-process> <state name="next step" /> 
<state name="update" /> 
<state name="close" /> 

 

   子流程SubProcessReview定义：

<task assignee="johndoe" name="get approval">
 <transition name="ok" to="ok"/> 
<transition name="nok" to="nok"/>
 <transition name="reject" to="state1"/>
 </task>
 <end name="ok"/> 
<end name="nok"/> 
<end name="reject"/>
 <state name="state1" >
 <transition name="to reject" to="reject"/> 
</state>

 

    部分事例代码如下：

ProcessInstance processInstance = executionService 
.startProcessInstanceByKey("SubProcessDocument");
 List<Task> taskList = taskService.findPersonalTasks("johndoe"); 
Task task = taskList.get(0); 
//子流程活动结束于ok活动返回父流程实例，父流程会自动地通过名称为ok的转移， 
//进入"next step活动" taskService.completeTask(task.getId(), "ok"); 
processInstance = executionService
.findProcessInstanceById(processInstance.getId()); 
assertNotNull(processInstance.findActiveExecutionIn("next step")); 

 

 

7.自定义活动
   如果有特殊而复杂的业务需求，与其生套JBPM本身提供的流转控制活动，不如自己实现一个自定义的活动使用。
Jpdl定义：

 

<!-- custom调用用户代码，实现一个自定义的活动行为 -->
 <custom name="print dots" class="org.jbpm.examples.custom.PrintDots""> 
<transition to="end" /> 
</custom>

 

 自定义活动的类需实现ExternalActivityBehaviour接口

public class PrintDots implements ExternalActivityBehaviour { 
// 在流程实例进入到此活动时执行此方法 
public void execute(ActivityExecution execution) { 
// 执行自定义的处理逻辑 
// 使流程陷入“等待”状态 
execution.waitForSignal();
 }
 // 在流程实例得到执行信号离开此活动时执行此方法
 public void signal(ActivityExecution execution, String signalName,   Map<String, ?> parameters)
 { // 使流程实例进入下一步 
execution.take(signalName);
 } 
}

 

 

8.自动活动
   自动活动是在执行过程中完全无须人工干预地编排好程序，jbpm在处理和执行这些自动活动时能把人工活动产生的数据
   通过流程变量等方式与之完美结合。
  1）java程序活动
  jpdl定义:

<!-- java 任务,流程处理的流向会执行 这个活动配置的方法
 class:完全类名 
method:调用的方法名 
var:返回值存储的 变量名 --> 
<java name="greet" class="org.jbpm.examples.java.JohnDoe" 
method="hello" var="answer" g="96,16,83,52"> 
<!--fileld:在方法调用之前给成员变量注入 配置值 --> 
<field name="state">
<string value="fine"/>
</field>
 <!--arg:方法参数 --> 
<arg><string value="Hi, how are you?"/></arg> 
<transition to="shake hand" /> 
</java>
 <!--expr:这个表达式返回方法被调用 产生的目标对象 ,通过对象参数传入(new Hand()-->
 <java name="shake hand" expr="#{hand}" 
method="shake" var="hand" g="215,17,99,52"> 
<!-- 通过表达式引用流程变量，为shake方法提供2个参数 --> 
<arg><object expr="#{joesmoe.handshakes.force}"/></arg> 
<arg><object expr="#{joesmoe.handshakes.duration}"/></arg> 
<transition to="wait" /> </java>

 

 JohnDoe事例代码如下：

public class JohnDoe implements Serializable {  
  String state;  
  public String hello(String msg) {
    if ( (msg.indexOf("how are you?")!=-1)
       ) {
      return "I'm "+state+", thank you.";
    }
    return null;
  }
}

 

 

 Hand事例代码如下：

public class Hand implements Serializable {
  private boolean isShaken;
  public Hand shake(Integer force, Integer duration) {
    if (force>3 && duration>7) {
      isShaken = true;
    }    
    return this;
  }
  public boolean isShaken() {
    return isShaken;
  }
}

 

 JoeSmoe事例代码如下：

public class JoeSmoe implements Serializable {
  public Map<String, Integer> getHandshakes() {
    Map<String, Integer> handshakes = new HashMap<String, Integer>();
    handshakes.put("force", 5);
    handshakes.put("duration", 12);
    return handshakes;
  }
}

  测试代码如下：

 

Map<String, Object> variables = new HashMap<String, Object>();
    variables.put("hand", new Hand());
    variables.put("joesmoe", new JoeSmoe());
    
    ProcessInstance processInstance = executionService.startProcessInstanceByKey("Java", variables);
    String pid = processInstance.getId();
    
    // 获取流程变量answer
    String answer = (String) executionService.getVariable(pid, "answer");
    assertEquals("I'm fine, thank you.", answer);
    // 获取流程变量hand
    Hand hand = (Hand) executionService.getVariable(pid, "hand");
assertTrue(hand.isShaken());