一、为何选择自研工作流引擎？

在业务系统开发中，工作流引擎是支撑审批、订单处理、任务调度等复杂流程的核心组件。行业常见技术方案（如Activiti、Flowable）虽功能强大，但存在以下痛点：

1. 重量级依赖：传统引擎依赖Spring等框架，集成成本高，对小型项目不友好；
2. 灵活性不足：预设的BPMN规范难以适配快速变化的业务需求；
3. 性能瓶颈：复杂流程下状态查询与事务管理效率低下。

自研引擎的优势在于轻量化与可控性：可根据业务场景定制状态机模型、优化持久化策略，并完全掌控源码级调试与扩展。本文将以Java实现为例，分步骤拆解核心设计。

二、核心架构设计：分层与解耦

1. 分层架构模型

采用经典的三层架构：

• API层：暴露流程定义、启动、查询等接口；
• 核心层：处理状态机、任务调度、事件通知；
• 存储层：支持多种持久化方案（如内存、数据库）。

// 示例：流程引擎接口定义
public interface WorkflowEngine {
    String startProcess(String processDefinitionKey, Map<String, Object> variables);
    ProcessInstance getProcessInstance(String instanceId);
    void completeTask(String taskId, Map<String, Object> variables);
}

2. 状态机模型设计

状态机是工作流引擎的核心，需定义以下要素：

• 状态（State）：如CREATED、RUNNING、COMPLETED；
• 转换（Transition）：触发状态变更的条件（如用户审批通过）；
• 事件（Event）：状态变更时触发（如发送通知）。

通过枚举类定义状态，避免硬编码：

public enum ProcessState {
    CREATED, RUNNING, SUSPENDED, COMPLETED, FAILED
}

3. 流程定义解析

支持两种流程定义方式：

• JSON配置：适合简单流程，示例如下：

  {
  "key": "order_approval",
  "states": [
    {"name": "CREATED", "type": "start"},
    {"name": "APPROVED", "type": "user_task", "assignee": "${manager}"},
    {"name": "COMPLETED", "type": "end"}
  ],
  "transitions": [
    {"from": "CREATED", "to": "APPROVED", "condition": "amount > 1000"},
    {"from": "APPROVED", "to": "COMPLETED"}
  ]
  }

• 代码动态构建：通过Java代码定义流程逻辑，适合复杂场景。

三、状态机实现：有限状态自动机（FSM）

1. 状态转换逻辑

使用State Pattern实现状态行为封装：

public interface State {
    void enter(ProcessContext context);
    void exit(ProcessContext context);
    State transition(ProcessContext context, String event);
}
public class RunningState implements State {
    @Override
    public State transition(ProcessContext context, String event) {
        if ("APPROVE".equals(event)) {
            return new CompletedState();
        } else if ("REJECT".equals(event)) {
            return new FailedState();
        }
        return this;
    }
}

2. 上下文管理

ProcessContext保存流程实例数据（如变量、当前状态）：

public class ProcessContext {
    private String instanceId;
    private Map<String, Object> variables = new HashMap<>();
    private State currentState;
    // Getters & Setters
}

3. 触发器设计

通过事件驱动状态转换，支持同步与异步触发：

public class StateMachine {
    public void fireEvent(ProcessContext context, String event) {
        State nextState = context.getCurrentState().transition(context, event);
        if (nextState != context.getCurrentState()) {
            context.getCurrentState().exit(context);
            context.setCurrentState(nextState);
            nextState.enter(context);
        }
    }
}

四、持久化方案：内存与数据库的权衡

1. 内存存储（快速原型）

适用于测试或低并发场景，使用ConcurrentHashMap保存流程实例：

public class InMemoryStorage implements ProcessStorage {
    private Map<String, ProcessInstance> instances = new ConcurrentHashMap<>();
    @Override
    public void save(ProcessInstance instance) {
        instances.put(instance.getId(), instance);
    }
    @Override
    public ProcessInstance findById(String id) {
        return instances.get(id);
    }
}

2. 数据库存储（生产环境）

设计两张表：

• PROCESS_INSTANCE：存储实例基础信息（ID、定义KEY、状态）；
• PROCESS_VARIABLE：存储流程变量（键值对）。

通过JDBC或JPA实现持久化，示例片段：

public class JdbcProcessStorage implements ProcessStorage {
    private DataSource dataSource;
    @Override
    public ProcessInstance findById(String id) {
        String sql = "SELECT * FROM PROCESS_INSTANCE WHERE ID = ?";
        // 执行查询并构建ProcessInstance对象
    }
}

五、扩展性设计：插件化与事件驱动

1. 插件化任务处理器

支持自定义任务类型（如HTTP调用、消息发送）：

public interface TaskHandler {
    void execute(TaskContext context);
}
public class HttpTaskHandler implements TaskHandler {
    @Override
    public void execute(TaskContext context) {
        // 调用HTTP接口
    }
}

通过ServiceLoader动态加载插件。

2. 事件通知机制

集成观察者模式，在状态变更时触发事件：

public interface WorkflowEventListener {
    void onEvent(WorkflowEvent event);
}
public class EventBus {
    private List<WorkflowEventListener> listeners = new ArrayList<>();
    public void register(WorkflowEventListener listener) {
        listeners.add(listener);
    }
    public void publish(WorkflowEvent event) {
        listeners.forEach(l -> l.onEvent(event));
    }
}

六、总结与下篇预告

本篇从架构设计、状态机实现、持久化方案三个维度，详细解析了Java自研工作流引擎的核心逻辑。下篇将深入探讨分布式事务处理、性能优化及与微服务架构的集成，并提供完整的代码示例与测试用例。

通过自研引擎，开发者可摆脱对第三方工具的依赖，实现流程定义的灵活性与系统性能的极致优化。无论是在高并发审批场景，还是复杂任务调度中，轻量级工作流引擎都能成为业务系统的强力支撑。