SpringBoot+Activiti实现高效自动化审批流程-代码聚汇网

SpringBoot+Activiti实现高效自动化审批流程

AngstEssenSeele

1. 为什么我们需要自动化审批流程？

作为一名Java开发者，我经历过太多繁琐的请假审批流程。记得有一次，我为了请半天病假，需要打印纸质申请表，找三个领导签字，最后还要扫描存档。整个过程花了2小时，而我的病假其实只需要4小时。这种低效的流程在传统企业尤为常见，但即使在科技公司，很多团队仍然在使用邮件或聊天工具进行人工审批，效率低下且难以追踪。

SpringBoot结合工作流引擎（如Activiti）可以完美解决这个问题。通过简单的配置和几行代码，我们就能实现：

自动化的审批流程路由
电子化的申请和审批记录
可视化的流程监控
灵活的流程调整机制

实际案例：在我主导的一个项目中，使用SpringBoot+Activiti将原本平均需要1.5天的审批流程缩短到了30分钟内完成，员工满意度提升了40%。

2. 环境准备与基础配置

2.1 创建SpringBoot项目

使用IDEA或Eclipse创建一个基础的SpringBoot项目，我推荐使用Spring Initializr（https://start.spring.io/）快速生成项目骨架。关键依赖包括：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-spring-boot-starter</artifactId>
    <version>7.1.0.M6</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

2.2 数据库配置

虽然示例使用H2内存数据库，但生产环境建议使用MySQL或PostgreSQL。在application.properties中添加：

properties复制spring.datasource.url=jdbc:h2:mem:activiti;DB_CLOSE_DELAY=1000
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

踩坑提醒：Activiti 7.x默认使用SpringBoot 2.x，如果使用SpringBoot 3.x需要额外处理兼容性问题。我曾在一个项目中因此浪费了半天时间排查启动失败的问题。

3. 设计请假审批流程（BPMN）

3.1 创建BPMN流程图

在resources/processes目录下创建leave-approval.bpmn20.xml文件：

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:activiti="http://activiti.org/bpmn"
             targetNamespace="http://www.activiti.org/test">
    
    <process id="leaveApproval" name="Leave Approval Process">
        <startEvent id="startEvent"/>
        <userTask id="applyLeave" name="Apply for Leave" 
                 activiti:assignee="${applicant}"/>
        <sequenceFlow sourceRef="startEvent" targetRef="applyLeave"/>
        
        <userTask id="managerApproval" name="Manager Approval"
                 activiti:assignee="${manager}"/>
        <sequenceFlow sourceRef="applyLeave" targetRef="managerApproval"/>
        
        <exclusiveGateway id="decisionGateway"/>
        <sequenceFlow sourceRef="managerApproval" targetRef="decisionGateway"/>
        
        <sequenceFlow sourceRef="decisionGateway" targetRef="hrRecord">
            <conditionExpression xsi:type="tFormalExpression">
                ${approved}
            </conditionExpression>
        </sequenceFlow>
        
        <sequenceFlow sourceRef="decisionGateway" targetRef="rejectEnd">
            <conditionExpression xsi:type="tFormalExpression">
                ${!approved}
            </conditionExpression>
        </sequenceFlow>
        
        <userTask id="hrRecord" name="HR Record"/>
        <sequenceFlow sourceRef="hrRecord" targetRef="endEvent"/>
        
        <endEvent id="rejectEnd" name="Rejection End"/>
        <endEvent id="endEvent"/>
    </process>
</definitions>

3.2 流程说明

这个流程模拟了一个典型的请假审批场景：

员工发起请假申请
直属经理审批
根据审批结果：
- 通过：HR备案后流程结束
- 拒绝：直接结束流程

设计技巧：在实际项目中，我通常会为${manager}实现动态分配逻辑，比如从组织架构服务中获取真实汇报关系，而不是硬编码在流程定义中。

4. 实现核心业务逻辑

4.1 请假申请服务

创建LeaveApplicationService.java：

java复制@Service
public class LeaveApplicationService {
    @Autowired
    private RuntimeService runtimeService;
    
    @Autowired
    private TaskService taskService;
    
    public String startLeaveProcess(String applicant, String manager, 
                                  LocalDate startDate, LocalDate endDate, 
                                  String reason) {
        Map<String, Object> variables = new HashMap<>();
        variables.put("applicant", applicant);
        variables.put("manager", manager);
        variables.put("startDate", startDate);
        variables.put("endDate", endDate);
        variables.put("reason", reason);
        variables.put("approved", false); // 默认值
        
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(
            "leaveApproval", variables);
        
        return processInstance.getId();
    }
    
    public void completeManagerApproval(String taskId, boolean approved) {
        Map<String, Object> variables = new HashMap<>();
        variables.put("approved", approved);
        taskService.complete(taskId, variables);
    }
}

4.2 控制器层

创建LeaveController.java：

java复制@RestController
@RequestMapping("/api/leave")
public class LeaveController {
    @Autowired
    private LeaveApplicationService leaveService;
    
    @PostMapping("/apply")
    public String applyForLeave(@RequestBody LeaveApplicationDTO dto) {
        return leaveService.startLeaveProcess(
            dto.getApplicant(),
            dto.getManager(),
            dto.getStartDate(),
            dto.getEndDate(),
            dto.getReason()
        );
    }
    
    @PostMapping("/approve/{taskId}")
    public void approveLeave(@PathVariable String taskId, 
                           @RequestParam boolean approved) {
        leaveService.completeManagerApproval(taskId, approved);
    }
}

4.3 一行代码的"魔法"

实际上，核心的流程启动确实可以简化为一行代码：

java复制runtimeService.startProcessInstanceByKey("leaveApproval", variables);

但为了让系统更健壮，我们通常需要添加异常处理、日志记录和业务验证等逻辑。

性能提示：在高并发场景下，我建议对runtimeService和taskService的方法调用添加@Transactional注解，避免流程状态不一致的问题。

5. 高级功能与优化

5.1 动态任务分配

在实际项目中，审批人通常不是固定的。我们可以实现一个监听器：

java复制@Component
public class ManagerAssignmentListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        String applicant = (String) delegateTask.getVariable("applicant");
        String manager = organizationService.findManager(applicant);
        delegateTask.setAssignee(manager);
    }
}

然后在BPMN中配置：

xml复制<userTask id="managerApproval" name="Manager Approval">
    <extensionElements>
        <activiti:taskListener event="create" 
            class="com.example.ManagerAssignmentListener"/>
    </extensionElements>
</userTask>

5.2 会签功能

当需要多个经理同时审批时，可以使用会签（Multi-instance）：

xml复制<userTask id="committeeApproval" name="Committee Approval">
    <multiInstanceLoopCharacteristics 
        activiti:collection="${committeeMembers}"
        activiti:elementVariable="member">
        <completionCondition>${nrOfCompletedInstances/nrOfInstances >= 0.6}</completionCondition>
    </multiInstanceLoopCharacteristics>
</userTask>

5.3 流程监控

添加以下依赖后，Activiti会自动提供REST API：

xml复制<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-rest</artifactId>
    <version>7.1.0.M6</version>
</dependency>

然后可以通过以下端点监控流程：

GET /api/runtime/process-instances
GET /api/history/historic-process-instances

安全建议：在生产环境中，一定要对这些端点添加权限控制。我曾见过一个案例，因为暴露了这些接口导致敏感流程数据泄露。

6. 常见问题与解决方案

6.1 流程版本管理

当修改BPMN文件后重新部署时，Activiti会创建新版本的流程定义。旧实例会继续使用旧版本，新实例使用新版本。如果需要迁移运行中的实例，可以使用：

java复制runtimeService.createProcessInstanceMigrationBuilder()
    .migrateToProcessDefinition(newProcessDefinitionId);

6.2 事务管理

Activiti默认会为每个命令开启新事务。在复杂的业务场景中，可能需要将多个操作放在同一事务中：

java复制@Transactional
public void complexOperation() {
    // 业务逻辑
    taskService.complete(taskId);
    // 更多操作
}

6.3 性能优化

对于高频使用的流程：

启用流程定义缓存：

properties复制activiti.process-definition-cache-limit=100

批量处理任务时使用CommandContext：

java复制activitiRule.getManagementService().executeCommand(
    new Command<Void>() {
        public Void execute(CommandContext commandContext) {
            // 批量操作
            return null;
        }
    }
);

7. 替代方案比较

除了Activiti，还有其他工作流引擎可选：

引擎	优点	缺点	适用场景
Activiti	成熟稳定，社区活跃	配置较复杂	企业级复杂流程
Flowable	Activiti分支，更活跃	文档较少	需要最新特性的项目
Camunda	可视化工具完善	商业版功能多	需要强大BPM工具的项目
自研方案	完全定制化	开发成本高	特殊流程需求

在我的经验中，对于大多数请假审批这类简单流程，Activiti已经足够。但对于需要复杂业务规则或与现有系统深度集成的场景，可能需要考虑Flowable或Camunda。

8. 部署与扩展

8.1 Docker部署

创建Dockerfile：

dockerfile复制FROM openjdk:17-jdk-slim
COPY target/leave-approval.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建并运行：

bash复制docker build -t leave-approval .
docker run -p 8080:8080 leave-approval

8.2 Kubernetes部署

创建deployment.yaml：

yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
  name: leave-approval
spec:
  replicas: 3
  selector:
    matchLabels:
      app: leave-approval
  template:
    metadata:
      labels:
        app: leave-approval
    spec:
      containers:
      - name: app
        image: leave-approval
        ports:
        - containerPort: 8080
        resources:
          limits:
            memory: "512Mi"
            cpu: "500m"

8.3 与前端集成

典型的Vue.js前端调用示例：

javascript复制async function applyLeave(application) {
  const response = await axios.post('/api/leave/apply', application);
  return response.data;
}

async function approveLeave(taskId, approved) {
  await axios.post(`/api/leave/approve/${taskId}`, null, {
    params: { approved }
  });
}

在实际项目中，我通常会添加以下优化：

流程状态轮询
审批操作确认
审批期限提醒

9. 监控与维护

9.1 日志配置

在application.properties中添加：

properties复制logging.level.org.activiti=DEBUG
logging.level.org.springframework.web=INFO

9.2 健康检查

SpringBoot Actuator自动提供健康端点：

properties复制management.endpoints.web.exposure.include=health,info
management.endpoint.health.show-details=when_authorized

9.3 性能监控

添加Micrometer依赖：

xml复制<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

然后可以通过/metrics端点获取性能指标。

10. 实际应用中的经验分享

经过多个项目的实践，我总结了以下经验：

流程设计原则：
- 保持每个用户任务的责任单一
- 网关分支不宜超过5个
- 为每个流程定义明确的超时机制

异常处理：

java复制try {
    runtimeService.startProcessInstanceByKey(...);
} catch (ActivitiObjectNotFoundException e) {
    // 流程定义不存在
} catch (ActivitiException e) {
    // 其他流程引擎异常
}

测试策略：

使用Activiti的测试工具类：

java复制@RunWith(SpringRunner.class)
@SpringBootTest
public class LeaveProcessTest {
    @Autowired
    private ProcessEngine processEngine;
    
    @Test
    public void testHappyPath() {
        // 测试完整流程
    }
}

团队协作：
- 使用BPMN可视化工具（如Eclipse插件或在线工具）设计流程
- 流程定义文件应该纳入版本控制
- 建立流程变更的评审机制
扩展性考虑：
- 为未来可能增加的审批层级预留扩展点
- 考虑与邮件/消息系统的集成
- 设计可插拔的审批规则引擎

在最近的一个金融项目中，我们基于这套架构处理了日均1000+的请假审批，系统稳定运行了18个月无重大故障。关键是把复杂流程分解为简单、可测试的组件，并做好监控和告警。