JBPM4.4 撤销任务/回退任务/自由流

JBPM4.4任务撤销操作/回退操作/自由流
详细操作看注释。
操作示意图

task.jpdl.xml

<?xml version="1.0" encoding="UTF-8"?>

 <process name="TaskAssignee" xmlns="http://jbpm.org/4.3/jpdl">

   <start g="20,20,48,48">
     <transition g="-23,-17" name="123" to="review"/>
   </start>

   <task assignee="#{order.owner}" g="96,16,127,52" name="review">
       <transition g="-59,-17" name="to state1" to="state1"/>
       <transition g="-53,-17" name="to task1" to="task1"/>
   </task>
   <state g="143,142,92,52" name="state1">
       <transition g="-47,-17" name="to end1" to="end1"/>
   </state>

    <task assignee="#{order.owner}" g="348,86,92,52" name="task1">
       <transition name="to end1" to="end1" g="-47,-17"/>
    </task>
     <end g="213,298,48,48" name="end1"/>
 </process>

<?xml version="1.0" encoding="UTF-8"?>

<process name="TaskAssignee" xmlns="http://jbpm.org/4.3/jpdl">

  <start g="20,20,48,48">
    <transition g="-23,-17" name="123" to="review"/>
  </start>

  <task assignee="#{order.owner}" g="96,16,127,52" name="review">
      <transition g="-59,-17" name="to state1" to="state1"/>
      <transition g="-53,-17" name="to task1" to="task1"/>
  </task>
  <state g="143,142,92,52" name="state1">
      <transition g="-47,-17" name="to end1" to="end1"/>
  </state>
  
   <task assignee="#{order.owner}" g="348,86,92,52" name="task1">
      <transition name="to end1" to="end1" g="-47,-17"/>
   </task>
	<end g="213,298,48,48" name="end1"/>
</process>

TestUndoTask.java

Java代码  

package TestPackage;

 import static org.junit.Assert.*;

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.annotation.Resource;

 import org.jbpm.api.Configuration;
 import org.jbpm.api.ExecutionService;
 import org.jbpm.api.HistoryService;
 import org.jbpm.api.ProcessDefinition;
 import org.jbpm.api.ProcessEngine;
 import org.jbpm.api.ProcessInstance;
 import org.jbpm.api.RepositoryService;
 import org.jbpm.api.TaskService;
 import org.jbpm.api.history.HistoryActivityInstance;
 import org.jbpm.api.task.Task;
 import org.jbpm.examples.task.assignee.Order;
 import org.jbpm.pvm.internal.env.EnvironmentFactory;
 import org.jbpm.pvm.internal.env.EnvironmentImpl;
 import org.jbpm.pvm.internal.model.ActivityImpl;
 import org.jbpm.pvm.internal.model.ExecutionImpl;
 import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
 import org.jbpm.pvm.internal.model.TransitionImpl;
 import org.jbpm.pvm.internal.task.TaskImpl;
 import org.junit.*;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

 import IdentitySessionImp.DhbsIdentitySessionImp;

 @ContextConfiguration("classpath:applicationContext.xml")
 public class TestUndoTask extends AbstractJUnit4SpringContextTests {
     private String deploymentId;
     private ProcessEngine processEngine;
     private TaskService taskService;
     private RepositoryService repositoryService;
     private ExecutionService executionService;
     private HistoryService historyService;

     public TestUndoTask() {
    }

     @BeforeClass
     public static void setUpClass() throws Exception {
    }

     @AfterClass
     public static void tearDownClass() throws Exception {
    }

     @Before
     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();
    }

     @After
     public void tearDown() {
        repositoryService.deleteDeploymentCascade(deploymentId);
    }

     /*@Resource
    private DhbsIdentitySessionImp identitySession;*/

     @Test
     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"));
         //启动1个实例
         ProcessInstance processInstance3 = executionService.startProcessInstanceByKey("TaskAssignee", variables);
        String p3id = processInstance3.getId();
         //johndoe的任务列表这时有了1条待办任务
         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"));
         taskService.completeTask(task1.getId(),"to task1",assignMap);
         //重新查询才能看到状态改变
        List<ProcessInstance> piList = executionService.createProcessInstanceQuery().list();
         for(ProcessInstance pi : piList){
            System.out.println(pi.findActiveActivityNames());
        }

         // 查看johndoe的待办任务列表是否空了
         List<Task> johndoetaskList_ = taskService.findPersonalTasks("johndoe");
         System.out.println("johndoetaskList0.size() = "+johndoetaskList_.size());
         assertEquals(0, johndoetaskList_.size());

         //打印在此节点流程的相关信息。这里可以看出getExecutionId()就是流程实例的id即processInstance.getId()
         List<HistoryActivityInstance> list = historyService.createHistoryActivityInstanceQuery().activityName("state1").list();
         for(HistoryActivityInstance activity : list){
             System.out.println("getActivityName() = "+activity.getActivityName());
             System.out.println("getExecutionId() = "+activity.getExecutionId());
        }

      // 查看撤销前johndoe的待办任务列表是否为零个
         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());
        }

         //查看撤销前we的待办任务列表是否为一个
         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)pd;
         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());
        }

         // 查看撤销后johndoe的待办任务列表是否为一个
         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);
        }

         //assertEquals(1, johndoetaskList1.size());
         //查看撤销后we的待办任务列表是否变为零个
         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);
        }
      }

     /**
       * 动态创建连接当前任务节点至名称为destName的节点的Transition
       * @param taskId 任务节点ID
       * @param sourceTask 源节点Task
       * @param destName  目标节点名称
       */
       public void addOutTransition(ProcessDefinitionImpl pd,TaskImpl sourceTask,String destName){
       EnvironmentFactory environmentFactory = (EnvironmentFactory) processEngine;
        EnvironmentImpl env=null;
        try {
           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());

           taskService.completeTask(sourceTask.getId(),transition.getName(),variables);
        }catch(Exception ex){
           ex.getMessage();
        }finally{
           env.close();
       }
    }
}

2 楼 tree_161219 2010-10-18  

哥们 我找到你这个例子的问题了。 不需要EnvironmentFactory 这个。去掉就可以了

1 楼 tree_161219 2010-10-18  

楼主，这个例子跑步通啊~~~运行后发现：1、 任务状态没有回到review，并且也不再we的代办列表中。 2、 在johndoe的任务列表中也没有这任务。
最近在学习JBPM。遇到这个问题，请指教！