Camunda 7.16 与 Spring Boot 3.x 集成实战：5分钟完成流程引擎嵌入与 REST API 调用

weixin_36250541

545人浏览 · 2026-07-09 11:57:19

weixin_36250541 · 2026-07-09 11:57:19 发布

Camunda 7.16 与 Spring Boot 3.x 集成实战：5分钟完成流程引擎嵌入与 REST API 调用

在当今企业级应用开发中，业务流程自动化已成为提升效率的关键。Camunda作为一款轻量级、高性能的开源工作流引擎，与Spring Boot的完美结合，能够为开发者提供快速实现复杂业务流程的能力。本文将带您从零开始，在Spring Boot 3.x项目中集成Camunda 7.16社区版，并通过REST API快速启动第一个流程实例。

1. 环境准备与依赖配置

首先创建一个全新的Spring Boot 3.x项目，推荐使用Spring Initializr（https://start.spring.io）生成项目骨架。确保选择的Java版本为17或以上，这是Spring Boot 3.x的最低要求。

在 pom.xml 中添加Camunda的核心依赖：

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Camunda核心依赖 -->
    <dependency>
        <groupId>org.camunda.bpm.springboot</groupId>
        <artifactId>camunda-bpm-spring-boot-starter</artifactId>
        <version>7.16.0</version>
    </dependency>
    
    <!-- 可选：REST API支持 -->
    <dependency>
        <groupId>org.camunda.bpm.springboot</groupId>
        <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
        <version>7.16.0</version>
    </dependency>
    
    <!-- 数据库支持（以H2为例） -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

提示：Camunda需要数据库支持来持久化流程定义和实例数据。在生产环境中，建议使用MySQL、PostgreSQL等更稳定的数据库。

2. 基础配置

在 application.yml 中添加Camunda的基本配置：

spring:
  datasource:
    url: jdbc:h2:mem:camunda;DB_CLOSE_DELAY=-1
    username: sa
    password: 
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: update

camunda:
  bpm:
    admin-user:
      id: admin
      password: admin
    filter:
      create: All tasks
    database:
      schema-update: true
    auto-deployment-enabled: true

关键配置说明：

配置项	说明	推荐值
spring.datasource.url	数据库连接URL	根据实际数据库调整
camunda.bpm.admin-user	管理员账号	生产环境务必修改
camunda.bpm.database.schema-update	自动更新数据库Schema	true(开发)/false(生产)
camunda.bpm.auto-deployment-enabled	自动部署流程定义	true

3. 部署第一个BPMN流程

在 src/main/resources 目录下创建 processes 文件夹，然后新建一个简单的请假流程 leave-request.bpmn ：

<?xml version="1.0" encoding="UTF-8"?>
<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" 
                  xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" 
                  id="Definitions_1" 
                  targetNamespace="http://bpmn.io/schema/bpmn">
  <bpmn:process id="leaveRequest" name="Leave Request Process" isExecutable="true">
    <bpmn:startEvent id="StartEvent_1">
      <bpmn:outgoing>SequenceFlow_1</bpmn:outgoing>
    </bpmn:startEvent>
    <bpmn:sequenceFlow id="SequenceFlow_1" sourceRef="StartEvent_1" targetRef="Task_1" />
    <bpmn:userTask id="Task_1" name="Submit Leave Request">
      <bpmn:incoming>SequenceFlow_1</bpmn:incoming>
      <bpmn:outgoing>SequenceFlow_2</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="SequenceFlow_2" sourceRef="Task_1" targetRef="Task_2" />
    <bpmn:userTask id="Task_2" name="Manager Approval">
      <bpmn:incoming>SequenceFlow_2</bpmn:incoming>
      <bpmn:outgoing>SequenceFlow_3</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="SequenceFlow_3" sourceRef="Task_2" targetRef="EndEvent_1" />
    <bpmn:endEvent id="EndEvent_1">
      <bpmn:incoming>SequenceFlow_3</bpmn:incoming>
    </bpmn:endEvent>
  </bpmn:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <!-- 省略图形布局定义 -->
  </bpmndi:BPMNDiagram>
</bpmn:definitions>

启动应用后，Camunda会自动检测并部署 processes 目录下的BPMN文件。您可以通过以下URL访问Camunda的管理界面：

Cockpit: http://localhost:8080/camunda/app/cockpit/default/
Tasklist: http://localhost:8080/camunda/app/tasklist/default/

4. 通过Java API操作流程引擎

创建一个服务类来封装常用的流程操作：

@Service
public class CamundaService {
    
    @Autowired
    private RuntimeService runtimeService;
    
    @Autowired
    private TaskService taskService;
    
    @Autowired
    private RepositoryService repositoryService;
    
    // 启动流程实例
    public String startProcess(String processDefinitionKey, Map<String, Object> variables) {
        ProcessInstance instance = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
        return instance.getId();
    }
    
    // 查询用户任务
    public List<Task> getUserTasks(String assignee) {
        return taskService.createTaskQuery()
                .taskAssignee(assignee)
                .list();
    }
    
    // 完成任务
    public void completeTask(String taskId, Map<String, Object> variables) {
        taskService.complete(taskId, variables);
    }
    
    // 部署BPMN文件
    public Deployment deployBpmnFile(String resourceName, InputStream inputStream) {
        return repositoryService.createDeployment()
                .addInputStream(resourceName, inputStream)
                .deploy();
    }
}

5. 通过REST API操作流程引擎

Camunda提供了完整的REST API支持。以下是使用Spring的RestTemplate调用API的示例：

@RestController
@RequestMapping("/api/process")
public class ProcessController {
    
    @Autowired
    private RestTemplate restTemplate;
    
    private static final String CAMUNDA_ENGINE_URL = "http://localhost:8080/engine-rest";
    
    // 启动流程实例
    @PostMapping("/start/{processDefinitionKey}")
    public ResponseEntity<?> startProcess(
            @PathVariable String processDefinitionKey,
            @RequestBody Map<String, Object> variables) {
        
        String url = CAMUNDA_ENGINE_URL + "/process-definition/key/" + 
                    processDefinitionKey + "/start";
        
        Map<String, Object> request = new HashMap<>();
        request.put("variables", variables);
        
        return restTemplate.postForEntity(url, request, String.class);
    }
    
    // 查询任务
    @GetMapping("/tasks")
    public ResponseEntity<?> getTasks(@RequestParam String assignee) {
        String url = CAMUNDA_ENGINE_URL + "/task?assignee=" + assignee;
        return restTemplate.getForEntity(url, String.class);
    }
    
    // 完成任务
    @PostMapping("/complete/{taskId}")
    public ResponseEntity<?> completeTask(
            @PathVariable String taskId,
            @RequestBody Map<String, Object> variables) {
        
        String url = CAMUNDA_ENGINE_URL + "/task/" + taskId + "/complete";
        
        Map<String, Object> request = new HashMap<>();
        request.put("variables", variables);
        
        return restTemplate.postForEntity(url, request, String.class);
    }
}

6. 测试与验证

创建一个测试Controller来验证我们的集成：

@RestController
@RequestMapping("/test")
public class TestController {
    
    @Autowired
    private CamundaService camundaService;
    
    @PostMapping("/leave")
    public String applyLeave(@RequestBody Map<String, Object> request) {
        // 启动请假流程
        String processInstanceId = camundaService.startProcess(
            "leaveRequest", 
            Map.of(
                "employee", request.get("employee"),
                "days", request.get("days"),
                "reason", request.get("reason")
            )
        );
        
        return "Leave process started with ID: " + processInstanceId;
    }
    
    @GetMapping("/tasks/{assignee}")
    public List<Map<String, Object>> getTasks(@PathVariable String assignee) {
        return camundaService.getUserTasks(assignee).stream()
            .map(task -> Map.of(
                "id", task.getId(),
                "name", task.getName(),
                "created", task.getCreateTime()
            ))
            .collect(Collectors.toList());
    }
    
    @PostMapping("/complete/{taskId}")
    public String completeTask(
            @PathVariable String taskId,
            @RequestBody Map<String, Object> decision) {
        
        camundaService.completeTask(taskId, decision);
        return "Task " + taskId + " completed";
    }
}

使用curl或Postman测试API：

# 启动请假流程
curl -X POST http://localhost:8080/test/leave \
-H "Content-Type: application/json" \
-d '{"employee":"john","days":3,"reason":"Family event"}'

# 查询john的任务
curl http://localhost:8080/test/tasks/john

# 完成提交请假申请任务
curl -X POST http://localhost:8080/test/complete/{taskId} \
-H "Content-Type: application/json" \
-d '{"approved":true,"comments":"Approved"}'

7. 高级配置与优化

对于生产环境，还需要考虑以下配置：

数据库连接池配置 （在application.yml中）：

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 30000
      max-lifetime: 1800000
      connection-timeout: 30000

异步执行配置 ：

@Configuration
public class CamundaAsyncConfig {
    
    @Bean
    public ProcessEnginePlugin asyncConfiguration() {
        return new AbstractProcessEnginePlugin() {
            @Override
            public void preInit(ProcessEngineConfigurationImpl configuration) {
                configuration.setJobExecutorActivate(true);
                configuration.setJobExecutorDeploymentAware(true);
            }
        };
    }
}

性能监控配置 ：

@Configuration
public class CamundaMetricsConfig {
    
    @Bean
    public ProcessEnginePlugin metricsPlugin() {
        return new MetricsPlugin();
    }
    
    @Bean
    public MeterRegistry meterRegistry() {
        return new SimpleMeterRegistry();
    }
}

通过以上步骤，您已经成功在Spring Boot 3.x项目中集成了Camunda 7.16，并实现了基本的流程管理和REST API调用。这种集成方式既保持了Spring Boot的简洁性，又充分利用了Camunda强大的流程引擎能力。