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

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

http://paomo30000.iteye.com/blog/768033

转处:

博客分类： 
• JAVA

JBPM junit XML 活动

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>

TestUndoTask.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();
       }
    }
}