1538人阅读
jbpm（13）
指定方式：
1)，直接指定某人，在.jpdl.xml中写：assignee=&张三&
2)，使用流程变量，在.jpdl.xml中写：assignee=&#{manager}&
3)，使用类(这时，不需要将将该属性宣城none)，在.jpdl.xml中写：
&assignment-handler class=&com.njupt.task.AssignmentHandlerImpl&/&
4)，processEngine.getTaskService().assignTask(taskId, userId); //重新指定办理人
以下分点进行说明
1、 对于2)，其源代码如下：
package com.njupt.
import java.io.InputS
import java.util.HashM
import java.util.M
import org.jbpm.api.C
import org.jbpm.api.ProcessE
import org.jbpm.api.ProcessI
import org.jbpm.api.task.T
import org.junit.T
public class ProcessTest {
private ProcessEngine processEngine = Configuration.getProcessEngine();
public void test() throws Exception {
// 1，部署流程定义
InputStream in = getClass().getResourceAsStream(&test.jpdl.xml&);
processEngine.getRepositoryService()//
.createDeployment()//
.addResourceFromInputStream(&test.jpdl.xml&, in)//
.deploy();
// 2，启动流程实例
Map&String, Object& variables = new HashMap&String, Object&();
variables.put(&manager&, &李经理&);//这里就对应了我们指定的#{manager}
ProcessInstance pi = processEngine.getExecutionService().startProcessInstanceByKey(&test&, variables);
2、对于3),4）起源代码如下
& & &1&首先书写处理人的处理类
package com.njupt.
import org.jbpm.api.model.OpenE
import org.jbpm.api.task.A
import org.jbpm.api.task.AssignmentH
public class AssignmentHandlerImpl implements AssignmentHandler {
// 计算并指定任务的办理人
public void assign(Assignable assignable, OpenExecution execution) throws Exception {
System.out.println(&---& AssignmentHandlerImpl.assign()&);
// 计算办理人
String userId = &赵经理+++&;
// 指定办理人
assignable.setAssignee(userId); //
// assignable.addCandidateUser(&经理AA&);
// assignable.addCandidateUser(&经理BB&);
// assignable.addCandidateUser(&经理CC&);
& & 2&编写流程设计的测试类
package com.njupt.
import java.io.InputS
import org.jbpm.api.C
import org.jbpm.api.ProcessE
import org.jbpm.api.ProcessI
import org.junit.T
public class ProcessTest {
private ProcessEngine processEngine = Configuration.getProcessEngine();
public void test() throws Exception {
// 1，部署流程定义
InputStream in = getClass().getResourceAsStream(&test.jpdl.xml&);
processEngine.getRepositoryService()//
.createDeployment()//
.addResourceFromInputStream(&test.jpdl.xml&, in)//
.deploy();
// 2，启动流程实例
ProcessInstance pi = processEngine.getExecutionService().startProcessInstanceByKey(&test&);
// 重新分配任务（重新指定办理人）
public void testAssignTask() throws Exception {
String taskId = &270009&;
String userId = &赵经理++++++&;
processEngine.getTaskService().assignTask(taskId, userId);
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1957766次
积分：33173
积分：33173
排名：第148名
原创：1199篇
转载：278篇
评论：182条
难度：初级
类型：技术教程
难度：初级
类型：技术教程
难度：初级
类型：技术教程
毕业学校:南京邮电大学本科
成长的地方:创新工场、美团点评
职位:游戏研发工程师、Android研发工程师
《libGDX移动游戏开发从入门到精通》作者
努力奋斗、快乐生活
Android课程交流答疑QQ:
阅读：6030
阅读：17575
文章：16篇
阅读：27553
阅读：19666
文章：18篇
阅读：38812
文章：36篇
阅读：56802
文章：173篇
阅读：275311
文章：17篇
阅读：31298
文章：309篇
阅读：350179
(1)(5)(1)(13)(67)(48)(25)(7)(3)(7)(6)(10)(24)(27)(27)(18)(68)(18)(31)(117)(177)(125)(98)(179)(86)(73)(105)(82)(31)(1)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'博客分类：
博客分类：
JBPM4.4任务撤销操作/回退操作/自由流 详细操作看注释。 操作示意图
task.jpdl.xml
version="1.0" encoding="UTF-8"
name="TaskAssignee" xmlns="http://jbpm.org/4.3/jpdl"
g="20,20,48,48"
g="-23,-17" name="123" to="review"
assignee="#{order.owner}" g="96,16,127,52" name="review"
g="-59,-17" name="to state1" to="state1"
g="-53,-17" name="to task1" to="task1"
g="143,142,92,52" name="state1"
g="-47,-17" name="to end1" to="end1"
assignee="#{order.owner}" g="348,86,92,52" name="task1"
name="to end1" to="end1" g="-47,-17"
g="213,298,48,48" name="end1"
TestUndoTask.java
package TestP
import static org.junit.Assert.*;
import java.util.HashM
import java.util.I
import java.util.L
import java.util.M
import java.util.S
import javax.annotation.R
import org.jbpm.api.C
import org.jbpm.api.ExecutionS
import org.jbpm.api.HistoryS
import org.jbpm.api.ProcessD
import org.jbpm.api.ProcessE
import org.jbpm.api.ProcessI
import org.jbpm.api.RepositoryS
import org.jbpm.api.TaskS
import org.jbpm.api.history.HistoryActivityI
import org.jbpm.api.task.T
import org.jbpm.examples.task.assignee.O
import org.jbpm.pvm.internal.env.EnvironmentF
import org.jbpm.pvm.internal.env.EnvironmentI
import org.jbpm.pvm.internal.model.ActivityI
import org.jbpm.pvm.internal.model.ExecutionI
import org.jbpm.pvm.internal.model.ProcessDefinitionI
import org.jbpm.pvm.internal.model.TransitionI
import org.jbpm.pvm.internal.task.TaskI
import org.junit.*;
import org.springframework.test.context.ContextC
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextT
import IdentitySessionImp.DhbsIdentitySessionI
@ContextConfiguration("classpath:applicationContext.xml")
public class TestUndoTask extends AbstractJUnit4SpringContextTests {
private String deploymentId;
private ProcessEngine processE
private TaskService taskS
private RepositoryService repositoryS
private ExecutionService executionS
private HistoryService historyS
public TestUndoTask() {
@BeforeClass
public static void setUpClass() throws Exception {
@AfterClass
public static void tearDownClass() throws Exception {
public void setUp() {
processEngine = Configuration.getProcessEngine();
repositoryService = processEngine
.getRepositoryService();
executionService = processEngine.getExecutionService();
taskService = processEngine.getTaskService();
historyService = processEngine.getHistoryService();
deploymentId = repositoryService.createDeployment()
.addResourceFromClasspath("task.jpdl.xml")
.deploy();
public void tearDown() {
repositoryService.deleteDeploymentCascade(deploymentId);
public void testTaskAssignee() {
ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().uniqueResult();
System.out.println("显示流程定义
"+pd.getId()+"
"+pd.getKey()+"
"+pd.getName());
Map&String, Object& variables = new HashMap&String, Object&();
variables.put("order", new Order("johndoe"));
ProcessInstance processInstance3 = executionService.startProcessInstanceByKey("TaskAssignee", variables);
String p3id = processInstance3.getId();
List&Task& taskList = taskService.findPersonalTasks("johndoe");
assertEquals(1, taskList.size());
for(Task task : taskList){
System.out.println("task.getId() = "+task.getId());
System.out.println("task.getName() = "+task.getName());
Task task1 = taskList.get(0);
Set&String& outcomes = taskService.getOutcomes(task1.getId());
Iterator it = outcomes.iterator();
while(it.hasNext()){
String str = (String) it.next();
System.out.println("outcome = "+str);
assertEquals("review", task1.getName());
assertEquals("johndoe", task1.getAssignee());
Map&String, Object& assignMap = new HashMap&String, Object&();
assignMap.put("order", new Order("we"));
pleteTask(task1.getId(),"to task1",assignMap);
List&ProcessInstance& piList = executionService.createProcessInstanceQuery().list();
for(ProcessInstance pi : piList){
System.out.println(pi.findActiveActivityNames());
List&Task& johndoetaskList_ = taskService.findPersonalTasks("johndoe");
System.out.println("johndoetaskList0.size() = "+johndoetaskList_.size());
assertEquals(0, johndoetaskList_.size());
List&HistoryActivityInstance& list = historyService.createHistoryActivityInstanceQuery().activityName("state1").list();
for(HistoryActivityInstance activity : list){
System.out.println("getActivityName() = "+activity.getActivityName());
System.out.println("getExecutionId() = "+activity.getExecutionId());
List&Task& johndoetaskList0 = taskService.findPersonalTasks("johndoe");
System.out.println("查看撤销前johndoe的待办任务列表是否为零个");
System.out.println("johndoe_taskList1.size() = "+johndoetaskList0.size());
if(johndoetaskList0.size() & 0){
TaskImpl before_johndoetask = (TaskImpl)johndoetaskList0.get(0);
String before_johndoetask_actName = before_johndoetask.getActivityName();
String before_johndoetask_ExecutionId = before_johndoetask.getExecutionId();
System.out.println("before_johndoetask_actName = "+before_johndoetask_actName);
System.out.println("before_johndoetask_ExecutionId = "+before_johndoetask_ExecutionId);
assertEquals(0, johndoetaskList0.size());
List&Task& wetaskList1 = taskService.findPersonalTasks("we");
System.out.println("查看撤销前we的待办任务列表是否为一个");
System.out.println("we_taskList1.size() = "+wetaskList1.size());
if(wetaskList1.size() & 0){
TaskImpl before_wetask = (TaskImpl)wetaskList1.get(0);
String before_wetask_actName = before_wetask.getActivityName();
String before_wetask_ExecutionId = before_wetask.getId();
System.out.println("before_wetask_actName = "+before_wetask_actName);
System.out.println("before_wetask_ExecutionId = "+before_wetask_ExecutionId);
assertEquals(1, wetaskList1.size());
ProcessDefinitionImpl pdi = (ProcessDefinitionImpl)
TaskImpl wetask = (TaskImpl)wetaskList1.get(0);
addOutTransition(pdi,wetask,"review");
List&ProcessInstance& piList1 = executionService.createProcessInstanceQuery().list();
for(ProcessInstance pi : piList1){
System.out.println(pi.findActiveActivityNames());
List&Task& johndoetaskList1 = taskService.findPersonalTasks("johndoe");
System.out.println("查看撤销后johndoe的待办任务列表是否为一个");
System.out.println("johndoetaskList1.size() = "+johndoetaskList1.size());
if(johndoetaskList1.size() & 0){
TaskImpl johndoetask = (TaskImpl)johndoetaskList1.get(0);
String johndoetask_actName = johndoetask.getActivityName();
String johndoetask_ExecutionId = johndoetask.getExecutionId();
System.out.println("johndoetask_actName = "+johndoetask_actName);
System.out.println("johndoetask_ExecutionId = "+johndoetask_ExecutionId);
List&Task& wetaskList = taskService.findPersonalTasks("we");
System.out.println("查看撤销后we的待办任务列表是否为零个");
System.out.println("wetaskList.size() = "+wetaskList.size());
if(wetaskList.size() & 0){
TaskImpl taskwww = (TaskImpl)wetaskList.get(0);
String wetask_actName = taskwww.getActivityName();
String wetask_ExecutionId = taskwww.getExecutionId();
System.out.println("wetask_actName = "+wetask_actName);
System.out.println("wetask_ExecutionId = "+wetask_ExecutionId);
public void addOutTransition(ProcessDefinitionImpl pd,TaskImpl sourceTask,String destName){
EnvironmentFactory environmentFactory = (EnvironmentFactory) processE
EnvironmentImpl env=null;
env = environmentFactory.openEnvironment();
ActivityImpl sourceActivity = pd.findActivity(sourceTask.getActivityName());
ActivityImpl destActivity=pd.findActivity(destName);
TransitionImpl transition = sourceActivity.createOutgoingTransition();
transition.setName("to" + destName);
transition.setDestination(destActivity);
sourceActivity.addOutgoingTransition(transition);
System.out.println("sourceActivity.getName() = "+sourceActivity.getName());
System.out.println("destActivity.getName() = "+destActivity.getName());
Map&String, Object& variables = new HashMap&String, Object&();
variables.put("order", new Order("johndoe"));
System.out.println("task1.getId() = "+sourceTask.getId());
pleteTask(sourceTask.getId(),transition.getName(),variables);
}catch(Exception ex){
ex.getMessage();
env.close();
lvdong5830
浏览: 302493 次
来自: 无锡
切换成成功，谢谢大神！
好用 ，谢谢分享~
切换成功。膜拜大神推荐一篇类似的博客：http://43.24 ...
切换成功。膜拜大神
想问一下springdata jpa 与 mybaties之间 ...14:30 提问
JBPM中任务分配的问题
采购系统中，我想要在经理审批完成之后，由经理来将一个采购计划表里面
的需要采购的物料手动来选择分配给哪一个采购员去采购，jbpm4.4怎么实现
这样的任务分配
刚刚学习JBPM，大神们帮忙解答一下啊！！！
按赞数排序
把任务执行人设置为一个变量，经理审批时为这个变量赋值就好了
大神，有没有具体的代码实现啊，我刚刚学这个不久，谢谢啊！！
其他相关推荐JBPM4.4中怎么得到下个任务ID - ITeye问答
看以下代码：
Map m = new HashMap();
m.put("ywcssh", is.findGroupById("ywcssh").getId());
taskService.setVariables(taskID,m);
pleteTask(taskID);
问题是：当前任务的参与者完成了此任务后，将任务发送到下一个节点的参与者，在这里怎么得到下一个任务的ID？
目前还没有答案
已解决问题
未解决问题jbpm4&动态分配任务执行人
在jBPM中，分配任务可以有几种方式：
按照分配对象，可以分为：
分配给某个/些用户
或者分配给某个/些用户组。
从分配的方式看，可以有以下几种：
在流程设计的时候，就直接指定用户/用户组：
在流程设计的时候，可以通过assignee方式，直接分配给用户
明确的分配给某用户/用户组：
&task name="task1" assignee="username"
& 这样直接把工作分配给该用户，这里只能是用户
从环境变量来
&task name="task1" assignee="#{order.saler}"
& 这样直接把工作环境变量order对象的saler属性值所代表的用户
在流程设计的时候，分配给一群用户 candidate-users
&task name="task1"
candidate-users="usernameA,usernameB,usernameC"
在流程设计的时候，分配给一群用户组 candidate-groups
&task name="task1"
candidate-groups="groupA,groupB,groupC" &
在上述的2种方式：candidate-users、candidate-groups的方式，接收任务的人需要首先接收任务，才能进行处理，接收方式：taskService.takeTask
在程序执行的时候，动态确定：
这个在流程的xml中，也需要配置，到底哪个程序来确定。在Task节点中，需要配置任务分配器：
&assignment-handler
class="className"&
这个class是一个继承AssignmentHandler的类，只有一个方法：
void assign(Assignable assignable,
OpenExecution execution) throws E
Assignable是任务和泳道的通用接口。 所以任务分配处理器可以使用在任务， 也可以用在泳道中
assignable：可以完成上述的3种添加完成任务用户的方法：assignee、candidate-users、candidate-groups，
还有根据泳道（swimlane）进行分配用户
流程确定的情况下，有时候完成一个步骤人数不确定，在任务发布的时候有领导确定参与完成的人员。
为了完成这样的情况，可以到了这一步，通过配置动态的生成一些subTask，通过subTask给每个人进行分派工作。
其实还可以通过jBPM4.4中的foreach的方式进行完成（注意：这个功能还在孵化器中）。
如：完成一个审核工作，有些工作需要2个人完成，有些工作需要3个人完成，在开启流程的时候，由生成流程的人员进行指定对应的工作人员。
拿jBPM4.4开发指南中的例子来解释：
&process&name="ForEach"&xmlns="http://jbpm.org/4.4/jpdl"&&&
&&&&start&g="28,61,48,48"&name="start1"&&&
&&&&&&&transition&to="foreach1"/&&&
&&&&/start&&&
&&&&foreach&var="department"&in="#{departments}"&g="111,60,48,48"&name="foreach1"&&&
&&&&&&&transition&to="Collect&reports"/&&&
&&&&/foreach&&&
&&&&task&candidate-groups="#{department}"&g="201,58,92,52"&name="Collect&reports"&&&
&&&&&&&transition&to="join1"/&&&
&&&&/task&&&
&&&&join&g="343,59,48,48"&multiplicity="#{quorum}"&name="join1"&&&
&&&&&&&transition&to="end1"/&&&
&&&&/join&&&
&&&&end&g="433,60,48,48"&name="end1"/&&&
&/process&&&
&process name="ForEach" xmlns="http://jbpm.org/4.4/jpdl"&
&start g="28,61,48,48" name="start1"&
&transition to="foreach1"/&
&foreach var="department" in="#{departments}" g="111,60,48,48" name="foreach1"&
&transition to="Collect reports"/&
&/foreach&
&task candidate-groups="#{department}" g="201,58,92,52" name="Collect reports"&
&transition to="join1"/&
&join g="343,59,48,48" multiplicity="#{quorum}" name="join1"&
&transition to="end1"/&
&end g="433,60,48,48" name="end1"/&
&/process&
1. 启动流程后，到达foreach节点：
&foreach&var="department"&in="#{departments}"&g="111,60,48,48"&name="foreach1"&&&
&&&&transition&to="Collect&reports"/&&&
&/foreach&&&
&foreach var="department" in="#{departments}" g="111,60,48,48" name="foreach1"&
&transition to="Collect reports"/&
&/foreach&
in：表示从外面传入的参数，foreach会读取这个参数，这个参数可以是string数组，也可以是通过逗号分隔的字符串
var：这个变量是foreach将in中的内容按照规则进行拆分，拆分的结果放在var定义的变量中，传递给下一步（每一步接收一个值）
进入到foreach，解析完这些参数，会根据join中的multiplicity参数的值，生成task（multiplicity定义为几，就生成几个Executiuon，几个task），这些Task的assignee都是空的
2. 进入到task
&task&candidate-groups="#{department}"&g="201,58,92,52"&name="Collect&reports"&&&
&&&&transition&to="join1"/&&&
&task candidate-groups="#{department}" g="201,58,92,52" name="Collect reports"&
&transition to="join1"/&
进入到task，其实现在有多个task，是根据join中的multiplicity来确定的。
这些task任务安排的人员在candidate-groups（或者是candidate-users等）中定义。这个例子#{department}，就是在foreach节点中，定义的var="department"中的变量名字；
这些任务不是直接分派到用户的，而是需要用户自己进行take的
（通过TaskService.createTaskQuery().candidate(userId).list
可以获得有哪些任务自己是候选者
或者通过TaskService.findGroupTasks(userId)获取有哪些任务是自己加入的组需要完成的，
& 或者在流程xml文件中，直接用assignee，分配给任务完成的人员
3. foreach自动生成的这些Task都完成了，则流程进入到下一步；
如果有部分人员完成，部分人员没有完成，还是可以查到foreach自动生成的所有Execution（通过processInstance.getExecutions()），不过根据任务完成的情况有不同的状态：
如果任务已经完成，则在Task表中已经删除，得到的execution状态是：inactive-join
没有完成的任务，在task中依旧存在，得到的execution状态是 active-concurrent
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。