引言：为什么业务逻辑配置需要可视化？

在日常开发中，我们经常遇到这样的场景：

电商促销活动：满减、折扣、优惠券、会员等级、时间段、商品分类等各种规则组合在一起，每次产品经理提新促销规则，开发人员就要改代码、测试、上线，整个流程下来可能需要好几天。

审批流程：部门经理审批 → 财务审批 → 总经理审批，看似简单，但不同金额、不同类型的申请可能需要不同的审批路径。

数据处理：数据验证 → 数据转换 → 数据存储，每个环节都可能有不同的处理逻辑。

传统的硬编码方式在这些场景下显得力不从心：

1. 代码复杂度高：if-else嵌套越来越深
2. 维护成本大：规则变更需要重新发布代码
3. 业务响应慢：新规则上线周期长
4. 沟通成本高：业务人员无法直接参与规则配置

这时候，规则编排可视化就派上用场了！今天我们就来聊聊如何用SpringBoot打造一个让非技术人员也能配置复杂业务逻辑的可视化平台。

核心设计理念

1. 流程即代码，代码即流程

我们的核心思想是：把业务逻辑抽象成可视化的流程图，让业务人员通过拖拽节点的方式来配置规则。

传统方式：代码编写 → 编译测试 → 部署上线
可视化方式：拖拽配置 → 实时生效 → 无需重启

2. 节点化思维

将复杂的业务逻辑拆解成基本的节点类型：

• 开始节点：流程入口
• 条件节点：判断逻辑
• 动作节点：执行操作
• 结束节点：流程出口

3. 连接即逻辑

节点之间的连接关系就是业务逻辑的执行顺序，条件节点的多个输出连接可以实现分支判断。

技术架构实现

后端技术栈选择

SpringBoot 2.7.x + Easy Rules + Redis + MySQL

为什么选择这个组合？

• SpringBoot：快速开发，生态丰富
• Easy Rules：轻量级规则引擎，简单易用
• Redis：高性能缓存，规则存储
• MySQL：持久化存储，数据备份

系统架构图

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   前端界面层    │    │   控制层        │    │   规则引擎层    │
│  (Vue3 + jsPlumb)│◄──►│ (SpringBoot)    │◄──►│ (Easy Rules)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
        │                       │                       │
        ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   规则存储层    │    │   执行引擎层    │    │   业务逻辑层    │
│   (Redis/MySQL) │    │   (规则执行)    │    │   (具体业务)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘

核心组件详解

1. 规则流程定义模型

@Data
public class RuleFlow implements Serializable {
    private String flowId;           // 流程ID
    private String flowName;         // 流程名称
    private List<RuleNode> nodes;    // 节点列表
    private List<NodeConnection> connections; // 连接关系
    private String status;           // 状态
    private Integer version;         // 版本号
}

2. 规则节点定义

@Data
public class RuleNode implements Serializable {
    private String nodeId;      // 节点ID
    private String nodeName;    // 节点名称
    private String nodeType;    // 节点类型：START/CONDITION/ACTION/END
    private String condition;   // 条件表达式
    private String action;      // 动作表达式
    private NodePosition position; // 节点位置（用于可视化）
}

3. 规则执行引擎

核心思想是将流程图转换为规则引擎可以理解的规则集：

@Component
public class RuleExecutionEngine {
    
    private final RulesEngine rulesEngine = new DefaultRulesEngine();
    
    public Map<String, Object> executeRuleFlow(RuleFlow ruleFlow, 
                                              Map<String, Object> inputData) {
        // 1. 构建执行上下文
        Facts facts = new Facts();
        facts.put("input", inputData);
        facts.put("output", new HashMap<>(inputData));
        
        // 2. 构建规则集
        Rules rules = buildRules(ruleFlow);
        
        // 3. 执行规则
        rulesEngine.fire(rules, facts);
        
        return (Map<String, Object>) facts.get("output");
    }
    
    private Rules buildRules(RuleFlow ruleFlow) {
        Rules rules = new Rules();
        
        for (RuleNode node : ruleFlow.getNodes()) {
            if ("CONDITION".equals(node.getNodeType())) {
                // 条件节点转换为规则
                org.jeasy.rules.api.Rule conditionRule = 
                    new org.jeasy.rules.api.Rule.Builder()
                    .name(node.getNodeName())
                    .when(facts -> evaluateCondition(node.getCondition(), facts))
                    .then(facts -> executeAction(node.getAction(), facts))
                    .build();
                rules.register(conditionRule);
            }
        }
        
        return rules;
    }
}

可视化界面实现

前端技术栈

Vue3 + Element Plus + jsPlumb

核心功能实现

<template>
  <div class="flow-container">
    <div id="flowCanvas" class="flow-canvas">
      <!-- 流程图容器 -->
    </div>
  </div>
</template>

<script>
import { ref, onMounted } from 'vue'
import axios from 'axios'

export default {
  setup() {
    // 创建流程
    const createFlow = async () => {
      const flowDefinition = {
        flowName: 'VIP用户折扣规则',
        nodes: [
          {
            nodeId: 'start',
            nodeName: '开始',
            nodeType: 'START',
            position: { x: 100, y: 100, width: 100, height: 50 }
          },
          {
            nodeId: 'condition1',
            nodeName: '判断用户类型',
            nodeType: 'CONDITION',
            condition: 'userType == "VIP"',
            position: { x: 250, y: 100, width: 120, height: 60 }
          }
        ],
        connections: [
          {
            connectionId: 'conn1',
            fromNodeId: 'start',
            toNodeId: 'condition1'
          }
        ]
      }
      
      const response = await axios.post('/api/rule/flow', flowDefinition)
      // 处理响应
    }
    
    return { createFlow }
  }
}
</script>

实际应用案例

案例1：电商VIP折扣规则

开始节点 → 判断用户类型(VIP?) → 判断订单金额(>100?) → 应用20%折扣 → 结束

配置JSON：

{
  "flowName": "VIP用户折扣规则",
  "nodes": [
    {
      "nodeId": "condition1",
      "nodeType": "CONDITION",
      "condition": "userType == 'VIP'",
      "action": "isVip = true"
    },
    {
      "nodeId": "condition2",
      "nodeType": "CONDITION", 
      "condition": "orderAmount > 100",
      "action": "discount = 0.2"
    }
  ]
}

案例2：多级审批流程

开始 → 部门经理审批 → 财务审批 → 总经理审批 → 结束

案例3：数据处理流程

开始 → 数据验证 → 数据转换 → 数据存储 → 结束

性能优化策略

1. 规则缓存机制

@Service
public class RuleFlowService {
    
    // 缓存执行结果
    private static final String RULE_CACHE_PREFIX = "rule:cache:";
    
    public Map<String, Object> executeRuleFlow(String flowId, 
                                              Map<String, Object> inputData) {
        // 先从缓存获取
        String cacheKey = RULE_CACHE_PREFIX + flowId + ":" + inputData.hashCode();
        Map<String, Object> cachedResult = redisTemplate.opsForValue().get(cacheKey);
        
        if (cachedResult != null) {
            return cachedResult;
        }
        
        // 执行规则并缓存结果
        Map<String, Object> result = ruleExecutionEngine.executeRuleFlow(flowId, inputData);
        redisTemplate.opsForValue().set(cacheKey, result, 5, TimeUnit.MINUTES);
        
        return result;
    }
}

2. 异步执行机制

对于复杂的规则流程，可以采用异步执行：

@Async
public CompletableFuture<Map<String, Object>> executeRuleFlowAsync(
        String flowId, Map<String, Object> inputData) {
    Map<String, Object> result = executeRuleFlow(flowId, inputData);
    return CompletableFuture.completedFuture(result);
}

安全性和权限控制

1. 规则版本管理

public class RuleFlow {
    private Integer version;     // 版本号
    private String status;       // 状态：DRAFT/PENDING/APPROVED/ACTIVE
    private Long createTime;     // 创建时间
    private Long updateTime;     // 更新时间
}

2. 操作权限控制

@PreAuthorize("hasAuthority('RULE_ADMIN')")
@PostMapping("/flow")
public Map<String, Object> createRuleFlow(@RequestBody RuleFlow ruleFlow) {
    // 只有规则管理员才能创建流程
}

部署和运维

启动脚本

# start.bat
@echo off
echo 正在启动后端服务...
cd backend
start "Rule Backend" mvn spring-boot:run

timeout /t 10 /nobreak >nul

echo 正在启动前端服务...
cd ../frontend
start "Rule Frontend" npm run dev

echo 服务启动完成！
echo 后端服务: http://localhost:8080
echo 前端界面: http://localhost:3000

监控和告警

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

总结

规则编排可视化平台的核心价值在于：

🎯 降低技术门槛：非技术人员也能配置复杂业务逻辑
⚡ 提升响应速度：规则变更实时生效，无需重启服务
🔧 增强灵活性：支持复杂的条件判断和分支流程
🛡️ 保证稳定性：完善的版本控制和权限管理

这个方案特别适合以下场景：

• 电商促销规则配置
• 审批流程管理
• 数据处理流程
• 业务规则频繁变更的系统

记住，技术的价值不在于炫酷，而在于解决实际问题。规则编排可视化让业务人员从被动等待开发变成了主动配置，这才是真正的价值所在！

公众号：服务端技术精选