Solon-Flow订单处理示例：构建高效电商订单流程编排系统-优快云博客

Solon-Flow订单处理示例：构建高效电商订单流程编排系统

【免费下载链接】solon-flow Solon Flow 通用流程编排框架（采用 json 和 yaml 编排格式）。可用于计算（或任务）的编排场景；可用于业务规则和决策处理型的编排场景；可用于办公审批型（有状态、可中断，人员参与）的编排场景；可用于长时间流程（结合自动前进，等待介入）的编排场景。项目地址: https://gitcode.com/opensolon/solon-flow

痛点场景：电商订单处理的复杂性挑战

你是否还在为电商订单处理流程的复杂性而头疼？订单状态流转混乱、业务规则频繁变更、多系统集成困难、人工审批效率低下...这些痛点是否让你夜不能寐？

本文将为你展示如何利用Solon-Flow流程编排框架，构建一个高效、灵活、可扩展的电商订单处理系统。通过本文，你将掌握：

✅ Solon-Flow核心概念与架构设计
✅ 订单处理流程的YAML配置实战
✅ 条件判断与业务规则编排技巧
✅ 状态管理与人工审批集成方案
✅ 完整订单处理示例代码实现

Solon-Flow核心架构解析

Solon-Flow采用基于YAML/JSON的声明式流程编排，其核心架构如下：

mermaid

订单处理流程设计

订单状态机设计

mermaid

订单处理YAML配置

id: order_processing_chain
layout:
  - id: start_node
    type: start
    title: 订单创建
    link: payment_check_node
    
  - id: payment_check_node
    type: activity
    title: 支付状态检查
    task: |
      if(order.getStatus() == "PAID") {
        context.put("payment_verified", true);
        order.setProcessStep("支付验证通过");
      } else {
        context.put("payment_verified", false);
        order.setProcessStep("等待支付");
      }
    link: 
      - nextId: large_order_check_node
        when: payment_verified == true
      - nextId: payment_reminder_node
        when: payment_verified == false
        
  - id: payment_reminder_node
    type: activity
    title: 支付提醒
    task: |
      // 发送支付提醒通知
      notificationService.sendPaymentReminder(order.getOrderNo(), order.getUserId());
      order.setProcessStep("已发送支付提醒");
    link: wait_for_payment_node
    
  - id: wait_for_payment_node
    type: delay
    title: 等待支付
    meta: 
      timeout: 3600
      timeout_action: cancel_order
    link: payment_check_node
    
  - id: large_order_check_node
    type: exclusive
    title: 大额订单判断
    task: |
      boolean isLargeOrder = order.getAmount() > 1000;
      context.put("is_large_order", isLargeOrder);
      order.setProcessStep(isLargeOrder ? "大额订单需审核" : "小额订单直接发货");
    link:
      - nextId: manual_approval_node
        when: is_large_order == true
      - nextId: shipping_preparation_node
        when: is_large_order == false
        
  - id: manual_approval_node
    type: activity
    title: 人工审核
    meta:
      approver_role: "finance_manager"
      approval_timeout: 86400
    task: "@ManualApprovalTask"
    link: approval_result_check_node
    
  - id: approval_result_check_node
    type: exclusive
    title: 审核结果判断
    task: |
      String approvalStatus = order.getApprovalStatus();
      context.put("approval_status", approvalStatus);
    link:
      - nextId: shipping_preparation_node
        when: approval_status == "APPROVED"
      - nextId: order_cancellation_node
        when: approval_status == "REJECTED"
        
  - id: shipping_preparation_node
    type: activity
    title: 发货准备
    task: |
      shippingService.prepareShipping(order);
      order.setStatus("PREPARING_SHIPMENT");
      order.setProcessStep("发货准备中");
    link: inventory_check_node
    
  - id: inventory_check_node
    type: activity
    title: 库存检查
    task: |
      boolean inventoryAvailable = inventoryService.checkInventory(order.getItems());
      context.put("inventory_available", inventoryAvailable);
    link:
      - nextId: shipping_execution_node
        when: inventory_available == true
      - nextId: inventory_replenishment_node
        when: inventory_available == false
        
  - id: inventory_replenishment_node
    type: activity
    title: 库存补充
    task: |
      inventoryService.requestReplenishment(order.getItems());
      order.setProcessStep("等待库存补充");
    link: inventory_check_node
    
  - id: shipping_execution_node
    type: activity
    title: 执行发货
    task: |
      shippingService.executeShipping(order);
      order.setStatus("SHIPPED");
      order.setProcessStep("已发货");
      context.eventBus().send("order.shipped", order);
    link: delivery_tracking_node
    
  - id: delivery_tracking_node
    type: activity
    title: 物流跟踪
    task: |
      logisticsService.trackDelivery(order.getTrackingNumber());
    link: delivery_completion_check_node
    
  - id: delivery_completion_check_node
    type: activity
    title: 送达确认
    task: |
      if(logisticsService.isDelivered(order.getTrackingNumber())) {
        order.setStatus("COMPLETED");
        order.setProcessStep("订单已完成");
        context.put("delivery_completed", true);
      }
    link:
      - nextId: order_completion_node
        when: delivery_completed == true
      - nextId: delivery_tracking_node
        when: delivery_completed == false
        
  - id: order_completion_node
    type: activity
    title: 订单完成处理
    task: |
      orderService.completeOrder(order);
      notificationService.sendOrderCompletion(order.getUserId(), order.getOrderNo());
      context.eventBus().send("order.completed", order);
    link: end_node
    
  - id: order_cancellation_node
    type: activity
    title: 订单取消
    task: |
      orderService.cancelOrder(order);
      refundService.processRefund(order);
      notificationService.sendOrderCancellation(order.getUserId(), order.getOrderNo());
      context.eventBus().send("order.cancelled", order);
    link: end_node
    
  - id: end_node
    type: end
    title: 流程结束

核心业务组件实现

订单实体类

public class Order {
    private String orderNo;
    private Long userId;
    private BigDecimal amount;
    private String status;
    private String processStep;
    private String approvalStatus;
    private List<OrderItem> items;
    private String trackingNumber;
    
    // Getter和Setter方法
    public long getAmount() {
        return amount.longValue();
    }
    
    public void setStatus(String status) {
        this.status = status;
    }
    
    public void setProcessStep(String processStep) {
        this.processStep = processStep;
    }
    
    public String getApprovalStatus() {
        return approvalStatus;
    }
    
    // 其他方法...
}

人工审核任务组件

@Component("ManualApprovalTask")
public class ManualApprovalTask implements TaskComponent {
    
    @Inject
    private ApprovalService approvalService;
    
    @Override
    public void run(FlowContext context, Node node) throws Throwable {
        Order order = context.get("order");
        String approverRole = node.getMeta("approver_role");
        
        // 创建审批任务
        ApprovalTask approvalTask = approvalService.createApprovalTask(
            order.getOrderNo(), 
            "ORDER_APPROVAL", 
            approverRole,
            order.getAmount()
        );
        
        // 设置超时时间
        long timeout = Long.parseLong(node.getMeta("approval_timeout").toString());
        approvalTask.setTimeout(timeout);
        
        context.put("approval_task_id", approvalTask.getId());
        order.setProcessStep("等待人工审核");
    }
}

流程引擎配置与执行

@Configuration
public class OrderFlowConfig {
    
    @Bean
    public FlowEngine orderFlowEngine() {
        FlowEngine engine = FlowEngine.newInstance();
        engine.register(new SimpleFlowDriver(new AviatorEvaluation()));
        
        // 加载订单处理流程配置
        engine.load("classpath:flow/order/*.yml");
        
        return engine;
    }
}

@Service
public class OrderProcessingService {
    
    @Inject
    private FlowEngine orderFlowEngine;
    
    public void processOrder(Order order) throws Throwable {
        FlowContext context = FlowContext.of()
            .put("order", order)
            .put("current_time", System.currentTimeMillis());
        
        // 执行订单处理流程
        orderFlowEngine.eval("order_processing_chain", context);
        
        // 处理流程执行结果
        handleFlowResult(context, order);
    }
    
    private void handleFlowResult(FlowContext context, Order order) {
        // 根据上下文处理结果
        if (context.contains("flow_error")) {
            handleFlowError(context, order);
        }
    }
}

高级特性应用

条件表达式与业务规则

- id: discount_application_node
  type: activity
  title: 折扣应用
  task: |
    # 根据订单金额应用不同折扣
    if(order.getAmount() > 1000) {
        order.applyDiscount(0.1); // 满1000打9折
    } else if(order.getAmount() > 500) {
        order.applyDiscount(0.05); // 满500打95折
    } else if(order.getAmount() > 200) {
        order.applyDiscount(0.02); // 满200打98折
    }
  when: order.hasDiscountEligibility() == true

事件驱动与消息通知

- id: notification_node
  type: activity
  title: 消息通知
  task: |
    # 发送各种类型的通知
    context.<Order, Void>eventBus().send("order.status.update", order);
    context.<String, Void>eventBus().send("sms.notification", 
        "尊敬的客户，您的订单" + order.getOrderNo() + "状态已更新为：" + order.getStatus());

元数据配置与扩展

- id: special_handling_node
  type: activity
  title: 特殊处理
  meta:
    priority: "HIGH"
    handler_team: "vip_customer_service"
    sla_time: 3600
    allowed_retries: 3
  task: "@SpecialHandlingTask"

性能优化与最佳实践

流程配置优化建议

优化点	推荐做法	避免做法
节点数量	保持流程简洁，不超过20个节点	创建过于复杂的巨型流程
条件判断	使用清晰的when条件表达式	在task中编写复杂逻辑判断
元数据使用	合理使用meta存储配置信息	在代码中硬编码配置参数
错误处理	配置适当的异常处理机制	忽略流程执行中的异常

监控与日志记录

@Component
public class OrderFlowMonitor implements ChainInterceptor {
    
    @Override
    public void before(ChainInvocation invocation) {
        log.info("开始执行流程: {}, 节点: {}", 
            invocation.getChain().getId(), 
            invocation.getNode().getId());
    }
    
    @Override
    public void after(ChainInvocation invocation, Object result) {
        log.info("流程执行完成: {}, 节点: {}, 耗时: {}ms",
            invocation.getChain().getId(),
            invocation.getNode().getId(),
            System.currentTimeMillis() - invocation.getStartTime());
    }
    
    @Override
    public void error(ChainInvocation invocation, Throwable error) {
        log.error("流程执行错误: {}, 节点: {}", 
            invocation.getChain().getId(), 
            invocation.getNode().getId(), error);
    }
}

总结与展望

通过本文的订单处理示例，我们展示了Solon-Flow在电商领域的强大应用能力：

声明式编排：通过YAML配置实现复杂的业务逻辑，降低开发维护成本
灵活的条件处理：支持丰富的条件表达式，满足各种业务场景需求
状态管理：完善的状态机支持，确保订单状态流转的正确性
扩展性强：通过元数据和自定义组件支持业务扩展
事件驱动：内置事件总线支持系统间解耦和异步处理

Solon-Flow不仅适用于订单处理场景，还可以广泛应用于规则引擎、审批流程、数据处理管道等各种需要流程编排的场景。其简洁的配置语法和强大的扩展能力，使其成为Java生态中流程编排的优秀解决方案。

未来，随着业务复杂度的增加，我们可以进一步探索：

分布式流程执行与状态同步
可视化流程监控与管理
AI驱动的智能流程优化
多租户流程隔离与管理

立即开始使用Solon-Flow，构建你的下一代智能订单处理系统！

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考