flowable，199boge，进阶

已于 2022-11-18 17:34:36 修改
阅读量1.2k 收藏 8
点赞数 2
分类专栏： # 07 互联网生态 文章标签： 其他
于 2022-11-10 14:57:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aiwokache/article/details/127788938
版权

Flowable BPMN 用户手册 (v 6.3.0)

idea的Flowable BPMN visualizer插件

一 多人会签

  1. 使用场景
    1. 同一个任务Task，可能需要有3个都要去做审批。
    2. 这3个人可能是并行、串行地去做审批。
    3. 这3个人中，可能要3个人都通过才结束、2个人通过就可结束、甚至1个人通过也可结束。
  2. 案例演示：
    1. 第一步：ui，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：用户任务
        1. 第a步：多人、并行与串行、结束规则，Multi instance(多实例）：
          1. sequential：是否串行，true:是，false:否（并行）。
          2. loop cardinality：循环的次数。比如，有3个人就写3，表示此任务由3个人单循环完成。
          3. Collection：集合（候选人集合）。如可以填写persons（List<Pserson>），然后for循环persons。
          4. Element varialbe：元素实例。pseron，即上面for循环（List<Pserson> persons）的单个实例。
          5. Completion condition：完成的条件。如：填写EL表达式${multilnstanceCompleteTask.completeTask(execution)}，此表达式的作用是从spring容器中获取相关的对象，并且调用相应的方法。
        2. 第b步：给task执行时，创建监听器，监听器通过行为触发。比如，在创建时触发：
          1. Event：监听的行为（事件）
          2. Type：
            1. java class：java类
            2. expression：表达式，如${}
            3. delegate expression：
          3. Expression：
      3. 第3步：空结束事件
    2. 第二步：idea编程
      1. 第1步：定义多从会签的规则MulitiInstanceCompleteTask.java，控制多实例完成的规则：
        @Component("mulitiInstanceCompleteTask")
        public class MulitiInstanceCompleteTask implements Serializable {
            /**
             * 完成任务是需要触发的方法
             * @param execution
             * @return
             *     false 表示会签任务还没有结束
             
             *     true 表示会签任务结束了
             */
            public boolean completeTask(DelegateExecution execution) {
                System.out.println("总的会签任务数量：" + execution.getVariable("nrOfInstances")
                        + "当前获取的会签任务数量：" + execution.getVariable("nrOfActiveInstances")
                        + " - " + "已经完成的会签任务数量：" + execution.getVariable("nrOfCompletedInstances"));
                //有一个人同意就通过
                Boolean flag = (Boolean) execution.getVariable("flag");
                System.out.println("当前意见："+flag);
                return flag;
            }
        }
        1. flowable默认帮我们提供的流程实例的变量：
          1. nrOfInstances：总的会签任务数量。如上面设置的3。
          2. nrOfActiveInstances：当前获取的会签任务数量，即还没有完成的。
          3. nrOfCompletedInstances：已经完成的会签任务数量。
        2. flag：我们自定义的。
        3. return flag：控制当前会签是否结束的。
      2. 第2步：编写监听器（供上面使用）
        @Component("mulitiInstanceTaskListener")
        public class MulitiInstanceTaskListener implements Serializable {
            
            public void completeListener(DelegateExecution execution){
                System.out.println("任务："+execution.getId());
                System.out.println("persons:" + execution.getVariable("persons"));
                System.out.println("person" + execution.getVariable("person"));
            }
        }
        1. 作用：监听在任务Task的创建，在监听器里可以获取流程实例以及任务Task的相关信息。
      3. 第3步：部署流程实例
      4. 第4步：创建（启动）流程实例： @Test
            void startFlow() throws Exception{
                Map<String,Object> map = new HashMap<>();
                // 设置多人会签的数据
                map.put("persons", Arrays.asList("张三","李四","王五","赵六"));
                ProcessInstance processInstance = runtimeService
                        .startProcessInstanceById("myProcess:1:ba1518fc-b22d-11ec-9313-c03c59ad2248",map);
            }
        1. 注意：这里会签人数我们设置为3，但实际给的人数是4个人，这里会不会有问题呢？不会。多人会签的规则，会签人数大于或等于配置人数即可。
      5. 第5步：验证1

        1. 效果：MulitiInstanceTaskListener.completeListener()被执行3次。因为会签从数设置为3，所以循环创建任务Task为3次，所以监听器走了3次。每次创建任务，就从person列表中获取一个候选人绑定给了任务task。如下，控制台打印：
        2. act_ru_task：有3条任务被创建
          注意：但任务的分配人ASSIGNEE_没有值？这是因为我们没有去绑定它，需要我们去做动态绑定。比如，我们可以在监听器MulitiInstanceTaskListener.completeListener()进行绑定，即任务Task创建的时候进行动态绑定（指派）处理人。
      6. 第6步：通过任务id，去完成任务（查看多人会签任务时，有1个人去完成任务的效果是怎么样的）  
           @Test
    void completeTask1(){
        Map<String,Object> map = new HashMap<>();
        map.put("flag",false); //设置为true，结束多人会签
        taskService.complete("71337501-b22e-11ec-a534-c03c59ad2248",map);
        System.out.println("complete ....");
    }
         
        1. map.put("flag",false); 
          1. 去完成任务task时，绑定一个流程变量flag=false。
        2. 其中taskService.complete("71337501-b22e-11ec-a534-c03c59ad2248",map);：
          1. 71337501-b22e-11ec-a534-c03c59ad2248：为任务Task的id（act_ru_task表中查找）。
          2. 因为ASSIGNEE_没有值，表明没有指派此任务的具体候选人，所以这里使用的是包含任务id参数的处理方法，去完成（处理）任务。而不是使用包含处理人参数的处理方法。
             
      7. 第7步：验证2

        1.  MulitiInstanceCompleteTask.completeTask()被执行1次，控制台有如下打印。：

          1. 当前意见:false，表示当前会签任务没有结束，继续会签直到遇到true为止。

        2. act_ru_task：还有2条任务（删除一条任务了）

      8. 第8步：再次通过任务id，去完成任务（查看多人会签任务时，有2个人去完成任务的效果是怎么样的） 

        1. map.put("flag",true); //设置为true，结束多人会签

      9. 第9步：验证3

        1.  MulitiInstanceCompleteTask.completeTask()又被执行1次，控制台有如下打印。：

          当前意见:true，表示当前会签结束了，即“用户任务”这个节点完成了，流转空结束事件。

        2. act_ru_task：3条任务都删除了，甚至连没有去完成的那1条任务也被删除了。

​​​​​二 回退、驳回、撤消

  1. 概念
    1. 回退和驳回区别不大，其实可以把它们看成是同一个概念。
    2. 撤消与回退、驳回是有一点区别的。
      1. 撤消举例：流程流转到用户2之后，想撤回到用户1。这时用户2的历史任务就没有了。
  2. 串行的回退

    1. 应用场景

      1. 用户任务4回退到用户任务3，或者从用户任务4回退到用户任务1。

    2. 案例演示
      1. 第一步：ui，绘制流程图
        1. 用户任务1，user1
        2. 用户任务2，user2
        3. 用户任务3，user3
        4. 用户任务4，user4
      2. 第二步：idea编程
        1. 第1步：部署流程
        2. 第2步：创建（启动）流程实例
        3. 第3步：user1完成用户任务1，流转到用户任务2（user2），act_ru_task验证
        4. 第4步：user2完成用户任务2，流转到用户任务3（user3）
        5. 第5步：user3完成用户任务3，流转到用户任务4（user4）
        6. 第6步：从用户任务4（user4）回退到用户任务3（user3) 
              /**
     * moveActivityIdTo()，可以从当前的流程跳转到任意的节点
     */
    @Test
    public void rollbackTask(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("67501")
                .moveActivityIdTo("usertask4","usertask3")//方法1：可以从当前活动的节点(Id），跳转指定的新的节点（Id）
                //.moveActivityIdsToSingleActivityId(currentActivityIds,newActivityId)
                .changeState();//改变状态
    }
        7. 第7步：验证
          1. act_hi_actinst：操作后我们可以在对应的历史表中看到相关的信息：
        8. 第8步：user3完成用户任务3，流转到用户任务4（user4）
        9. 第9步：从用户任务4（user4）回退到用户任务1（user1) 
             @Test
    public void rollbackTask1(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        List<String> newActivityIds = new ArrayList<String>();
        newActivityIds.add("usertask1");
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("67501")
                //方法1：可以从当前活动的节点(Id），跳转指定的新的节点（Id）
                //.moveActivityIdTo("usertask4","usertask3")
                //方法2：从当前活动的节点（id）,跳转到List<String> ids集合(多个节点）。
                .moveSingleActivityIdToActivityIds("usertask4",newActivityIds)
                .changeState();//改变状态
    }
        10. 第10步：验证
          1. act_hi_actinst：操作后我们可以在对应的历史表中看到相关的信息：
        11. 第11步：用户任务1 》用户任务2 》用户任务3 》用户任务4
        12. 第12步：从用户任务4（user4）回退到用户任务3（user3) 
             @Test
    public void rollbackTask1(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        List<String> newActivityIds = new ArrayList<String>();
        newActivityIds.add("usertask1");
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("67501")
                //方法1：可以从当前活动的节点(Id），跳转指定的新的节点（Id）
                //.moveActivityIdTo("usertask4","usertask3")
                //方法2：从当前活动的节点（id）,跳转到List<String> ids集合(多个节点）。
                //.moveSingleActivityIdToActivityIds("usertask4",newActivityIds)
                //方法3：不管当前节点是哪个了，就是要从当前执行实例跳到哪个节点。参数1：执行id，参数2：目标id。
                .moveExecutionToActivityId("77501","usertask3")
                .changeState();//改变状态
    }
    3. 注意事项
      1. 如果上面的流程图中，包含了一个排他网关，那也算是串行的。
      2. 如果上面的流程图中，包含了一个多用户实例，那也算是串行的。
      3. 可以看到任务又回到了user1处。也就是在串行的流程中，我们可以回退到任意的用户节点，当然这个串行也包括多人会签和排他网关节点。当然在回退的时候我们还可以使用moveActivityIdTo(String currentActivityId,String newActivityId)这个方法来处理。
  3. 并行的回退

    1. 应用场景

      1. 业务副总肯定是不能回退到行政副总。即使你可以强行跳过来，但这种逻辑是不合理的。

      2. 从业务副总回退到业务负责人，这是串行的，和上面的操作一样。

      3. 关注1：从并行节点回退到串行节点。并行审批流转到业务副总（没处理），同时流转到行政副总（没处理）。编码要实现，业务副总（没处理）回退到用户审批01（起始节点）。自动地，行政副总要自动回退到用户审批01（起始节点）。

      4. 关注2：并行审批流转到业务副总（没处理），同时流转到行政副总（已处理，到达并行网关之集合）。因为是并行网关，所以也要等待业务副总（没处理）审批是吧。这时想编码要实现，业务副总（没处理）回退到用户审批01（起始节点）。自动地，行政副总要自动回退到用户审批01（起始节点）。

      5. 关注3：从串行节点回退到并行节点。总经理回退到并行网关中的业务副总、行政副总。

      6. 关注4：总经理回退到用户审批01（起始节点），其实也是串行的，和上面的操作一样。

    2. 案例演示
      1. 第一步：ui，绘制流程图
        1. 并行网关
        2. 用户审批01，user1
        3. 业务负责人，user2
        4. 业务副总，user3
        5. 行政副总，user4
        6. 总经理，user5
      2. 第二步：演示1：业务副总（没处理）回退到用户审批01。行政副总会自动回退到用户审批01。
        1. 第1步：部署流程
        2. 第2步：创建（启动）流程实例
        3. 第3步：用户审批01，user1，完成任务
          1. task表：产生2条并行的任务task，业务负责人user2和行政副总user4。
        4. 第4步：业务负责人，user2，完成任务
          1. task表：流转到：行政副总user4、业务副总user3
        5. 第5步：业务副总（没处理）回退到用户审批01，重新去录入相关数据。行政副总会自动回退到用户审批01。 
              /**
     * 回退操作
     *   业务副总驳回到到用户审批处  那么行政审批的应该自动回到到用户审批处
     */
    @Test
    public void rollbackTask(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 当前的Task对应的用户任务的Id
        List<String> currentActivityIds = new ArrayList<String>();
        currentActivityIds.add("usertask4"); // 业务副总
        currentActivityIds.add("usertask3"); // 行政副总
        // 需要回退的目标节点的用户任务Id
        String newActivityId = "usertask1"; // 用户审批01
        // 回退操作
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("95001")
                .moveActivityIdsToSingleActivityId(currentActivityIds,newActivityId)
                .changeState();
    }

        6. 第6步：验证

          1. task表

          2. act_hi_actinst表，查看任务列表

      3. 第三步：演示2：并行审批流转到业务副总（没处理），同时流转到行政副总（已处理，到达并行网关之集合）。因为是并行网关，所以也要等待业务副总（没处理）审批是吧。这时想编码要实现，业务副总（没处理）回退到用户审批01（起始节点）。自动地，行政副总要自动回退到用户审批01（起始节点）。

        1. 第1步：完成任务：用户审批01，user1。业务负责人，user2。行政副总，user4。

        2. 第2步：验证

          1. task表，只有1条任务，流转到（即等待）业务副总user3

          2. act_hi_actinst表，查看任务列表

        3. 第3步：业务副总（没处理）回退到用户审批01，重新去录入相关数据。行政副总会自动回退到用户审批01：

          /**
     * 回退操作
     *   业务副总驳回到到用户审批处
     */
    @Test
    public void rollbackTask(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 当前的Task对应的用户任务的Id
        List<String> currentActivityIds = new ArrayList<String>();
        currentActivityIds.add("usertask4"); // 业务副总
        //currentActivityIds.add("usertask3"); //行政副总
        // 需要回退的目标节点的用户任务Id
        String newActivityId = "usertask1"; // 用户审批01
        // 回退操作
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("95001")
                .moveActivityIdsToSingleActivityId(currentActivityIds,newActivityId)
                .changeState();
    }

      4. 第四步：演示3：总经理回退到并行网关中的业务副总、行政副总。

        1. 第1步：完成任务：用户审批01，user1。业务负责人，user2。业务副总，user3。行政副总，user4。
        2. 第2步：验证
          1. task表：只剩下总经理，user5
        3. 第3步：总经理user5，回退到并行网关里面（即业务副总，user3。行政副总，user4。） 
              @Test
    public void rollbackTask(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 当前的Task对应的用户任务的Id
        List<String> newActivityId = new ArrayList<String>();
        newActivityId.add("usertask2"); //业务负责人
        newActivityId.add("usertask3"); //行政副总
        // 回退操作
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("95001")
                .moveSingleActivityIdToActivityIds("usertask5",newActivityId)
                .changeState();
    }
    3. 子流程回退
      1. 应用场景
        1. 子流程回退，其实可以看成一个串行回退。就是一个串行的，没什么太多区别啊。
        2. 关注1：子任务1回退到主任务1
        3. 关注2：主任务2回退到子任务1
      2. 案例演示
        1. 第一步：ui，绘制流程图：
          1. 主任务1，user1，usertask1
          2. 子任务1，user2，usertask2
          3. 主任务2，user3，usertask3
        2. 第二步：演示1：子任务1回退到主任务1
          1. 代码实现1： 
                /**
     * 回退操作
     *   从子流程回退到主流程操作
     */
    @Test
    void rollbackMainTask(){

        // 回退操作
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("2501")
                // 没有多个时，可用此方法
                .moveActivityIdTo("usertask2","usertask1")
                .changeState();
    }

}
          2. 代码实现2： 
                /**
     * 回退操作
     *   从子流程回退到主流程操作：moveExecutionToActivityId不关心当前的节点
     */
    @Test
    void rollbackMainTask(){

        // 回退操作
        runtimeService.createChangeActivityStateBuilder()
                .processInstanceId("2501")
                .moveExecutionToActivityId("5003","usertask1")
                .changeState();
    }
        3. 第三步：演示2：主任务2回退到子任务1
          1. 代码实现： 
            /**
 * 回退操作
 */
@Test
void rollbackSubTask(){

    // 回退操作
    runtimeService.createChangeActivityStateBuilder()
            .processInstanceId("2501")
            //当然也可以回退到usertask1
            .moveActivityIdTo("usertask3","usertask2")
            .changeState();
}

        4. 第四步：验证

          1. task表

          2. act_hi_actinst

    4. 撤消 = 回退 + 删除历史记录信息

    5. 实际开发过程中，要结合历史数据。通过一些sql语句，所这些回退节点都找出来。如果说操作比较复杂，你可能还要去重、编排、处理。

三 动态表单

  1. 概述
    1. 应用场景：在做审批流程的时，审批流程中的要有数据流转。
      1. 方案1（建议）：可以做一个请假的表单、审批的表单、报销的一个表单，使用表单更规范。
      2. 方案2（不建议）：使用流程变量绑定数据，也可以，但不规范。
  2. 内置表单
    1. 应用场景
      1. 启动流程时可以给它绑定一个表单。
      2. 启动流程的时候，可以往表单里面去给一些默认信息。
      3. 用户申请节点可以打开表单，并且可以修改（录入）其中的一些信息。比如，修改（录入）请假原因、请假天数、请假开始与结束时间等。
    2. 案例演示
      1. 第一步：ui，绘制流程图，请假审批流程：
        1. 第1步：空启动事件
          1. 第a步：空启动事件-动态表单属性：请假天数 days：
          2. 第b步：空启动事件-动态表单属性：请假开始时间 startTime：
          3. 第c步：空启动事件-动态表单属性：请假原因 reson string。
        2. 第2步：用户申请，user1，usertask1
          1. 第a步：用户申请-动态表单属性：请假天数 days。
          2. 第b步：用户申请-动态表单属性：请假开始时间 startTime：
          3. 第c步：用户申请-动态表单属性：请假原因 reson string。
        3. 第3步：排他网关
          1. 总监审批，days>3，user2，usertask2
            1. 注意：如果这个节点，需要用表单去做相关操作，也是可以设置动态表单属性的。
          2. 部门经理审批，days<=3，user3，usertask3
            1. 注意：如果这个节点，需要用表单去做相关操作，也是可以设置动态表单属性的。
        4. 第4步：空结束事件
      2. 第二步：idea编码
        1. 第1步：部署流程
          1. 第a步：编码：查看流程关联的表单信息。比如，查看空启动事件节点 或 用户申请节点有没有关联相关的表单： 
            /**
     * 查看部署的流程内置的表单信息
     */
    @Test
    public void getStartFromData(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        StartFormData startFormData = processEngine.getFormService().getStartFormData("inner_form:1:4");
        List<FormProperty> formProperties = startFormData.getFormProperties();
        for (FormProperty formProperty : formProperties) {
            String id = formProperty.getId();
            String name = formProperty.getName();
            FormType type = formProperty.getType();
            System.out.println("id = " + id);
            System.out.println("name = " + name);
            System.out.println("type.getClass() = " + type.getClass());
        }
    }
          2. 第b步：验证：查看流程关联的表单信息。比如，查看空启动事件节点 或 用户申请节点有没有关联相关的表单：
        2. 第2步：创建（启动）流程实例
          1. 第a步：编码 
               /**
     * 正常的启动流程
     */
    @Test
    void startFlow() throws Exception{
        Map<String,Object> map = new HashMap<>();
        map.put("days","5");
        map.put("startDate","20220403");
        map.put("reason","想休息下");
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceById("myProcess:5:4dd61987-b313-11ec-882d-c03c59ad2248",map);
    }


    /**
     * 通过FormService来启动一个表单流程
     * @throws Exception
     */
    @Test
    void startFormFlow() throws Exception{
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .deploymentId("4da14de4-b313-11ec-882d-c03c59ad2248")
                .singleResult();
        //  map只能是<String,String>
        Map<String,String> map = new HashMap<>();
        map.put("days","2");
        map.put("startDate","20220406");
        map.put("reason","出去玩玩");
        //  提交启动的表单数据
        // ProcessInstance processInstance = processEngine.getFormService().submitStartFormData("inner_form:1:4", map);
        ProcessInstance processInstance = processEngine.getFormService().submitStartFormData(processDefinition.getId(), map);

    }
          2. 第b步：验证
            1. act_ru_task：有2条任务Task
        3. 第3步：查看某个任务表单数据
          1. 第a步：编码 
                /**
     * 根据Task编号来查看表单数据
     */
    @Test
    public void getTaskFormData(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        String taskId = "2508";// taskId，即任务编号
        TaskFormData taskFormData = processEngine.getFormService().getTaskFormData(taskId);
        List<FormProperty> formProperties = taskFormData.getFormProperties();
        for (FormProperty formProperty : formProperties) {
            System.out.println("formProperty.getId() = " + formProperty.getId());
            System.out.println("formProperty.getName() = " + formProperty.getName());
            System.out.println("formProperty.getValue() = " + formProperty.getValue());
        }
    }
          2. 第b步：验证
        4. 第4步：修改（保存、更新）某个任务表单数据
          1. 第a步：编码 
                /**
     * 根据Task编号来修改（保存、更新）表单数据
     */
    @Test
    public void saveOrupdateTaskFormData(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        String taskId = "2508";// taskId，即任务编号
        Map<String,String> map = new HashMap<String,String>();
        map.put("reson","巴拉巴拉");
        FormService formService = processEngine.getFormService();
        formService.saveFormData(taskId,map);
    }
          2. 第b步：验证
        5. 第5步：完成任务
          1. 编码： 
            /**
     * 直接完成任务
     */
    @Test
    public void submitTaskFormData1(){
        // 直接完成
        ProcessEngine processEngine = configuration.buildProcessEngine();
        processEngine.getTaskService().complete("2508");
    }

    /**
     * 保存表单数据并完成任务
     */
    @Test
    public void submitTaskFormData2(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        String taskId = "2508";
        // 完成任务的同时可以修改（保存、更新）表单数据
        Map<String,String> map = new HashMap<String,String>();
        map.put("days","7");
        map.put("startDate","20220408");
        map.put("reason","9出去玩玩");
        processEngine.getFormService().submitTaskFormData(taskId,map);
    }
          2. 验证：走上面的“ 第3步：查看某个任务表单数据 ”。
          3. 注意：这里为什么不出现"days"，"startTime"，"reason"这些表单数据呢？因为在绘制流程图的时候，我们没有给这个节点绑定任何的表单。我们只给“空启动事件”和“用户申请”两个节点绑定了表单。
        6. 第6步：查看历史Task表单数据：一个Task完成后，如果我们想要查看之前的表单的历史数据可以通过如下的方法来实现 
             /**
     * 查看已经完成的Task的表单数据
     */
    @Test
    void getHisTaskFormData(){
        String taskId = "80efeb32-b313-11ec-a7ff-c03c59ad2248";
        List<HistoricDetail> list = processEngine.getHistoryService()
                .createHistoricDetailQuery()
                .taskId(taskId)
                .formProperties()
                .list();
        for (HistoricDetail historicDetail : list) {
            HistoricFormPropertyEntityImpl his = (HistoricFormPropertyEntityImpl) historicDetail;
            System.out.println("his.getPropertyId() = " + his.getPropertyId());
            System.out.println("his.getPropertyValue() = " + his.getPropertyValue());
        }
    }
  3. 内置表单的缺点
    1. 我们会发现在上面的例子中通过内置的表单，我们需要在每个节点都设置一份表单数据，不是很灵活，这时我们可以单独创建一份表单，然后在对应的节点做引用就可以了。
  4. 外围表单
    1. 案例演示
      1. 第一步：创建表单在项目中创建test.form，内容是下面的json。注意：表单定义文件是以.form为后缀， 内容格式为Json格式。注意：上面文件中的key是唯一标识，我们在表单处理的时候是根据这个key来获取的哦。 
        {
"key": "form1",
"name": "请假流程",
"fields": [
            {
            "id": "startTime",
            "name": "开始时间",
            "type": "date",
            "required": true,
            "placeholder": "empty"
            },
            {
            "id": "days",
            "name": "请假天数",
            "type": "string",
            "required": true,
            "placeholder": "empty"
            },
            {
            "id": "reason",
            "name": "请假原因",
            "type": "text",
            "required": true,
            "placeholder": "empty"
            }
    ]
}
      2. 第二步：绘制流程图（或者 修改Xxx.bpmn20.xml文件，修改相应的节点，删除内置表单配置，加入处置表单引用）：
        1. 空启动事件、用户申请、总监审批、部门经理审批都引用上面的表单form1。
      3. 第三步：部署流程
      4. 第四步：部署表单。因为流程关联了form1表单，因此在流程部署结束后要单独对表单进行部署。
        1. 编码： 
            @Autowired
    private FormRepositoryService formRepositoryService;

    /**
     * 部署form表单：在外置Form表单中我们需要在流程部署完毕后，再对表单做部署的操作	
     */
    @Test
    public void deployForm() throws Exception{

        FormDeployment formDeployment = formRepositoryService.createDeployment()
                .addClasspathResource("holiday.form")
                .name("test")
                .parentDeploymentId("1") //和我们上面部署的流程关联
                .deploy();
        System.out.println("formDeployment.getId() = " + formDeployment.getId());
    }
        2. 验证：act_fo_form_deployment
      5. 第五步：创建（启动）流程实例
        1. 编码： 
            /**
     * 启动流程实例，并且设置对应的值
     */
    @Test
    void startTask(){
        Map<String,Object> map = new HashMap<>();
        map.put("days","4");
        map.put("startTime","20220404");
        map.put("reason","出去玩玩");
        ProcessInstance processInstance = runtimeService.startProcessInstanceWithForm(
                "myProcess:1:4"
                , null
                , map
                , "请假流程");
        String id = processInstance.getId();
        System.out.println("id = " + id);

    }
        2. 验证：act_ru_task
        3. 报错：NullPointException
          1. 原因：startTime = new Date()
          2. 解决：startTime = 20221118
      6. 第六步：查看某个Task对应的表单信息
        1. 编码： 
          /**
     * 查看流程定义表单数据
     */
    @Test
    public void getTaskFormData1(){
        Task task = taskService.createTaskQuery()
                .processDefinitionId("myProcess:1:4")
                .taskAssignee("zhangsan")
                .singleResult();
        // FormInfo 表单的元数据信息
        FormInfo formInfo = runtimeService.getStartFormModel("myProcess:1:4", "5001");
        System.out.println("formInfo.getId() = " + formInfo.getId());
        System.out.println("formInfo.getName() = " + formInfo.getName());
        System.out.println("formInfo.getKey() = " + formInfo.getKey());
        // FormModel 表单中的具体信息 具体实现是 SimpleFormModel
        SimpleFormModel formModel = (SimpleFormModel) formInfo.getFormModel();
        List<FormField> fields = formModel.getFields();
        for (FormField field : fields) {
            System.out.println("field.getId() = " + field.getId());
            System.out.println("field.getName() = " + field.getName());
            System.out.println("field.getValue() = " + field.getValue());
        }
        System.out.println("formModel = " + formModel);
    }

	/**
	* 查看具体的Task的表单数据
	*/
    @Test
    void getTaskData(){
        FormInfo formInfo = taskService.getTaskFormModel("17505");
        System.out.println("formInfo.getId() = " + formInfo.getId());
        System.out.println("formInfo.getName() = " + formInfo.getName());
        System.out.println("formInfo.getKey() = " + formInfo.getKey());
        SimpleFormModel formModel = (SimpleFormModel) formInfo.getFormModel();
        List<FormField> fields = formModel.getFields();
        for (FormField field : fields) {
            System.out.println("field.getId() = " + field.getId());
            System.out.println("field.getName() = " + field.getName());
            System.out.println("field.getValue() = " + field.getValue());
        }
    }
        2. 验证：打印都一样
      7. 第七步：完成任务：在外置表单的场景中我们需要通过taskService.completeTaskWithForm来完成表单的任务
        1. 编码： 
            /**
     * 完成任务
     */
    @Test
    public void completeTaskForm(){
        Map<String,Object> map = new HashMap<>();
        map.put("days","4");
        map.put("startTime","20220404");
        map.put("reason","出去玩玩");
        String taskId = "5010";
        String formDefinitionId = "2503";
        String outcome = "波哥";
        taskService.completeTaskWithForm(taskId,formDefinitionId,outcome,map);
    }
        2. 验证：act_ru_task

四 事件

1 空启动事件

  1. 首先，部署流程。注意此时，流程实例没有创建（启动）。
  2. 最后，创建（启动）流程实例：需要人为显示调用startProcessInstanceByXXX API方法。
  3. 注意：在部署的流程中加入了定时事件、消息事件、错误事件、信号事件等等以后，创建（启动）流程实例就有了不同的情况：
    1. 比如，启动时不再是空启动事件。
    2. 比如，部署完成的流程中加入了定时事件。可能过个10分钟（定时），flowable就会自动创建（启动）新流程实例。
    3. 比如，部署完成的流程中注册了信号量。那么flowable能够捕获相应的信号，然后触发了信号事件，可能flowable就会自动创建（启动）新流程实例。

2 定时事件

  1. 应用场景
    1. 每天晚上的某个时候，启动定时触发的任务。然后呢，1234，通过各个流程去流转。
  2. 定时器启动事件
    1. 第一步：UI，绘制流程图
      1. 第1步：定时器启动事件（删除空启动事件）
        1. 第a步：触发的时间设置：开始时间(ISO-8601)   2022-03-27T23:14:14
      2. 第2步：用户任务（也可以是别的任务）
        1. 第a步：分配给单个用户，zhangsan
      3. 第3步：结束事件
      4. 第4步：保存
    2. 第二步：UI，演示应用程序（部署流程）
      1. 第1步：创建一个应用程序
        1. 第a步：添加包含的流程
        2. 第b步：保存并退出
      2. 第2步：发布些应用程序
    3. 第三步：UI，zhangsan用户登录，并验证：
      1. 第1步：到2022-03-27T23:14:14时会自动创建（启动）流程。通过FlowableUI我们可以看到，没有启动流程实例的情况下，到里23:14:14秒的时候自动帮助我们创建了一个流程实例。
      2. 第2步：并且任务流转到第1个任务节点，处理人是zhangsan。
        1. 可查看显示图
      3. 第3步：zhangsan处理任务，
      4. 第4步：流程结束。
  3. 定时器捕获中间事件 
    1. 第一步：UI，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：任务Task，人工处理，固定zhangsan
      3. 第3步：中间计时器捕获事件
        1. 第a步：触发的时间设置：开始时间(ISO-8601)   2022-03-27T23:25:14
      4. 第4步：任务Task，人工处理，固定lisi
      5. 第5步：流程结束 
      6. 第6步：保存
    2. 第二步：UI，演示应用程序（部署流程）
      1. 第1步：创建一个应用程序
        1. 第a步：添加包含的流程
        2. 第b步：保存并退出
      2. 第2步：发布些应用程序
    3. 第三步：UI，任务应用程序
      1. 第1步：流程Tab，启动流程（创建流程实例）
      2. 第2步：zhangsan
        1. 第a步：切换用户，使用zhangsan用户登录。
        2. 第b步：UI，任务应用程序，流程Tab，zhangsan点击完成”人工处理“
      3. 第3步：lisi
        1. 第a步：切换用户，使用lisi用户登录。
        2. 第b步：刚开始，没有任务
        3. 第c步：直到2022-03-27T23:25:14时，有一个任务
    4. 总结
      1. 当第一个人工处理完成后，第二个人工处理的任务需要在2022-03-27T23:25:14之后执行
      2. 通过FlowableUI的案例演示我们可以看到后一个任务是在定时时间之后执行的
  4. 定时器边界事件：比如，流程流转到某个任务Task，而这个任务Task过了多久没有被处理会怎么怎么样 
    1. 第一步：UI，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：任务Task，人工处理1，固定zhangsan
      3. 第3步：边界计时器事件
        1. 第a步：触发的时间设置：开始时间(ISO-8601)   2022-03-27T23:36:14
      4. 第5步：任务Task，人工处理2，固定lisi
      5. 第4步：任务Task，人工处理3，固定wangwu
      6. 第6步：流程结束 
      7. 第7步：保存
    2. 第二步：UI，演示应用程序（部署流程）
      1. 第1步：创建一个应用程序
        1. 第a步：添加包含的流程
        2. 第b步：保存并退出
      2. 第2步：发布些应用程序
    3. 第三步：UI，任务应用程序
      1. 第1步：流程Tab，启动流程（创建流程实例）
      2. 第2步：zhangsan
        1. 第a步：切换用户，使用zhangsan用户登录。
        2. 第b步：UI，任务应用程序，任务Tab，zhangsan有1个任务，但他不处理任务Task
      3. 第3步：等到2022-03——27T23:36:14
      4. 第4步：wangwu
        1. 第a步：切换用户，使用wangwu用户登录。
        2. 第b步：UI，任务应用程序，任务Tab，有1个任务Task
    4. 总结：
      1. 人工任务1如果在定义的2022-03-27T23:36:14这个时间之前还没有处理，那么就会触发定时边界事件，从而从人工任务3。
      2. 然后在张三这个位置我们不完成，等到定时到来，达到定时的时间，任务进入到了人工审批三
  5. timeDuration
    1. 定时器启动事件：持续时间
      1. 第一步：UI，绘制流程图
        1. 第1步：定时器启动事件 
          1. 第a步：持续时间(例: PT5M)，PT2M/PT30S，部署后等待2分钟启动
        2. 第2步：服务任务（Task)，自动任务
          1. 第a步：设置属性 "类"，值是 "类的路径"
          2. 附：自动任务处理规则
            1. 如果没特殊的情况，自动任务会自动处理完成
            2. 如果想捕获自动任务的自动处理事件（行为），并做相关处理的话，可以创建一个委托的java去做处理。
        3. 第3步：结束流程
        4. 第4步：保存，导出
      2. 第二步：idea编码
        1. 第1步：自动任务，委托处理类
        2. 第2步：部署流程（可以用XxxController方式，也可以用单元测试的方式）
      3. 第三步：启动项目
      4. 第四步：浏览器访问，验证
        1. 2分钟后，可以看数据库
      5. 总结：
        1. 发布任务后然后我们等待两分钟就可以看到任务到了zhangsan的位置。
        2. 重复部署流程，定时任务会重复走。
    2.  中间计时器捕获事件：持续时间
      1. 第一步：UI，绘制流程图
        1. 第1步：自动任务一（任务类型为：服务任务）（任务类型：因为异步任务）
          1. 类 = 处理类的路径
        2. 第2步：中间计时器捕获事件
          1. 持续时间 = 30s
        3. 第3步：自动任务二（任务类型为：服务任务）（任务类型：因为异步任务）
          1. 类 = 处理类的路径
      2. 第二步：idea编码
        1. 第1步：部署流程
        2. 第2步：创建（启动）流程实例，阻塞（因为异步任务）
        3. 第3步：流转到”自动任务一“，并自动完成任务，类的方法执行
        4. 第4步：阻塞多长时间
        5. 第5步：流转到”自动任务二“，并自动完成任务，类的方法执行
      3. 总结：阻塞多长时间，才把流转到下一个任务Task
    3. 边界计时器事件：持续时间
      1. 第一步：UI，绘制流程图
        1. 边界计时器事件，持续时间 = 5m
        2. 自动任务，类 = 类的路径
      2. ​​​​​​总结：“人工审核”任务Task，在5分钟之内还没有处理，触发边界计时器事件，然后调度（自动流转到）自动任务二 
  6. timeCycle：循环时间
    1. 定时器启动事件：循环时间
      1. 第一步：UI，绘制流程图
        1. 定时器启动事件，循环时间 = R3/PT20s（循环次数是3次，每次间隔20s）
        2. 自动任务一，类 = 类路径，是一种异步任务
      2. 总结： 效果是，部署流程以后，会自动创建（启动）3个流程实例，间隔20s。如果不指定次数，那么会无限循环下去（每隔多长时间都做一次）。
    2. 中间计时器捕获事件：循环时间   
      1. 第一步：UI，绘制流程图
        1. 自动任务一，类 = 类路径，是一种异步任务
        2. 中间计时器捕获事件，循环时间 = R3/PT20s（循环次数是3次，每次间隔20s）
        3. 自动任务二，类 = 类路径，是一种异步任务
      2. 总结：即使指定了多次循环次数，也只会触发1次中间计时器捕获事件，即只有1次流转到自动任务二。
    3. 边界计时器事件：循环时间
      1. 第一步：UI，绘制流程图
      2. 总结： 用户任务在指定的时间内没有被处理的话，会触发边界计时器事件（循环时间），然后任务流转到自动任务二。但是即使指定了多次循环次数，也只会触发1次边界计时器事件，即只有1次流转到自动任务二。
        1. 循环设定

          1. 启动事件：根据设置循环启动流程实例

          2. 边界事件：即使设置了循环时间也只会触发1次

          3. 中间事件：即使设置了循环时间也只会触发1次

3 消息事件

  1. 概述
    1. 消息：接收的邮件、接通电话、接收的短信等各种外部消息。      
    2. 消息事件：接收了消息以后，触发消息事件。
  2. 消息启动事件
    1. 第一步：UI，绘制流程图
      1. 第1步：定义外部要发送的消息：点击空白，消息定义属性。
      2. 第2步：点击消息节点，选择订阅的“外部消息”。
      3. 第3步：自动流程处理，类 = 类路径，是一种异步任务。
    2. 第二步：idea编码
      1. 第1步：部署流程
      2. 第2步：创建（启动）流程实例
        1. startProcessInstanceByMessage("xxx")，发送外部消息。注意：发送消息发送的应该是消息的名称而不是消息的ID。
    3. 总结： 效果，通过发外部消息触发消息启动事件，即创建（启动）了1个新的流程实例。然后，任务流转到“自动流程处理”，因为此任务是1个自动任务，所以会自动完成。最后，结束流程。
  3. 中间消息捕获事件
    1. 第一步：UI，绘制流程图
      1. 第1步：定义外部要发送的消息：点击空白，消息定义属性。
      2. 第2步：点击消息节点，选择订阅的“外部消息”。
    2. 第二步：idea编码
      1. 通过单元测试来发布外部事件：runtimeService.messageEventReceived("第二个消息",processExecutionId);，来触发中间消息捕获事件。
    3. 总结：消息中间事件就是，在流程运作中需要消息来触发的场景。案例演示，自动流程1处理完成后，需要接收特定的消息之后才能进入到自动流程2。
  4. 边界消息事件
    1. 第一步：UI，绘制流程图
      1. 第1步：定义外部要发送的消息：点击空白，消息定义属性。
      2. 第2步：点击消息节点，选择订阅的“外部消息”。
    2. 第二步：idea编码
      1. 第1步：部署流程
      2. 第2步：创建（启动）流程实例，流转到任务Task“人工处理”
      3. 第3步：单元测试，触发边界事件：runtimeService.messageEventReceived("第三个消息",processExecutionId);
    3. 总结：如果人工处理在消息订阅前没有处理就会触发边界事件

4 错误事件

  1. 概述
    1. 应用场景：当流程中抛出相关错误时，就会触发错误事件。
    2. 错误事件，只有开始错误事件和边界错误事件，而没有中间错误事件。
  2. 异常启动事件
    1. 注意事项
      1. 注意1：错误启动事件不能用于启动流程实例。即开始错误事件，不能够做为整个流程的启动事件。
      2. 注意2：错误启动事件（error start event），可用于触发事件子流程（Event Sub-Process）。
      3. 注意3：错误启动事件总是中断。
    2. 第一步：UI，绘制流程图
      1. 第1步：主流程：
        1. 自动任务1，类 = 类路径
      2. 第2步：事件子流程
        1. 第a步：异常启动事件
          1. 属性设置：错误引用 = error01
        2. 第b步：自动任务2 ，类 = 类路径
    3. 第二步：idea编码
      1. 第1步：修改Xxx.bpmn.xml文件，进行错误定义：
      2. 第2步：自动任务一的处理类抛出异常： 
        public class MyOneDelegate implements JavaDelegate {
    @Override
    public void execute(DelegateExecution execution) {

        System.out.println("完成自动审批任务-----》MyOneDelegate" + LocalDateTime.now().toString());
        // 业务执行发现有问题 此处的errorCode需要和定义的error标签中的errorCode保持一致
        throw new BpmnError("abcd");
    }
}
    4. 总结：首先，主流程一启动，流转到“自动任务一”。其次，如果“自动任务一”抛出了1个异常，那么事件子流程中的异常启动事件节点就会捕获到错误事件。最后，流程就会流转到事件子流程中的“自动任务二”。
  3. 边界错误事件
    1. 注意事项
      1. 边界错误事件，是在边界上面去触发。
      2. 边界错误事件，使用的是子流程，而不是事件子流程。
    2. 第一步：UI，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：子流程
        1. 第a步：空启动事件
        2. 第b步：自动任务一，类别是服务任务，类 = 类路径
        3. 第c步：空结束事件
      3. 第3步：自动任务二，类 = 类路径
      4. 第4步：边界错误事件
        1. 属性设置：错误引用：a123
      5. 第5步：自动任务三，类 = 类路径
    3. 第二步：idea编码
      1. 第1步：修改Xxx.bpmn.xml文件，进行错误定义：
      2. 第2步：部署流程
      3. 第3步：创建（启动）流程实例
    4. 总结：当流程开始，流转到子流程中来。如果子流程中的自动任务抛出指定的异常，那么就会触发边界错误事件的捕获，流程就会流转到自动任务三。

5 信号事件

  1. 应用场景
    1. 因为某些政策的变动，会自动发起一个人工审批的流程。
  2. 信号启动事件
    1. 全局
      1. 第一步：UI，绘制流程图

        1. 第1步：信号启动事件
          1. 信号引用 = signal01
        2. 第2步：自动任务
        3. 第3步：空结束事件
        4. 第4步：点击空白处，信号定义
      2. 第二步：idea编码
        1. 全局
          1. 第1步：修改Xxx.bpmn.xml文件，进行错误定义：
            1. flowable:scope="global"，全局
          2. 第2步：部署流程
          3. 第3步：流程是一个信息启动事件，所以我们需要释放对应的信号来触发流程的启动 
            /**
     * 通过信号发送来触发信号启动事件的执行
     * 全局的信息
     */
    @Test
    void signalReceived() throws Exception {
        runtimeService.signalEventReceived("firstSignal");
        // 我们得保证容器的运行，所以需要阻塞
        TimeUnit.MINUTES.sleep(1);
    }
    2. 局部
      1. flowable:scope="processInstance"，局部
      2. 注意：ps：信号启动事件中，使用全局或者是局部都没有区别，甚至说不起作用了。我们可以把信息的作用域由原来的golbal全局的调整为processInstance，测试后发现还是执行了，说明在启动事件信息的作用域其实是不起作用的
    3. 总结：
      1. 首先，定义一个任务。任务会去接收一个信号，做为该任务触发的条件。
      2. 效果：发出信号，触发信号启动事件，流程会流转到自动任务。
  3. 中间信号捕获事件
    1. 全局
      1. 第一步：UI，绘制流程图
        1. 第1步：信号定义，signal02
        2. 第2步：空启动事件
          1. 信号引用 = signal02
        3. 第3步：中间信号捕获事件
        4. 第4步：自动任务，类 = 类路径
        5. 第5步：空结束事件
      2. 第二步：idea编码
        1. 第1步：部署流程
        2. 第2步：创建（启动）流程实例
        3. 第3步：流程阻塞
        4. 第4步：发出全局信号 
          /**
     * 通过信号发送来触发信号启动事件的执行
     * 全局的信息
     */
    @Test
    void signalGolbal() throws Exception {
        runtimeService.signalEventReceived("secondSingal");
        // 我们得保证容器的运行，所以需要阻塞
        TimeUnit.MINUTES.sleep(1);
    }
    2. 局部：信号作用域为processInstance的情况
      1. 第一步：xml文件修改，信号作用域为processInstance
      2. 第二步：部署流程
      3. 第三步：创建（启动）流程实例
      4. 第四步：
        1. 仍然发全局的信号，控制台没有输出，事件不触发。
        2. 发出局部信号，不处理。因为processInstance的信息我们需要在流程实例内部抛出信号：
    3. 总结：
      1. 当我们启动事件后，会阻塞在这个消息获取中间事件处，等待相关信号后才会继续流转。
      2. 定义获取processInstance的信号，如果我们发送的是Global信号，那么是不会捕获的。
  4. 中间信号抛出事件
    1. 第一步：UI，绘制流程图
      1. 第1步：信号定义，全局，signal03
      2. 第2步：流程启动
      3. 第3步：并行网关 ——  分支
      4. 第4步：并行方向1
        1. 自动任务一
        2. 中间信号抛出事件，即抛出signal03信号
          1. 信号引用 = signal03
        3. 自动任务二
      5. 第5步：并行方向2
        1. 中间信号捕获事件，即捕获signal03信号
          1. 信号引用 = signal03
        2. 自动任务三
      6. 第6步：并行网关 —— 汇集
      7. 第7步：流程结束
    2. 第二步：idea编码
      1. 第1步：部署流程
      2. 第2步：创建（启动）流程实例
    3. 总结：
      1. 并行方向1：执行到“中间信号抛出事件”时，会抛出一个信号。抛出信号后，流转到“自动任务二”。
      2. 并行方向2：执行到“中间信号抛出事件”时，会抛出一个信号。信号触发“中间信号捕获事件”，流转到“自动任务三”。
  5. 边界信号事件
    1. 第一步：UI，绘制流程图
      1. 第1步：信号定义，signal04
      2. 第2步：空启动事件
      3. 第3步：人工任务，zhangsan
      4. 第4步：自动任务1，类 = 类路径
      5. 第5步：边界信号事件
        1. 信号引用 = signal04
      6. 第6步：自动任务2，类 = 类路径
    2. 第二步：idea编码
      1. 第1步：部署流程
      2. 第2步：创建（启动）流程实例
      3. 第3步：抛出信号： 
         @Test
    public void signalGlobal()  throws Exception{
        String signal = "signal2";
        Map<String, Object> variables = new HashMap();
        processEngine.getRuntimeService().signalEventReceived(signal,variables);
    }
      4. 第4步：流转到“自动任务二”
      5. 第5步：zhangsan处理任务
      6. 第6步：流转到“自动任务一”

6 结束事件

  1. 错误结束事件
    1. 第一步：UI，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：子流程
        1. 第a步：空启动事件
        2. 第b步：自动任务一，类 = 类路径
        3. 第c步：排他网关
        4. 第d步：分支1：流条件 flag > 0 》空结束事件
        5. 第e步：分支2：流条件 flag <= 0 》错误结束事件，错误引用 = error03
      3. 第3步：自动任务二，类 = 类路径 》空结束事件
      4. 第4步：错误边界事件，错误引用 = error03 》自动任务三，类 = 类路径 》空结束事件
    2. 第二步：idea编码
      1. 第1步：错误定义，修改bpmn.xml文件：
      2. 第2步：部署流程
      3. 第3步：创建（启动）流程实例
        1. 第a步：绑定全局变量：flag = 0
    3. 总结：
      1. 如果经过排他网关后，flag>0，走到的是空结束事件，那么就正常地走自动任务二 》空结束事件。
      2. 反之，如果，flag<=0，流转到错误结束事件后，会抛出1个错误，如果没有地方捕获的话整个流程就在异常状态下结束。
      3. 如果错误边界事件捕获了错误结束事件抛出的错误（相当于catch处理），那就走自动任务三。 
  2. 结束终止（中断）事件
    1. 案例1：无子流程
      1. 第一步：UI，绘制流程图
        1. 第1步：空启动事件
        2. 第2步：并行网关
          1. 第a步：用户任务一，zhangsan
          2. 第b步：用户任务二，lisi
          4. 第c步：用户任务三，wangwu
            1. 排他网关
              1. 分支1：流条件（连接条件）&{flag <= 0} 》终止结束事件
              2. 分支2：流条件（连接条件）&{flag > 0} 》汇集并行网关
        3. 第3步：并行网关
        4. 第4步：空结束事件
      2. 第二步：idea编码
        1. 第1步：部署流程
        2. 第2步：创建（启动）流程实例
        3. 第3步：wangwu处理，flag = 0
      3. 总结：
        1. 条件，在没有子流程的情况下：
          1. 如果“终止结束事件”被触发，则整个流程结束（即并行网关的3条分支都会结束）。
          2. 比如，总结理觉得靠近双十一会很忙，在对于张三的请假申请（并行的人事审批、行政审批、总经理审批）直接终止。
          3. 效果：wangwu处理，flag = 0，触发终止结束事件，Task表中删除3条分支的任务数据。查看历史数据act_hi_actinst表，发现被删除的3条中的2条有终止结束事件标识。
    2. 案例2：有子流程
      1. 第一步：UI，绘制流程图
        1. 第1步：空启动事件
        2. 第2步：并行网关
          1. 第a步：用户任务一，zhangsan
          2. 第b步：用户任务二，lisi
          3. 第c步：子流程
            1. 第i步：空启动事件
            2. 第ii步：子人工任务一，wangwu
            3. 第iii步：排他网关
              1. 分支1：子人工任务二，赵六
              2. 分支2：终止结束事件
            4. 第iiii步：空结束事件
        3. 第3步：并行网关
        4. 第4步：空结束事件
      2. 第二步：idea编码
        1. 第1步：部署、创新（启动）
        2. 第2步：子人工任务一，wangwu，处理，flag = 0
      3. 总结：
        1. 效果：子流程中的终止事件被触发，那么子流程肯定会结束。但主流程中的另外两条分支（用户任务一、用户任务二），还可以继续执行。
  3. 空结束事件，最开始就用的
  4. 结束取消事件
    1. 第一步：UI，绘制流程图
      1. 第1步：空启动事件
      2. 第2步：事务子流程
        1. 第a步：空启动事件
        2. 第b步：人工任务一，zhangsan
        3. 第c步：补偿边界事件 》补偿自动任务，类 = 类路径，Is for compensations（支持补偿）
        4. 第d步：排他网关
          1. 第i步：分支1：人式任务二，lisi，${flag > 0 } 》空结束事件
          2. 第ii步：分支2：${flag <= 0 } ，结束取消事件
      3. 正常结束任务
      4. 取消边界事件 》取消事件结束（类型：自动任务，类 = 类路径）
    2. 第二步：idea编码
      1. 第1步：部署流程
      2. 第2步：创建（启动）流程实例
        1. 第a步：绑定流程变量 flag = 0。
      3. 第3步：人工任务一，zhangsan，处理
    3. 总结：
      1. 效果：
        1. 首先，流转到“结束取消事件”，抛出取消结束事件。
        2. 然后，”取消边界事件“捕获，执行”取消事件结束（类型：自动任务，类 = 类路径）“
        3. 最后，触发“补偿边界事件”，执行“补偿自动任务”。
        4. 所以，在这个流程中：”补偿自动任务“、”取消事件结束“会被执行，而”正常结束“不会被执行。
    4. 注意事项：
      1. 结束取消事件我们只能在事务子流程中使用。
      2. 如果不在事务子流程中使用，那么就会抛出异常。
      3. 在FlowableUI中暂时没有找到这个组件，所以在Eclipse中来绘制。
      4. “补偿边界事件”是人”人工任务一“执行完毕之后，才会被触发。然后，以前我们学的”Xxx边界事件”是在“人工任务一“还没正常地走的情况下，并且条件满足的情况下，才会被抛出、捕获、处理。
  5. 补偿事件：补偿抛出中间事件、补偿边界事件
    1. 概述
      1. 补偿抛出中间事件
        1. 用于抛出补偿事件。
        2. 重点：抛出补偿时，当前范围中所有的活动，包括并行分支上的活动都会被补偿。
      2. 补偿边界事件
        1. 用于：捕获补偿事件
        2. 重点：这里的“边界补偿事件”和上面的几种“边界xxx事件”的区别是：“边界xxx事件”，是在当前的任务Task还没有被处理的情况下，满足某种条件而触发的边界事件。而“边界补偿事件”是在其依附的活动成功完成时激活。
    2. 第一步：UI，绘制流程图：
      1. 第1步：空启动事件
      2. 第2步：并行网关-分支
        1. 第a步：分支1：预订机票-自动，类 = 类路径
          1. 第i步：补偿边界事件
            1. 第ii步：取消预订-补偿器，Is for compensations（支持补偿、可补偿的），类 = 类路径 
        2. 第b步：分支2：微信支付-自动，类 = 类路径
          1. 第i步：边界错误事件
            1. 第ii步：补偿抛出中间事件
              1. 第iii步：空结束事件
      3. 第3步：并行网关-汇集
      4. 第4步：空结束事件
    3. 第二步：idea编码
      1. 第1步：错误定义，修改Xxx.bpmn.xml文件：
      2. 第2步：部署流程
      3. 第3步：创建（启动）流程实例
      4. 第4步：在微信支付-自动，类 = 类路径，抛出错误： 
        public class MyOneDelegate implements JavaDelegate {
    @Override
    public void execute(DelegateExecution execution) {

        System.out.println("微信支付-----》MyOneDelegate" + LocalDateTime.now().toString());
        System.out.println("余额不足....");
        throw  new BpmnError("payFail");
    }
}
    4. 总结：
      1. 首先，如果微信支付-自动，付款失败，产生“错误”。
      2. 其次，“边界错误事件”捕获。
      3. 接着，流转到“补偿抛出中间事件”，产生“补偿”。
      4. 最后，并行分支上的“补偿边界事件”捕获补偿，执行补偿器“取消预订” 
  6. 结束升级事件

五 springboot+flowable ui+mysql

1 flowable-ui项目概述

（1）先看效果

  1. 第一步：创建springboot程序
  2. 第二步：springboot+flowable ui
  3. 第三步：springboot+flowable ui+mysql
  4. 第四步：启动程序
    1. 第1步：在mysql数据库中创建flowable ui相关的表
  5. 第五步：验证
    1. 第1步：浏览器：localhost:8082 admin test
    2. 第2步：各个应用程序的作用
      1. 建模器应用程序
        1. 绘制流程图
      2. 任务应用程序
        1. 部署流程
        2. 创建（启动）流程实例
      3. 管理员应用模式
      4. 身份管理应用程序
  6. 第六步：案例演示
    1. 第1步：建模器应用程序 - 绘制流程图
      1. 第i步：分配候选人
      2. 第ii步：保存和关闭编辑器
    2. 第2步：建模器应用程序 - 应用程序，用于创建一个应用程序
      1. 第i步：包含上一步绘制的流程（图）
      2. 第ii步：保存和关闭编辑器
      3. 第iii步：分布应用程序
    3. 第3步：任务应用程序-流程
      1. 第i步：添加上一步的发布（部署）的流程
      2. 第ii步：点击“启动流程”
      3. 第iii步：显示图，看绘制的流程图，和流程当前的进展
    4. 第4步：任务应用程序-任务
      1. 第i步：选择上一步启动流程的任务
      2. 第ii步：点击“完成”
    5. 第5步：验证
      1. act_re_deplayment
      2. act_hi_actinst
      3. act_ru_task

（2）flowable ui源码下载和run

  1. 第一步：github官网：Release Flowable 6.7.2 release · flowable/flowable-engine · GitHub
    1. 也可以在官网上找下载入口：Flowable: Low-code | Process Automation | Workflow | BPM CMMN | Open Source，learn 》Open Source Community 》填写相关信息 》注册 》还是跳转到github上面来下载
  2. 第二步：下载源码
  3. 第三步：解压文件：Source code（zip）
    1. modules文件夹（包含很多模块）
      1. flowable-ui文件夹（模块）
        1. xxx-springboot-xxx：与springboot整合的
        2. xxx-admin-xxx：admin模块
        3. xxx-idm-xxx：idm模块
        4. xxx-modules-xxx：modules模块
        5. xxx-task-xxx：task模块
  4. 第四步：使用idea打开flowable-ui文件夹（模块）：flowable-ui模块本身就是一个maven项目（从源码中包含pom.xml文件可以看出）。
    1. 第1步：把flowable-ui文件夹（模块）拷贝到硬盘中
    2. 第2步：使用idea打开flowable-ui文件夹（模块）
    3. 第3步：idea会自动编译此flowable-ui项目
  5. 注意：
    1. 以前的版本，4大模块分成4个war包，整合难度大。最新版本，4个模块合在一起，整合难度小。       
    2. flowable-ui模块本身就是一个maven项目（从源码中包含pom.xml文件可以看出）。

 （3）flowable-ui源码介绍

  1. 项目概述
    1. flowable-ui是一个集合项目
      1. 项目结构：包含的模块
        1. war项目（war包），只有一个
          1. flowable-ui-app：要重点关注的子项目
        2. jar项目（jar包）
          1. 剩下的都是jar项目（jar包）。
          2. jar项目属于公共模块，因为jar项目中的类，会被war项目中的代码所使用。
      2. 项目环境
        1. 默认使用的数据库：h2
      3. 详细使用步骤
        1. 第一步：源代码下载
          1. Release Flowable 6.7.2 release · flowable/flowable-engine · GitHub
        2. 第二步：导入idea
        3. 第三步：本地启动
          1. 第一步：启动
            1. org.flowable.ui.application.FlowableUiApplication
          2. 第二步：访问
            1. localhost:8080/flowable-ui admin test
          3. 第三步：操作
            1. 绘制流程图
      4. 扩展
        1. 可以改动其中的任何一个页面
          1. 如隐藏掉：任务应用程序 或 建模器应用程序 或 管理员应用程序 或身份管理应用程序。
        2. 修改使用的数据库：\resources\flowable-default.properties
        3. 修改项目名称：\resources\flowable-default.properties
        4. 修改项目端口：\resources\flowable-default.properties
        5. 修改登录用户名和密码：\resources\flowable-default.properties
  2. 你把这个源码弄过来了，怎么跟我们的实际工作环境做一个整合呢？即在开发过程中跟springboot做一个整合。其实很简单：
    1. 方案1：项目干净（只显示flowable-ui模块）
      1. 第一步：把war项目，flowable-ui单独拿出来看成一个普通的springboot项目（本身就是）。
      2. 第二步：因为剩下的都是jar项目，所以把剩下的项目都编译后打成jar包。
      3. 第三步：在flowable-ui项目中添加上面生成的所有jar包。
    2. 方案2：项目臃肿（显示10几个模块）
      1. 第一步：上面的结构不动
      2. 第二步：直接在上面的结构中做业务开发
    3. 方案3：自动化
      1. 第一步：自定义starter
      2. 第二步：把war项目，flowable-ui单独拿出来看成一个普通的springboot项目（本身就是）。
      3. 第三步：引入自定义starter，自动化地引入所有jar项目所生成的jar包。

2 springboot+flowable ui（流程设计器）+mysql

  1. springboot+flowable ui（流程设计器）
    1. 第一步：创建普通的springboot项目
    2. 第二步：把源码项目flowable-ui-app的pom.xml中的所有<parent>、
      <dependencies>、<build>、<profiles>拉过去
      1. 第1步：编译看看
      2. 第2步：版本报错：     cannot resolve org.flowable:flowable-spring-boot-starter-ui-task:0.0.1
        1. 第a步：解决方案：统一版本<version>6.7.2</version>
      3. 第3步：pom.xml会红色（报错）
        1. <plugins>中有红色：这些都是用不到插件，可去掉
          1. 效果：<plugins>中的全去掉
        2. <pluginManagement>中有红色：这些都是用不到插件，可去掉
          1. <pluginManagement>中的全去掉
      4. 第4步：编译通过
    3. 第三步：把源码项目flowable-ui-app的resource目录下的所有文件都拉过去
    4. 第四步：把源码项目flowable-ui-app的java目录下的所有类拉过去
      1. 第1步：使用新项目的启动类，扫描注解@ComponentScan(basePackages={"org.flowable.ui.application"})
      2. 第2步：拷贝过来的启动类去掉main()，修改类注解为配置类注解@Configuration
    5. 第五步：启动
      1. 端口占用：修改配置文件flowable-default.properties
    6. ​​​​​​​第六步：访问 localhost:8082/flowable-ui admin test，OK
  2. ​​​​​​​整合mysql
    1. ​​​​​​​第一步：加入mysql 8依赖
    2. 第二步：修改flowable-default.properties中的数据库4要素
      1. ​​​​​​​注意：url要加入参数nullCatalogMeansCurrent=true
    3. 第三步：启动，成功
      1. ​​​​​​​第1步：自动在数据库中创建n张表，并把登录的用户名和密码（admin test）写入数据库用户表中
    4. 第四步：访问，成功
    5. 第五步：操作
      1. ​​​​​​​创建流程
      2. 测试流程​​​​​​​
aiwokache
关注
专栏目录
flowable工作流看这一篇就够了（进阶篇 上）
qq_38196449的博客
12-30 1253
循环设定启动事件：根据设置循环启动流程实例。中间事件：即使设置了循环时间也只会触发异常。边界事件：即使设置了循环时间也只会触发异常。
flowable工作流看这一篇就够了（进阶篇 下）
qq_38196449的博客
12-31 1604
多实例活动是为业务流程中的某个步骤定义重复的一种方式。在编程概念中，多实例与for each结构相匹配：它允许对给定集合中的每个项目按顺序或并行地执行某个步骤或甚至一个完整的子流程。多实例是一个有额外属性（所谓的 “多实例特性”）的常规活动，它将导致该活动在运行时被多次执行。以下活动可以成为多实例活动。Service Task 服务任务Send Task 发送任务User Task 用户任务Business Rule Task 业务规则任务Script Task 脚本任务。
Flowable多实例任务
没想到你是这种薯片的博客
09-08 2839
1. 可视化编辑器编辑 2. XML文件 <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:flowable="http:
FlowableUI 与 IDEA 插件：流程设计与开发的完美结合
最新发布
gitblog_06520的博客
09-20 842
FlowableUI 与 IDEA 插件：流程设计与开发的完美结合 FlowableFlowableUI使用以及在IDEA使用flowable插件二 项目地址: https://gitcode.com/Resource-Bund...
flowable bpmnxml中 completionCondition的含义
Ye7073的博客
05-23 299
八：Flowable串行流程移动活动
人不风流枉少年
11-14 578
串行流程是指简单的一条线的流程，流程中如果包含会签排它网关也算串行流程。向前移动foreward。向后移动back。直接跳转到最后一个结束节点end。串行流程节点移动有三个API，每个API都可以前进后退结束节点。// 方式一// 方式二：只是目标节点是个List而已// 方式三：通过指定执行id。
flowable 特殊多实例并行例子解决方案
Mr_王小峰的博客
04-24 4735
场景描述： 由于公司需要在流程图中明确的显示不同部门的流程情况，而这些部门是并行的，最后要有系统自动判断这些节点的审核结果给出一个最终的结果，来确定流程的走向，如果是单个审核节点的话可以使用多实例(设置多实例结束条件即可)，但是通常业务中包含着不止一个节点，这种情况我们可以使用子流程解决，也可以使用下边我要介绍的方案,这个方案我只画了每个并行节点的一个审核，但是实际通常会有多个，我只做例子讲解，...
flowable工作流会签的基本配置
jun2571的博客
03-27 2313
flowable activiti 工作流
flowable进阶使用
weixin_48093895的博客
10-21 677
flowable进阶3步，初始化，审核，获取待审核信息
【第十三篇】Flowable事件-消息事件
波波烤鸭的博客
04-07 3549
Flowable消息事件   消息事件（message event），是指引用具名消息的事件。消息具有名字与载荷。与信号不同，消息事件只有一个接收者 1.启动事件   消息启动事件，也就是我们通过接收到某些消息后来启动流程实例，比如接收到了一封邮件，一条短信等，具体通过案例来讲解 我们需要先定义一个消息 然后在消息开始节点出引用 然后通过代码来处理，部署和启动 /** * Deploy */ @Test void testDeploy() throws E.
Flowable进阶学习（十）定时器、ServiceTask服务任务、ScriptTask脚本任务
Huathy的博客
02-11 4866
可以通过给流程定义设置一个启动时间。这个流程就会延迟激活。在激活之前，无法启动该流程。部署流程。
Flowable-多实例
liuwenjun05101的博客
08-08 3662
BPMN 中的多实例活动是实现循环的方式之一。虽然循环总是可以通过活动连接网关将后续顺序流指向自己或前面的活动来实现，但是多实例活动是可以在某些情况下实现起来更简单。如果想让某些特定的活动重复执行多次，我们可以将该活动设置为多实例，让其按照配置来执行相应的次数。
流程引擎（flowable）之会签相关
H_g_y_的博客
09-29 4328
会签
flowable多实例并行审核
qq_42715450的博客
09-01 5531
flowable多实例并行审核。
flowable多实例任务注意事项
happyxin_的博客
07-12 3319
多实例类型：Parallel->并行多实例 指分配给多个用户之后，只要其中一个用户完成即可下一步 Sequential->串行多实例，值分配给多个用户之后，必须一个一个去完成才能进入下一步节点 配置信息： collection（集合）： 传入List参数,一般为用户ID集合 elementVariable（元素变量）：List中单个参数的名称 loopCardinality（基数）：List循环次数 isSequential：是否串并行 completionCondition（完成条件）：任务出口条件 nr
Flowable 6.7.X 学习笔记（二） FlowableUI 和IDEA插件
qq_51484868的博客
01-15 3013
Flowable 6.7.X 学习笔记（二） FlowableUI 和IDEA插件
Activiti并行网关和串行网关区别
四十二度科技
08-04 5648
转载出处来自分享牛http://blog.csdn.net/qq_30739519) Activiti多实例任务有并行、串行区分。 并行代表同时进行，如把任务分给5个人来处理，这5个人同时会收到任务，并且可以同时处理，不受各自的影响。 串行代表工作或任务由一个人完成后，再由另一个人去处理，直至全部完成，每个任务依赖于前一个任务完成。   我们在使用activiti 工作流引擎的时候，最常...
flowable多任务实现会签、或签
wangwcy的博客
05-14 4931
做工作流，基本会遇到会签、或签的需求。而flowable是通过多任务方式来实现的。
flowable 多实例流程
qq_36760953的博客
06-11 4184
<?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值