事件
登录
标签搜索
侧边栏壁纸
博主昵称
蘇阿細

  • 累计撰写 388 篇文章
  • 累计收到 4 条评论
Camunda 工作流

事件

suaxi
suaxi
2024-08-05 / 0 评论 / 284 阅读 / 正在检测是否收录...

事件（event）通常用于为流程生命周期中发生的事情建模，事件总是图形化为圆圈。在BPMN2.0中，主要分为：捕获（catching）与抛出（throwing）事件。

  • 捕获：当流程执行到达这个事件时，会等待直到触发器执行，触发器类型由XML中的类型声明定义
  • 抛出：当流程执行到达这个事件时，会触发对应的触发器

1. 定时器事件

定时触发相关的事件：定时器启动事件、定时器捕获中间事件、定时器边界事件

（1）定时器启动事件

定时器启动事件（timer start event）在指定的时间创建流程实例，可用于流程只需要启动一次，或流程需要在特定的时间间隔重复启动等场景。

其中需要注意：

  • 子流程不能有定时器启动事件
  • 在流程部署时就开始计时，不需要单独调用 startProcessInstanceByxxx() 方法来启动，当调用该方法时，会在定时启动的基础上再额外启动一个对应的流程
  • 当部署带有定时器启动事件的流程更新版本时，上一个版本的定时器作业会被清除，即Camunda流程引擎不希望旧版本的流程仍然自动启动更新之后的新版本流程实例
a. Date 固定时间点触发

ISO8601相关内容：https://zh.wikipedia.org/wiki/ISO_8601

1.1事件-定时器-启动事件-Date固定时间点.png

当该流程部署后，在任务表中能看到对应的固定时间点启动事件任务

1.2事件-定时器-启动事件-Date固定时间点.png

b. Duration 间隔时间触发

2.1事件-定时器-启动事件-Duration间隔时间.png

同理，流程部署后可在任务表看到对应的任务记录

2.2事件-定时器-启动事件-Duration间隔时间.png

c. Cycle重复多次触发

3.1事件-定时器-启动事件-Cycle重复多次触发.png


3.2事件-定时器-启动事件-Cycle重复多次触发.png

注：timeCycle 表达式包含可选属性 EndDate ，即 R3/PT1M/${EndDate} 表示执行过程中到达 EndDate 指定的时间时应用停止运行，并为该任务执行其他作业

（2）定时器中间事件

4.1事件-定时器-捕获中间事件.png


当组长审批完成之后，流程引擎会在任务记录表中创建对应的中间捕获事件对应的任务记录

4.2事件-定时器-捕获中间事件.png


4.3事件-定时器-捕获中间事件.png

（3）定时器边界事件

5.1事件-定时器-边界事件.png


流程启动后等待一分钟不进行任何操作，等待边界事件触发

5.2事件-定时器-边界事件.png


5.3事件-定时器-边界事件.png


如果在流程启动后正常进行组长审批，则边界事件不会触发，流程正常走向“项目经理1”审批

2. 消息事件

（1）启动事件

在接收到某些消息后来启动对应的流程实例，消息类型包括不限于邮件、短信等等

6.事件-消息事件-启动事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/7/24 21:53
 * @Description
 */
@SpringBootTest
public class FlowEventMessageTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-消息事件-启动事件")
                .addClasspathResource("flow/18.事件-消息事件-启动事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startMessageFlow() {
        runtimeService.startProcessInstanceByMessage("MsgStartEventMsg");
    }
}

注：启动流程时hi，可以通过常用的方式来启动，也可以通过对应的 startProcessInstanceByMessage() 方法启动

（2）中间事件

中间捕获事件即在流程运行过程中需要消息来触发的场景

7.事件-消息事件-中间捕获事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/7/24 21:53
 * @Description
 */
@SpringBootTest
public class FlowEventMessageTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-消息事件-中间捕获事件")
                .addClasspathResource("flow/19.事件-消息事件-中间捕获事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startMessageFlow() {
        String processInstanceId = "Process_14g0sj6:1:2f885ce8-49c7-11ef-9019-a8a1592cf182";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void complete() {
        String taskId = "612049bf-49c7-11ef-b518-a8a1592cf182";
        taskService.complete(taskId);
    }

    @Test
    public void sendMessageTest() {
        runtimeService.messageEventReceived("MsgMiddleCatchEventMsg", "fcbae170-49c7-11ef-8c1d-a8a1592cf182");
    }
}

注：当组长正常审批完成后，需要发送对应的消息来触发流程图中所画的中间事件，流程才会继续往后走

（3）边界事件

8.事件-消息事件-边界事件.png


同理定时器中的边界事件，当流程启动后，在组长审批前发送消息，即可触发对应的消息边界事件，走向新的流程方向（项目经理2审批）

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/7/24 21:53
 * @Description
 */
@SpringBootTest
public class FlowEventMessageTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-消息事件-边界事件")
                .addClasspathResource("flow/20.事件-消息事件-边界事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startMessageFlow() {
        String processInstanceId = "Process_0ub5i8b:1:b4e5124e-49c9-11ef-9973-a8a1592cf182";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void sendMessageTest() {
        runtimeService.messageEventReceived("MsgBoundaryEventMsg", "c910f373-49c9-11ef-b0ae-a8a1592cf182");
    }
}


3. 错误事件

（1）开始事件

错误启动事件（error start event），可用于触发事件子流程（Event Sub-Process），需注意错误启动事件不能用于启动流程实例

流程图

9.1事件-错误事件-开始事件.png


9.2事件-错误事件-开始事件.png

JavaDelegate

package com.sw.camundademo.delegate;

import lombok.extern.slf4j.Slf4j;
import org.camunda.bpm.engine.delegate.BpmnError;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;

/**
 * @Author Suaxi
 * @Date 2024/7/31 21:42
 * @Description
 */
@Slf4j
public class ErrorEventStartDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) throws Exception {
        log.info("ErrorEventStartDelegate执行了...");
        //抛出的信息必须与设置的error code对应
        throw new BpmnError("ErrorEventStartMsg");
    }
}


测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/7/31 21:49
 * @Description
 */
@SpringBootTest
public class FlowEventErrorTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-错误事件-开始事件")
                .addClasspathResource("flow/21.事件-错误事件-开始事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startErrorFlow() {
        String processInstanceId = "Process_1jtpd2d:1:26709f49-4f44-11ef-a77c-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }
    
}

当启动流程，服务任务绑定的 JavaDelegate 抛出错误后，会启动对应的错误启动事件子流程

9.3事件-错误事件-开始事件.png


9.4事件-错误事件-开始事件.png

（2）边界事件

当子流程执行过程中对外抛出了相关的异常，在流程中设置的错误边界事件就能捕获到相关的事件，然后做对应的处理

流程图，此处以服务任务绑定 JavaDelegate 为例

10.1事件-错误事件-边界事件.png

JavaDelegate

package com.sw.camundademo.delegate;

import lombok.extern.slf4j.Slf4j;
import org.camunda.bpm.engine.delegate.BpmnError;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;

/**
 * @Author Suaxi
 * @Date 2024/8/4 20:43
 * @Description
 */
@Slf4j
public class ErrorEventBoundaryDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) throws Exception {
        log.info("ErrorEventBoundaryDelegate执行了...");
        //抛出的信息必须与设置的error code对应
        throw new BpmnError("ErrorEventBoundaryMsg");
    }
}


当流程启动，对应的服务任务绑定的 JavaDelegate 执行时，抛出了对应的错误及 error code，则会触发对应的错误边界事件

10.2事件-错误事件-边界事件.png

触发后，流程进入对应的节点

10.3事件-错误事件-边界事件.png

4. 信号事件

（1）开始事件

通过信号来启动流程实例

11.1事件-信号事件-开始事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/8/5 21:23
 * @Description
 */
@SpringBootTest
public class FlowEventSignalTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-信号事件-开始事件")
                .addClasspathResource("flow/23.事件-信号事件-开始事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    /**
     * 通过信号触发启动流程实例
     */
    @Test
    public void signalReceive() {
        runtimeService.signalEventReceived("signalStartEvent");
    }

}


（2）中间捕获事件

当流程实例启动后，会阻塞在信号中间捕获事件处，等待信号触发后才会执行后续的流程

12.1事件-信号事件-中间捕获事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/8/5 21:23
 * @Description
 */
@SpringBootTest
public class FlowEventSignalTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-信号事件-中间捕获事件")
                .addClasspathResource("flow/24.事件-信号事件-中间捕获事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_1x6a9fh:1:5eb47e10-532f-11ef-ba7f-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    /**
     * 通过信号触发中间捕获事件
     */
    @Test
    public void signalReceive() {
        runtimeService.signalEventReceived("signalMiddleCatchEvent");
    }

}



当执行完组长审批后，流程会阻塞在中间捕获事件处，直到信号 signalMiddleCatchEvent 触发，才会执行后续的流程

12.2事件-信号事件-中间捕获事件.png

（3）中间抛出事件

在流程执行的过程中，某个节点抛出了对应的信号，触发了对应的信号捕获事件

13.1事件-信号事件-中间抛出事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/8/5 21:23
 * @Description
 */
@SpringBootTest
public class FlowEventSignalTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-信号事件-中间抛出事件")
                .addClasspathResource("flow/25.事件-信号事件-中间抛出事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_1tpyp0e:1:fab9fb72-5331-11ef-8386-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void complete() {
        taskService.complete("2b789f00-5332-11ef-98d2-10ffe00abd05");
    }
}

注：当流程实例启动后，应先执行组长2审批，让对应的中间捕获事件流程处于阻塞的状态，在组长1审批完成后，且抛出信号 signalMiddleThrowEvent 时，才会进入项目经理审批流程，反之只会进入到人事审批流程

13.2事件-信号事件-中间抛出事件.png

（4）边界事件

14.1事件-信号事件-边界事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/8/5 21:23
 * @Description
 */
@SpringBootTest
public class FlowEventSignalTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-信号事件-边界事件")
                .addClasspathResource("flow/26.事件-信号事件-边界事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_12diz27:1:5e6bea56-5334-11ef-8213-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void complete() {
        taskService.complete("9328e474-5334-11ef-8f89-10ffe00abd05");
    }

    /**
     * 通过信号触发边界事件
     */
    @Test
    public void signalReceive() {
        runtimeService.signalEventReceived("signalBoundaryEvent");
    }

}

注：启动流程后，如果在组长审批的过程中没有发送信号 signalBoundaryEvent ，则流程会进入到项目经理审批节点，反之，如果发送了信号，则会被组长审批节点中阻塞等待的信号边界事件捕获，进入到人事审批节点中

5. 结束事件

（1）错误结束事件

当流程执行到达错误结束事件（error end event）时，当前分支结束执行，并抛出错误，这个错误可以由错误边界、中间事件捕获，如果未匹配到对应的错误边界事件，将会抛出异常
15.1事件-结束事件-错误结束事件.png


测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @Author Suaxi
 * @Date 2024/8/6 21:10
 * @Description
 */
@SpringBootTest
public class FlowEventEndTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-结束事件-错误结束事件")
                .addClasspathResource("flow/27.事件-结束事件-错误结束事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_00xytj8:1:e8902c02-53f5-11ef-9c4a-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void complete() {
        taskService.complete("9328e474-5334-11ef-8f89-10ffe00abd05");
    }

}

当流程执行到人事审批时，此时设置流程变量 flag = true，流程走向为：

15.2事件-结束事件-错误结束事件.png

设置 flag = false，流程走向为：

15.3事件-结束事件-错误结束事件.png

（2）中断结束事件

中断结束事件也称为终止结束事件，主要用于对流程的终止。当在一个流程实例的执行过程中，需要提前或因为其他原因中断这个运行中的流程，可以使用这个事件来处理。

当在流程实例的层面处理，则整个流程都会被中断；当在子流程中处理，则当前作用和作用域内的所有内部流程都会被中断

  • 案例一：没有子流程的中断结束事件案例

16.1事件-结束事件-中断结束事件.png


测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
* @Author Suaxi
* @Date 2024/8/6 21:10
* @Description
*/
@SpringBootTest
public class FlowEventEndTest {

  @Autowired
  private RepositoryService repositoryService;

  @Autowired
  private RuntimeService runtimeService;

  @Autowired
  private TaskService taskService;

  @Test
  public void deploy() {
      Deployment deploy = repositoryService.createDeployment()
              .name("事件-结束事件-中断结束事件")
              .addClasspathResource("flow/28.事件-结束事件-中断结束事件.bpmn")
              .deploy();
      System.out.println(deploy.getId());
  }

  @Test
  public void startFlow() {
      String processInstanceId = "Process_1g4qego:1:9f795b0c-53f8-11ef-a302-10ffe00abd05";
      runtimeService.startProcessInstanceById(processInstanceId);
  }

}

启动流程后，在执行组长3审批时，如果设置的流程变量flag = true，则按照正常的顺序走，反之如果设置的flag = false，则流程直接中断，可在历史流程实例表中查询到相关的数据

16.2事件-结束事件-中断结束事件.png

  • 案例二：有子流程的情况下

16.3事件-结束事件-中断结束事件.png


测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

/**
* @Author Suaxi
* @Date 2024/8/6 21:10
* @Description
*/
@SpringBootTest
public class FlowEventEndTest {

  @Autowired
  private RepositoryService repositoryService;

  @Autowired
  private RuntimeService runtimeService;

  @Autowired
  private TaskService taskService;

  @Test
  public void deploy() {
      Deployment deploy = repositoryService.createDeployment()
              .name("事件-结束事件-中断结束事件（有子流程）")
              .addClasspathResource("flow/29.事件-结束事件-中断结束事件.bpmn")
              .deploy();
      System.out.println(deploy.getId());
  }

  @Test
  public void startFlow() {
      String processInstanceId = "Process_1xxaxsj:1:8315add5-53fa-11ef-8ee5-10ffe00abd05";
      runtimeService.startProcessInstanceById(processInstanceId);
  }

  @Test
  public void complete() {
      Map<String, Object> variables = new HashMap<>();
      variables.put("flag", false);
      taskService.complete("213ce445-53fb-11ef-b9de-10ffe00abd05", variables);
  }

}

启动流程后，在执行组长3审批时，如果设置的流程变量flag = true，则按照正常的顺序走，反之如果设置的flag = false，则当前子流程直接中断，但不会影响组长1审批、组长2审批的执行

16.4事件-结束事件-中断结束事件.png

（3）取消结束事件

取消结束事件（cancel end event）只能与BPMN事务子流程一起使用，当流程执行到达取消结束事件时，会抛出取消事件，且必须有取消边界事件（cancel boundary event）捕获，取消边界事件将取消事务，同时触发补偿

17.1事件-结束事件-取消结束事件.png

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author Suaxi
 * @Date 2024/8/6 21:10
 * @Description
 */
@SpringBootTest
public class FlowEventEndTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-结束事件-取消结束事件")
                .addClasspathResource("flow/30.事件-结束事件-取消结束事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_16jqg12:1:74f44003-53fd-11ef-8cb6-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

    @Test
    public void complete() {
        Map<String, Object> variables = new HashMap<>();
        variables.put("flag", false);
        taskService.complete("88a91c26-53fd-11ef-9b2f-10ffe00abd05", variables);
    }

}

启动流程后，在执行组长审批时，如果设置的流程变量flag = true，则按照正常的顺序（组长审批-项目经理审批-人事审批）走，反之设置的falg = false 时，流程会执行到开发经理审批补偿边界事件中

17.2事件-结束事件-取消结束事件.png


当开发经理审批完成时，触发取消边界事件总经理审批

17.3事件-结束事件-取消结束事件.png

（4）补偿事件

通过补偿达到控制业务流程的目的，此处以购票支付失败为例

18.1事件-结束事件-补偿事件.png

OrderTicketDelegate

package com.sw.camundademo.delegate;

import lombok.extern.slf4j.Slf4j;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;

/**
 * @Author Suaxi
 * @Date 2024/8/6 22:26
 * @Description
 */
@Slf4j
public class OrderTicketDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) throws Exception {
        log.info("执行OrderTicketDelegate，车票预定成功...");
    }
}

CompensationMiddleThrowEventDelegate

package com.sw.camundademo.delegate;

import lombok.extern.slf4j.Slf4j;
import org.camunda.bpm.engine.delegate.BpmnError;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;

/**
 * @Author Suaxi
 * @Date 2024/8/6 22:28
 * @Description
 */
@Slf4j
public class CompensationMiddleThrowEventDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) throws Exception {
        log.info("执行CompensationMiddleThrowEventDelegate，支付失败...");
        throw new BpmnError("compensationMiddleThrowEvent");
    }
}

测试

package com.sw.camundademo;

import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.repository.Deployment;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author Suaxi
 * @Date 2024/8/6 21:10
 * @Description
 */
@SpringBootTest
public class FlowEventEndTest {

    @Autowired
    private RepositoryService repositoryService;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Test
    public void deploy() {
        Deployment deploy = repositoryService.createDeployment()
                .name("事件-结束事件-补偿事件")
                .addClasspathResource("flow/31.事件-结束事件-补偿事件.bpmn")
                .deploy();
        System.out.println(deploy.getId());
        repositoryService.deleteDeployment("d8790e22-5400-11ef-a7c9-10ffe00abd05");
    }

    @Test
    public void startFlow() {
        String processInstanceId = "Process_0up7x7t:2:954f574f-5401-11ef-a09c-10ffe00abd05";
        runtimeService.startProcessInstanceById(processInstanceId);
    }

}

启动流程后，预定车票和支付绑定的 javaDelegate 同步执行

18.2事件-结束事件-补偿事件.png


流程进入到对应的取消订单补偿节点

18.3事件-结束事件-补偿事件.png

0
Camunda
版权属于： suaxi
本文链接： https://www.wangchouchou.com/997.html
作品采用： 《 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 》许可协议授权
相关推荐
动态表单
动态表单
 任务回退
任务回退
 多人会签
多人会签
 网关
网关

评论 (0)

取消