activiti入门

  1. activiti官网
  2. pom.xml文件
    xml <!-- activiti --> <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-engine</artifactId> <version>5.18.0</version> </dependency> <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-spring</artifactId> <version>5.18.0</version> </dependency> <!-- activiti结束 -->
  3. 安装activiti插件
    CSDN教程
  4. 创建bpm图

    1.开始点
    2.结束点
    3.任务
    4.执行人
    5.流程id,流程名

  5. 部署流程
    ```java
    public class Test {
    // getDefaultProcessEngine会读取activiti.cfg.xml
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    1.  /**
    2.   * 部署流程
    3.   */
    4.  @org.junit.Test
    5.  public void deploy() {
    6.      //读取资源文件部署
    7.      Deployment deploy = processEngine.getRepositoryService().createDeployment()
    8.              .addClasspathResource("bpmn/helloWorld.bpmn").addClasspathResource("bpmn/helloWorld.png").deploy();
    9.      // act_re_deployment部署对象表
    10.      // act_re_procdef 流程定义表
    11.      // act_ge_bytearray 资源文件表
    12.      System.out.println(deploy.getId());
    13.      System.out.println(deploy.getName());
    14.  }

    }
    ```

  6. 启动流程
    ```java
    /**

    • 启动流程实例
      */
      @org.junit.Test
      public void run() {
      // key值对应bpmn中流程的id 默认按最新版本启动
      ProcessInstance pi = processEngine.getRuntimeService().startProcessInstanceByKey("helloWorld");
      // 流程实例id
      System.out.println(pi.getId());
      // 流程定义id
      System.out.println(pi.getProcessDefinitionId());

    }
    ```

  7. 查询任务
    ```java
    /**

    • 查询任务
      */
      @org.junit.Test
      public void task() {
      // 通过执行人进行查询
      List list = processEngine.getTaskService().createTaskQuery().taskAssignee("李四").list();
      for (Task task : list) {
      // 任务id
      System.out.println(task.getId());
      // 任务名
      System.out.println(task.getName());
      // 任务创建时间
      System.out.println(task.getCreateTime());
      // 流程实例id
      System.out.println(task.getProcessInstanceId());
      // 流程定义id
      System.out.println(task.getProcessDefinitionId());

      }

    }
    ```

  8. 完成任务
    java /** * 完成任务 */ @org.junit.Test public void complete() { // 查询李四的所有任务 List<Task> list = processEngine.getTaskService().createTaskQuery().taskAssignee("李四").list(); for (Task task : list) { System.out.println(task.getId()); // 通过任务id进行完成 processEngine.getTaskService().complete(task.getId()); } }
  9. 查询所有部署
    java /** * 查询所有部署 */ @org.junit.Test public void findDeploy() { List<Deployment> deploymentList = processEngine.getRepositoryService().createDeploymentQuery().list(); for (Deployment deployment : deploymentList) { System.out.println(deployment.getId()); System.out.println(deployment.getName()); } }

  10. 删除流程定义

    1.  /**
    2.    * 删除部署
    3.    */
    5.   @org.junit.Test
    6.   public void deleteDeploy() {
    7.     String deployString = "20001";
    8.     // 部署表,流程定义表,资源表内容删除
    9.     // 普通删除:如果本流程定义正在运行会抛出异常
    10.     // 多级删除: 删除与本流程定义所关联的所有信息
    11.     processEngine.getRepositoryService().deleteDeployment(deployString);
    12.     System.out.println("删除部署成功");
    14.   }

  11. 获得部署资源文件

    1.   /**
    2.    * 获得部署的资源文件
    3.    *
    4.    * @throws IOException
    5.    */
    6.   @org.junit.Test
    7.   public void getResources() throws IOException {
    8.     // 部署对象id
    9.     String id = "7501";
    10.     // 查询出当前部署的所有资源文件png+bpm
    11.     List<String> deploymentResourceNames =
    12.         processEngine.getRepositoryService().getDeploymentResourceNames(id);
    13.     String png = null;
    14.     for (String name : deploymentResourceNames) {
    15.       // 获得png文件名
    16.       if (name.indexOf(".png") >= 0) {
    17.         png = name;
    18.       }
    19.     }
    20.     System.out.println(png);
    21.     // 获得当前文件流
    22.     InputStream resourceAsStream =
    23.         processEngine.getRepositoryService().getResourceAsStream(id, png);
    24.     File file = new File("d:/" + png);
    25.     FileUtils.copyToFile(resourceAsStream, file);
    27.   }

  12. 获得最新版本的流程定义

    1.   /**
    2.    * 查询最新坂本流程定义
    3.    */
    4.   @org.junit.Test
    5.   public void queryLatestVersion() {
    6.     // 查询流程定义按版本排序
    7.     List<ProcessDefinition> list = processEngine.getRepositoryService()
    8.         .createProcessDefinitionQuery().orderByProcessDefinitionVersion().asc().list();
    9.     // 创建一个map用于存放最新版本的流程定义
    10.     Map<String, ProcessDefinition> map = new HashMap<String, ProcessDefinition>();
    11.     // 遍历流程定义集合
    12.     for (ProcessDefinition processDefinition : list) {
    13.       map.put(processDefinition.getKey(), processDefinition);
    14.     }
    15.     // 遍历最新版本流程定义获得信息
    16.     for (ProcessDefinition processDefinition : map.values()) {
    17.       System.out.println("id:" + processDefinition.getId());
    18.       System.out.println("name:" + processDefinition.getName());
    19.       System.out.println("key:" + processDefinition.getKey());
    20.       System.out.println("version:" + processDefinition.getVersion());
    21.     }
    22.   }

  13. 查询流程状态

    1.   /**
    2.    * 查询流程状态
    3.    */
    4.   @org.junit.Test
    5.   public void processState() {
    6.     // 流程实例
    7.     String pid = "47501";
    8.     // 通过流程实例id进行查询返回唯一结果
    9.     ProcessInstance singleResult = processEngine.getRuntimeService().createProcessInstanceQuery()
    10.         .processInstanceId(pid).singleResult();
    11.     // 判断结果不为空
    12.     if (singleResult != null) {
    13.       System.out.println("未完成");
    14.       System.out.println(singleResult.getActivityId());
    15.     } else {
    16.       System.out.println("流程结束");
    17.     }
    18.   }

  14. 查询历史任务

    1.   /**
    2.    * 查询历史任务
    3.    */
    4.   @org.junit.Test
    5.   public void getHistoryTasks() {
    6.     // 历史任务办理人
    7.     String assignee = "张三";
    8.     // 通过历史任务办理人进行查询
    9.     List<HistoricTaskInstance> list = processEngine.getHistoryService()
    10.         .createHistoricTaskInstanceQuery().taskAssignee(assignee).list();
    11.     // 遍历历史任务
    12.     for (HistoricTaskInstance historicTaskInstance : list) {
    13.       // 任务id
    14.       System.out.println(historicTaskInstance.getId());
    15.       // 任务办理人
    16.       System.out.println(historicTaskInstance.getAssignee());
    17.       // 任务名
    18.       System.out.println(historicTaskInstance.getName());
    19.       // 任务流程实例
    20.       System.out.println(historicTaskInstance.getProcessInstanceId());
    21.     }
    22.   }

  15. 查询历史流程定义

    1.   /**
    2.    * 查询历史流程实例
    3.    */
    4.   @org.junit.Test
    5.   public void historyProcessInstance() {
    6.     // 通过流程定义key进行查询
    7.     List<HistoricProcessInstance> list = processEngine.getHistoryService()
    8.         .createHistoricProcessInstanceQuery().processDefinitionKey("helloWorld").list();
    9.     // 遍历结果集
    10.     for (HistoricProcessInstance historicProcessInstance : list) {
    11.       System.out.println(historicProcessInstance.getId());
    12.       // 启动时间
    13.       System.out.println(historicProcessInstance.getStartTime());
    14.       // 结束时间
    15.       System.out.println(historicProcessInstance.getEndTime());
    16.       // 持续时间
    17.   System.out.println(historicProcessInstance.getDurationInMillis());
    18.       System.out.println(historicProcessInstance.getName());
    19.       System.out.println(historicProcessInstance.getProcessDefinitionKey());
    20.     }
    22.   }

  16. 设置与获取流程变量

    1.   /**
    2.    * 设置获取流程变量
    3.    */
    4.   @org.junit.Test
    5.   public void setGetVariables() {
    6.     String pi = "47501";
    7.     String person = "李四";
    8.     TaskService taskService = processEngine.getTaskService();
    9.     Task task =
    10.         taskService.createTaskQuery().processInstanceId(pi).taskAssignee(person).singleResult();
    11.     String taskId = task.getId();
    12.     // 设置流程变量
    13.     taskService.setVariable(taskId, "审核意见", "同意");
    14.     taskService.setVariable(taskId, "备注", "路上注意安全");
    15.       /**
    16.         * setVariable和setVariableLocal的区别
    17.         * setVariable:流程变量名称相同的时候，后一次的值替换前一次的值,而且可以看到TASK_ID的字段不会存放任务ID的值
    18.         * setVariableLocal:一个流程中存在2个活动节点,流程变量的名称相同，后一次的版本的值也不会替换前一次版本的值
    19.         * 使用setVariableLocal说明流程变量绑定了当前的任务，当流程继续执行时，下个任务获取不到这个流程变量
    20.         */
    21.     // 变量存在javaBean前提要让javaBean实现序列化
    22.     LeaveInfo leaveInfo = new LeaveInfo();
    23.     leaveInfo.setId("1");
    24.     leaveInfo.setLeaveMsg("test");
    25.     taskService.setVariable(taskId, "javaBean", leaveInfo);
    26.     // 获取流程变量
    27.     String shyj = (String) taskService.getVariable(taskId, "审核意见");
    28.     String bz = (String) taskService.getVariable(taskId, "备注");
    29.     System.out.println(shyj);
    30.     System.out.println(bz);
    31.     // 同时要求流程变量对象的属性不能发生发生变化，否则抛出异常
    32.     LeaveInfo javaBean = (LeaveInfo) taskService.getVariable(taskId, "javaBean");
    33.     System.out.println(javaBean.getId());
    34.     System.out.println(javaBean.getLeaveMsg());
    35.   }

    1. RuntimeService对象可以设置流程变量和获取流程变量
    2. TaskService对象可以设置流程变量和获取流程变量
    3. 流程实例启动的时候可以设置流程变量
    4. 任务办理完成的时候可以设置流程变量
    5. 流程变量可以通过名称/值的形式设置单个流程变量
    6. 流程变量可以通过名称/值的形式设置单个流程变量
      • Map集合的key表示流程变量的名称
      • Map集合的value表示流程变量的值

  17. 查询历史流程变量

    1.   /**
    2.    * 查询历史流程变量
    3.    */
    4.   @org.junit.Test
    5.   public void historyVariable() {
    6.     HistoricVariableInstance variable =
    7.         processEngine.getHistoryService().createHistoricVariableInstanceQuery().variableName("审核意见")
    8.             .processInstanceId("47501").singleResult();
    9.     // 流程变量名
    10.     System.out.println(variable.getVariableName());
    11.     // 流程变量的值
    12.     System.out.println(variable.getValue());
    13.   }

    17.根据流程变量走不同的流程

    1. 流程图

    2. 代码:
      ```java
      package com.cjrj.bootactividemo;

      import java.util.HashMap;
      import java.util.Map;
      import org.activiti.engine.ProcessEngine;
      import org.activiti.engine.ProcessEngines;
      import org.activiti.engine.repository.Deployment;
      import org.activiti.engine.runtime.ProcessInstance;
      import org.activiti.engine.task.Task;
      import org.junit.Test;

      /**

      • 审核附加流程变量
      • @author Jamin

      • */
        public class Test2 {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

        @Test
        public void test() {
        // 部署
        Deployment deploy = processEngine.getRepositoryService().createDeployment()
        .addClasspathResource("bpm/test.bpmn").addClasspathResource("bpm/test.png").name("test")
        .deploy();
        // 启动
        ProcessInstance pi = processEngine.getRuntimeService().startProcessInstanceByKey("myProcess");
        Task task = processEngine.getTaskService().createTaskQuery().taskAssignee("张三")
        .processInstanceId(pi.getId()).singleResult();
        // 审批附加流程变量
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("message", "重要");
        processEngine.getTaskService().complete(task.getId(), map);
        // 查询李四的任务
        Task task1 = processEngine.getTaskService().createTaskQuery().taskAssignee("李四")
        .processInstanceId(pi.getId()).singleResult();
        // 如果message是重要task1不为空,如果message是不重要的task为空
        if (task1 != null) {
        System.out.println(task1.getName());
        } else {
        System.out.println("结束");
        }
        }
        }
        ```

  18. 排他网关

    • 代码:
      ```java
      package com.cjrj.bootactividemo;
      import java.util.HashMap;
      import java.util.Map;
      import org.activiti.engine.ProcessEngine;
      import org.activiti.engine.ProcessEngines;
      import org.activiti.engine.repository.Deployment;
      import org.activiti.engine.runtime.ProcessInstance;
      import org.activiti.engine.task.Task;

      /**

      • 排他网关
      • @author Jamin
      • */
        public class Test3 {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      1. @org.junit.Test
      2. public void test() {
      3.   // 部署
      4.   Deployment deployment = processEngine.getRepositoryService().createDeployment()
      5.       .addClasspathResource("reimburse/MyProcess.bpmn")
      6.       .addClasspathResource("reimburse/MyProcess.png").deploy();
      7.   // 启动
      8.   ProcessInstance processInstance =
      9.       processEngine.getRuntimeService().startProcessInstanceByKey("reimburse");
      10.   // 查询任务
      11.   Task task = processEngine.getTaskService().createTaskQuery().taskAssignee("张三")
      12.       .processInstanceId(processInstance.getId()).singleResult();
      13.   System.out.println("------------------------------------------------");
      14.   System.out.println(task.getId());
      15.   System.out.println("-------------------------------------------------");
      16.   // 完成任务,附带流程定义
      17.   Map<String, Object> map = new HashMap<String, Object>();
      18.   map.put("money", 10000);
      19.   processEngine.getTaskService().complete(task.getId(), map);
      20.   // 李四的任务
      21.   Task lisi = processEngine.getTaskService().createTaskQuery().taskAssignee("李四")
      22.       .processInstanceId(processInstance.getId()).singleResult();
      23.   Task wangwu = processEngine.getTaskService().createTaskQuery().taskAssignee("王五")
      24.       .processInstanceId(processInstance.getId()).singleResult();
      25.   Task zhaoliu = processEngine.getTaskService().createTaskQuery().taskAssignee("赵六")
      26.       .processInstanceId(processInstance.getId()).singleResult();
      27.   if (lisi == null) {
      28.     System.out.println("李四没有任务");
      29.   }
      30.   if (wangwu == null) {
      31.     System.out.println("王五没有任务");
      32.   }
      33.   if (zhaoliu == null) {
      34.     System.out.println("赵六没有任务");
      35.   }
      36. }

      }
      ```

  19. 接收任务

    • 代码:
      ```java
      package com.cjrj.bootactividemo;

      import org.activiti.engine.ProcessEngine;
      import org.activiti.engine.ProcessEngines;
      import org.activiti.engine.repository.Deployment;
      import org.activiti.engine.runtime.Execution;
      import org.activiti.engine.runtime.ProcessInstance;

      /**

      • 接受任务(启动流程实例 执行查询执行对象 查询不到第一个)
      • @author Jamin
      • @date 2019年7月16日 下午8:08:15
      • */
        public class Task5 {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      1. @org.junit.Test
      2. public void test() {
      3.   // 部署
      4.   Deployment deploy = processEngine.getRepositoryService().createDeployment()
      5.       .addClasspathResource("message/message.bpmn").addClasspathResource("message/message.png")
      6.       .deploy();
      7.   // 启动
      8.   ProcessInstance processInstance =
      9.       processEngine.getRuntimeService().startProcessInstanceByKey("message");
      10.   System.out.println(processInstance.getId());
      11.   // 查询执行对象
      12.   Execution execution = processEngine.getRuntimeService().createExecutionQuery()
      13.       .processInstanceId(processInstance.getId()).activityId("receivetask1").singleResult();
      14.   System.out.println("当前执行对象");
      15.   System.out.println(execution.getActivityId());
      16.   System.out.println("end当前执行对象");
      17.   processEngine.getRuntimeService().signal(execution.getId());
      18.   ProcessInstance pi = processEngine.getRuntimeService().createProcessInstanceQuery()
      19.       .processInstanceId(processInstance.getId()).singleResult();
      20.   System.out.println("查询实例是否结束");
      21.   System.out.println(pi);
      22.   // 查询执行对象
      23.   Execution execution2 = processEngine.getRuntimeService().createExecutionQuery()
      24.       .processInstanceId(processInstance.getId()).activityId("receivetask2").singleResult();
      25.   System.out.println("当前执行对象");
      26.   System.out.println(execution2.getActivityId());
      27.   System.out.println("end当前执行对象");
      28.   processEngine.getRuntimeService().signal(execution2.getId());
      29.   ProcessInstance pi2 = processEngine.getRuntimeService().createProcessInstanceQuery()
      30.       .processInstanceId(processInstance.getId()).singleResult();
      31.   System.out.println("查询实例是否结束");
      32.   System.out.println(pi2);
      33. }

      }
      ```
      20.个人任务
      1.直接指定办理人
      2.通过流程变量指定办理人

      • bpmn图

      • 代码
        java /** * 通过流程变量指定办理人 * * @author Jamin * @date 2019年7月17日下午4:18:30 * @return void */ @org.junit.Test public void test() { // 部署 Deployment deploy = repositoryService.createDeployment() .addClasspathResource("personVariables/personVariables.bpmn") .addClasspathResource("personVariables/personVariables.png").deploy(); // 启动并设定流程变量,指定组办理人 HashMap<String, Object> map = new HashMap<String, Object>(); map.put("userId", "张三"); ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("personVariables", map); System.out.println("流程实例:" + processInstance.getId()); // 查询个人任务 List<Task> list = taskService.createTaskQuery().taskAssignee("张三").list(); for (Task task : list) { System.out.println(task.getId()); System.out.println(task.getName()); System.out.println(task.getExecutionId()); System.out.println(task.getAssignee()); } }

      1. 通过类指定办理人

        1. 创建一个实现了TaskListener的类
          ```java
          package com.cjrj.bootactividemo;

          1.  import org.activiti.engine.delegate.DelegateTask;

          import org.activiti.engine.delegate.TaskListener;

          1.  /**
          2.   * 实现TaskListener接口完成指定办理人
          3.   *
          4.   * @author Jamin
          5.   * @date 2019年7月17日 下午4:23:30
          6.   *
          7.   */

          public class TaskListenerImpl implements TaskListener {

          1.    @Override
          2.    public void notify(DelegateTask delegateTask) {
          3.      // 指定办理人
          4.      String person = "张三";
          5.      // 设置办理人
          6.      delegateTask.setAssignee(person);

          }

          1.  }

          ```

        2. bpmn图绑定监听

        3. 测试代码
          ```java
          /**
          * 通过类指定办理人
          *
          * @author Jamin
          * @date 2019年7月17日下午4:20:31
          * @return void
          */
          @org.junit.Test
          public void test2() {
          TaskListenerImpl taskListenerImpl = new TaskListenerImpl();
          // 部署
          Deployment deploy = repositoryService.createDeployment()
          .addClasspathResource("personVariables/personClass.bpmn")
          .addClasspathResource("personVariables/personClass.png").deploy();
          // 启动并设定流程变量,指定组办理人
          HashMap<String, Object> map = new HashMap<String, Object>();
          map.put("userId", "张三");
          ProcessInstance processInstance =
          runtimeService.startProcessInstanceByKey("personVariables", map);
          System.out.println("流程实例:" + processInstance.getId());
          // 查询个人任务
          Task task = taskService.createTaskQuery().taskAssignee("张三")
          .processInstanceId(processInstance.getId()).singleResult();
          System.out.println("张三任务:" + task.getName());
          // 转交任务
          taskService.setAssignee(task.getId(), "李四");
          Task task1 = taskService.createTaskQuery().taskAssignee("李四")
          .processInstanceId(processInstance.getId()).singleResult();
          System.out.println("李四的任务:" + task1.getName());

          }
          ```

  20. 组任务

    1. 直接指定

    2. 使用流程变量

    3. 使用类

    • 代码
      ```java
      package com.cjrj.bootactividemo;

      1. import java.util.List;
      2. import org.activiti.engine.ProcessEngine;
      3. import org.activiti.engine.ProcessEngines;
      4. import org.activiti.engine.RepositoryService;
      5. import org.activiti.engine.RuntimeService;
      6. import org.activiti.engine.TaskService;
      7. import org.activiti.engine.history.HistoricIdentityLink;
      8. import org.activiti.engine.repository.Deployment;
      9. import org.activiti.engine.runtime.ProcessInstance;
      10. import org.activiti.engine.task.IdentityLink;
      11. import org.activiti.engine.task.Task;
      13. /**
      14.  * 组任务
      15.  *
      16.  * @author Jamin
      17.  * @date 2019年7月17日 下午5:12:21
      18.  *
      19.  */
      20. public class Test7 {
      21.   ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
      22.   RepositoryService repositoryService = processEngine.getRepositoryService();
      23.   RuntimeService runtimeService = processEngine.getRuntimeService();
      24.   TaskService taskService = processEngine.getTaskService();
      26.   /**
      27.    * 直接指定
      28.    *
      29.    * @author Jamin
      30.    * @date 2019年7月17日下午5:13:02
      31.    * @return void
      32.    */
      33.   @org.junit.Test
      34.   public void test() {
      35.     // 第一种
      36.     /*
      37.      * // 部署 repositoryService.createDeployment().addClasspathResource("group/first.bpmn")
      38.      * .addClasspathResource("group/first.png").deploy(); // 启动 ProcessInstance processInstance =
      39.      * runtimeService.startProcessInstanceByKey("first"); System.out.println("流程实例id:" +
      40.      * processInstance.getId());
      41.      */
      42.     // 第二种
      44.     /*
      45.      * Deployment deploy =
      46.      * repositoryService.createDeployment().addClasspathResource("group/second.bpmn")
      47.      * .addClasspathResource("group/second.png").deploy(); HashMap<String, Object> map = new
      48.      * HashMap<String, Object>(); map.put("userId", "张三,李四,王五"); ProcessInstance processInstance =
      49.      * runtimeService.startProcessInstanceByKey("second", map);
      50.      */
      51.     // 第三种
      52.     Deployment deploy = repositoryService.createDeployment()
      53.         .addClasspathResource("group/third.bpmn").addClasspathResource("group/third.png").deploy();
      54.     ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("third");
      55.     System.out.println("流程实例id" + processInstance.getId());
      56.     // 查询组任务
      57.     List<Task> list = taskService.createTaskQuery().processInstanceId(processInstance.getId())
      58.         .taskCandidateUser("张三").list();
      59.     System.out.println("组任务:" + list);
      60.     String taskId = null;
      61.     for (Task task : list) {
      62.       System.out.println(task.getName());
      63.       System.out.println(task.getAssignee());
      64.       System.out.println(task.getId());
      65.       taskId = task.getId();
      66.     }
      67.     // 查询组成员
      68.     List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(taskId);
      69.     for (IdentityLink identityLink : identityLinksForTask) {
      70.       System.out.println(identityLink.getGroupId());
      71.       System.out.println(identityLink.getUserId());
      72.     } // 查询历史组成员列表
      73.     List<HistoricIdentityLink> historicIdentityLinksForTask =
      74.         processEngine.getHistoryService().getHistoricIdentityLinksForTask(taskId);
      75.     for (HistoricIdentityLink historicIdentityLink : historicIdentityLinksForTask) {
      76.       System.out.println(historicIdentityLink.getUserId());
      77.       System.out.println(historicIdentityLink.getGroupId());
      78.     }
      79.     // 组任务转个人可以是任何人
      80.     taskService.claim(taskId, "张11");
      81.     Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
      82.         .taskAssignee("张11").singleResult();
      83.     System.out.println("组任务转个人任务名:" + task.getName());
      84.     // 个人任务转组(必须任务以前是组任务)
      85.     taskService.setAssignee(task.getId(), null);
      86.     // 检测是否转组任务成功,
      87.     List<Task> list1 = taskService.createTaskQuery().processInstanceId(processInstance.getId())
      88.         .taskCandidateUser("张三").list();
      89.     String taskId1 = null;
      90.     for (Task task1 : list) {
      92.       System.out.println("转组任务:" + task1.getName());
      93.       System.out.println("转组任务:" + task1.getAssignee());
      94.       System.out.println("转组任务:" + task1.getId());
      95.       taskId1 = task.getId();
      96.     }
      97.     // 添加人员
      98.     taskService.addCandidateUser(taskId1, "qiqi");
      99.     // 查询参与人员
      100.     List<IdentityLink> identityLinksForTask2 = taskService.getIdentityLinksForTask(taskId1);
      101.     for (IdentityLink identityLink : identityLinksForTask2) {
      102.       System.out.println("添加人员后" + identityLink.getUserId());
      103.     }
      105.     // 删除人员张三
      106.     taskService.deleteCandidateUser(taskId1, "张三");
      107.     List<IdentityLink> identityLinksForTask3 = taskService.getIdentityLinksForTask(taskId1);
      108.     for (IdentityLink identityLink : identityLinksForTask3) {
      109.       System.out.println("删除人员后:" + identityLink.getUserId());
      110.     }
      111.     // 完成任务
      112.     taskService.complete(taskId);
      114.   }
      115. }

      ```

  21. 分配任务给一个角色
    • bpmn图

    • 代码:
      ```java
      /**
      * 分配任务负责的组

      * 可以分配给多个角色

      * 三种方式都可
      *
      * @author Jamin
      * @date 2019年7月18日上午8:28:12
      * @return void
      /
      @org.junit.Test
      public void four() {
      // 部署
      Deployment deploy = repositoryService.createDeployment().addClasspathResource("group/four.bpmn")
      .addClasspathResource("group/four.png").deploy();
      IdentityService identityService = processEngine.getIdentityService();
      // 创建组与用户并关联
      /
      * identityService.saveGroup(new GroupEntity("部门经理")); identityService.saveGroup(new
      * GroupEntity("总经理")); identityService.saveUser(new UserEntity("张三"));
      * identityService.saveUser(new UserEntity("李四")); identityService.createMembership("张三",
      * "部门经理"); identityService.createMembership("李四", "总经理");
      /
      // 使用流程变量设置角色
      /
      * HashMap<String, Object> map = new HashMap<String, Object>(); map.put("group", "部门经理,总经理");
      */

      1.   // 启动
      2.   ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("four");
      3.   // 查询个人任务
      4.   Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
      5.       .taskCandidateUser("李四").singleResult();
      6.   System.out.println(task.getName());
      7. }
      8. // 查询执行任务的组
      9.   List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(task.getId());
      10.   for (IdentityLink identityLink : identityLinksForTask) {

      System.out.println(identityLink.getGroupId());
      ```

  • 总结:

    • 流程步骤

      1. bpmn
      2. 使用bpmn图或zip部署
      3. 启动流程
      4. 查询个人任务或组任务
    • 实现办理人的三种方式:
      1. 直接指定
      2. 使用流程变量,启动时指定
      3. 使用监听器
    • 21点与22点: 21点是指定多人,可以是任意一个人,以人为单位,22点必须创建角色,执行人是角色中的任意一个,以角色为单位,都可以进行任务转让,添加删除

activiti学习笔记的更多相关文章

  1. Activiti 学习笔记记录（2016-8-31）

    上一篇:Activiti 学习笔记记录(二) 导读:上一篇学习了bpmn 画图的常用图形标记.那如何用它们组成一个可用文件呢? 我们知道 bpmn 其实是一个xml 文件

  2. Activiti 学习笔记记录（二）

    上一篇:Activiti 学习笔记记录 导读:对于工作流引擎的使用,我们都知道,需要一个业务事件,比如请假,它会去走一个流程(提交申请->领导审批---(批,不批)---->结束),Act ...

  3. Activiti学习笔记目录

    1.Activiti学习笔记1 — 下载与开发环境的配置: 2.Activiti学习笔记2 — HelloWorld: 3.Activiti学习笔记3 — 流程定义: 4.Activiti学习笔记4 ...

  4. activiti学习笔记一

    activiti学习笔记 在讲activiti之前我们必须先了解一下什么是工作流,什么是工作流引擎. 在我们的日常工作中,我们会碰到很多流程化的东西,什么是流程化呢,其实通俗来讲就是有一系列固定的步骤 ...

  5. Activiti 学习笔记（2016-8-30）

    前言 不管学习什么,都必须对知识体系中专有的名词或者特定的语言组织方式 有所了解. 本文仅记录学习过程中的笔记,参考意义因人而定,不保证所言全部正确. 学习方式,百度传课的视频<权威Activi ...

  6. Activiti 学习笔记记录

    官方在线用户手册(英文版):http://activiti.org/userguide/index.html 中文用户手册:http://www.mossle.com/docs/activiti/in ...

  7. Activiti学习笔记1 — 下载与开发环境的配置

    一.下载 JDK下载URL: Tomcat下载URL:http://tomcat.apache.org/ Eclipse下载URL:http://www.oracle.com/technetwork/ ...

  8. Activiti学习笔记11 — 判断节点的使用

    一. 创建流程 <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns=" ...

  9. Activiti学习笔记10 — 动态任务分配

    动态任务分配使用的两种方式 一.通过特殊表达式,来获取任务信息 ,在流程 UserTask节点上设置 ${流程变量的Key} 1.流程定义 <?xml version="1.0&quo ...

随机推荐

  1. Objective

    1.NSSet 1.是一个无序的,管理多个对象的集合类,最大特点 是集合中不允许出现重复对象,和数学上的集合含义是一 样的 2.除了无序.不许重复之外,其它功能和NSArray是一样的 2.NSArr ...

  2. vista忘记用户名密码的修改方法（使用PE进入系统，用cmd.exe冒充虚拟键盘，然后就可以mmc组策略，或者命令行添加用户并提升权限）

    1. 准备Windows Vista安装光盘,进入BIOS将光驱设为第一启动,在出现的安装界面依次单击"修复计算机","命令提示符". 2.输入以下命令: co ...

  3. Change Default Route

    route delete 0.0.0.0route add 0.0.0.0 mask 0.0.0.0 10.226.4.14

  4. hadoop之文件管理基本操作

    # 格式化hdfs hadoop namenode -format # 查看hadoop下的文件夹 hadoop fs -ls # 创建hdfs文件夹 hadoop fs -mkdir /user/i ...

  5. kolla-ansible-----快速部署openstack

    基本环境 操作系统:CentOS Linux release 7.5.1804 (Core) 内核版本:3.10.0-862.el7.x86_64 docker版本:1.13.1 1.禁用宿主机的 L ...

  6. Hyperledger Fabric1.4环境搭建过程

    简单记录一下fabric版本1.4的环境搭建,运行环境为Ubuntu18.04,其中一些内容是根据官方文档整理的,如有错误欢迎批评指正. 本文只介绍最简单的环境搭建方法,具体的环境搭建解析在这里深入解 ...

  7. sails连接monogodb数据库

    1.全局安装:cnpm install -g sails 2.命令窗口进入项目位置 新建项目:sails new sails_cqwu --fast,选择2(快速建立sails项目) 3.cd进入sa ...

  8. U盘刻录kali linux启动盘提示找不到镜像解决方案

    选择“继续”后会来到步骤菜单,选择从shell启动,命令 df -m 查看当前磁盘挂载情况,看到  /media 目录 输入命令 umount /media 进行挂载然后输入 exit 退出

  9. 推荐一个高效，易用功能强大的可视化API管理平台

    项目管理 提供基本的项目分组,项目管理,接口管理功能 接口管理 友好的接口文档,基于websocket的多人协作接口编辑功能和类postman测试工具,让多人协作成倍提升开发效率 MockServer ...

  10. 【设计模式】行为型07备忘录模式（Memento Pattern）

    参考地址:http://www.runoob.com/design-pattern/memento-pattern.html 对原文总结调整,以及修改代码以更清晰的展示: 备忘录模式(快照模式):   ...