1. 策略的核心定义
将策略抽象为包含以下元素的配置对象：
// 策略配置结构
const StrategyConfig = {
id: "strategy_001", // 策略唯一标识
name: "普通用户信用评估策略", // 策略名称
description: "适用于普通注册用户的基础信用评估", // 策略描述
type: "credit", // 策略类型
priority: 100, // 优先级 (数值越高优先级越高)
conditions: [ // 触发条件
{ field: "userType", operator: "eq", value: "normal" },
{ field: "age", operator: "gte", value: 18 }
],
rules: { // 执行规则
scoringAlgorithm: "weighted_sum",
weightings: {
repaymentHistory: 0.4,
creditUtilization: 0.3,
incomeLevel: 0.2,
creditHistoryLength: 0.1
},
thresholds: { pass: 70, review: 50 }
},
actions: [ // 执行动作
{ type: "set_credit_score", params: { field: "finalScore" } },
{ type: "set_risk_level", params: { field: "riskLevel" } }
],
metadata: { // 元数据
version: "1.0.0",
createdAt: "2024-01-01",
status: "active"
}
};
// 策略仓库
class StrategyRepository {
constructor() {
this.strategies = new Map();
this._loadStrategies();
}
// 加载策略配置
_loadStrategies() {
// 从JSON文件、API或数据库加载策略
const strategies = require('../config/strategies.json');
strategies.forEach(strategy => {
this.strategies.set(strategy.id, strategy);
});
}
// 获取所有策略
getAllStrategies() {
return Array.from(this.strategies.values());
}
// 根据类型获取策略
getStrategiesByType(type) {
return Array.from(this.strategies.values())
.filter(strategy => strategy.type === type && strategy.metadata.status === "active");
}
// 获取单个策略
getStrategyById(id) {
return this.strategies.get(id);
}
// 更新策略
updateStrategy(id, updates) {
const strategy = this.getStrategyById(id);
if (strategy) {
this.strategies.set(id, { ...strategy, ...updates });
return true;
}
return false;
}
}
export default new StrategyRepository();
---
// 策略场景路由
class StrategyRouter {
constructor(strategyRepository) {
this.strategyRepository = strategyRepository;
}
// 根据请求上下文选择匹配的策略
selectStrategies(type, context) {
const strategies = this.strategyRepository.getStrategiesByType(type);
// 筛选符合条件的策略
const matchedStrategies = strategies.filter(strategy =>
this._matchConditions(strategy.conditions, context)
);
// 按优先级排序
matchedStrategies.sort((a, b) => (b.priority || 0) - (a.priority || 0));
return matchedStrategies;
}
// 条件匹配逻辑
_matchConditions(conditions, context) {
if (!conditions || conditions.length === 0) {
return true; // 无条件策略默认匹配
}
return conditions.every(cond => {
const value = context[cond.field];
switch (cond.operator) {
case "eq": return value === cond.value;
case "ne": return value !== cond.value;
case "gt": return value > cond.value;
case "gte": return value >= cond.value;
case "lt": return value < cond.value;
case "lte": return value <= cond.value;
case "in": return Array.isArray(cond.value) && cond.value.includes(value);
case "nin": return Array.isArray(cond.value) && !cond.value.includes(value);
case "exists": return value !== undefined && value !== null;
default: return false;
}
});
}
}
export default StrategyRouter;
---
// 执行
class StrategyExecutor {
constructor() {
this.algorithms = {
// 加权求和算法
weighted_sum: (data, config) => {
const { weightings } = config.rules;
let score = 0;
let totalWeight = 0;
Object.entries(weightings).forEach(([field, weight]) => {
const value = data[field] || 0;
score += value * weight;
totalWeight += weight;
});
return totalWeight > 0 ? score / totalWeight : 0;
},
// 可以添加更多算法
};
}
// 执行单个策略
async executeStrategy(strategy, data) {
try {
const algorithm = this.algorithms[strategy.rules.scoringAlgorithm];
if (!algorithm) {
throw new Error(`Unknown algorithm: ${strategy.rules.scoringAlgorithm}`);
}
// 执行评分算法
const score = algorithm(data, strategy);
// 根据阈值确定决策结果
let decision = "reject";
const { thresholds } = strategy.rules;
if (score >= thresholds.pass) {
decision = "pass";
} else if (score >= thresholds.review) {
decision = "review";
}
// 执行策略动作
const results = strategy.actions.reduce((acc, action) => {
switch (action.type) {
case "set_credit_score":
acc[action.params.field] = score;
break;
case "set_risk_level":
acc[action.params.field] = this._getRiskLevel(score, thresholds);
break;
// 可以添加更多动作类型
}
return acc;
}, {});
return {
strategyId: strategy.id,
strategyName: strategy.name,
score,
decision,
results,
executedAt: new Date().toISOString()
};
} catch (error) {
return {
strategyId: strategy.id,
strategyName: strategy.name,
error: error.message,
executedAt: new Date().toISOString()
};
}
}
// 执行多个策略
async executeStrategies(strategies, data) {
const promises = strategies.map(strategy =>
this.executeStrategy(strategy, data)
);
return await Promise.all(promises);
}
// 获取风险等级
_getRiskLevel(score, thresholds) {
if (score >= thresholds.pass) return "low";
if (score >= thresholds.review) return "medium";
return "high";
}
}
export default StrategyExecutor;
---
// 结果合并,合并某个场景下多个策略的结果
class ResultMerger {
// 合并多个策略执行结果
mergeResults(results, mergeStrategy = "priority") {
if (!results || results.length === 0) {
return null;
}
switch (mergeStrategy) {
case "priority":
// 按优先级合并（高优先级策略结果覆盖低优先级）
return this._mergeByPriority(results);
case "weighted":
// 加权合并（根据策略权重计算综合结果）
return this._mergeByWeight(results);
case "strictest":
// 取最严格结果（如风控场景取最高风险等级）
return this._mergeByStrictest(results);
case "consensus":
// 取共识结果（多数策略同意的结果）
return this._mergeByConsensus(results);
default:
return this._mergeByPriority(results);
}
}
// 按优先级合并
_mergeByPriority(results) {
// 假设results已经按优先级排序
const primaryResult = results[0];
const mergedResults = results.reduce((acc, result) => ({
...acc,
...result.results
}), {});
return {
...primaryResult,
results: mergedResults,
allResults: results,
mergeStrategy: "priority"
};
}
// 其他合并策略的实现...
_mergeByWeight(results) { /* ... */ }
_mergeByStrictest(results) { /* ... */ }
_mergeByConsensus(results) { /* ... */ }
}
export default ResultMerger;
---
// 决策引擎
import StrategyRepository from './strategyRepository';
import StrategyRouter from './strategyRouter';
import StrategyExecutor from './strategyExecutor';
import ResultMerger from './resultMerger';
class DecisionEngine {
constructor() {
this.strategyRepository = StrategyRepository;
this.strategyRouter = new StrategyRouter(this.strategyRepository);
this.strategyExecutor = new StrategyExecutor();
this.resultMerger = new ResultMerger();
}
// 执行决策
async executeDecision(scenarioType, requestData, context = {}) {
try {
// 1. 选择匹配的策略
const matchedStrategies = this.strategyRouter.selectStrategies(scenarioType, {
...requestData,
...context
});
if (matchedStrategies.length === 0) {
throw new Error(`No strategies found for scenario: ${scenarioType}`);
}
// 2. 执行所有匹配的策略
const strategyResults = await this.strategyExecutor.executeStrategies(
matchedStrategies,
requestData
);
// 3. 合并结果
const mergedResult = this.resultMerger.mergeResults(strategyResults);
// 4. 返回最终决策
return {
success: true,
scenarioType,
matchedStrategyCount: matchedStrategies.length,
finalResult: mergedResult,
timestamp: new Date().toISOString()
};
} catch (error) {
return {
success: false,
error: error.message,
timestamp: new Date().toISOString()
};
}
}
}
export default new DecisionEngine();
2. 策略管理架构设计
(1) 策略配置层
- 集中存储 ：将所有策略配置存储在统一的配置中心（如JSON文件、数据库或专业配置管理系统）
- 版本控制 ：为每个策略维护版本号，支持回滚和变更追踪
- 环境隔离 ：区分开发、测试、生产环境的策略配置
(2) 策略路由层
- 规则引擎 ：根据客户端请求特征（如用户类型、地区、设备等）匹配适用策略
- 优先级机制 ：当多个策略条件匹配时，按优先级选择执行策略
- 降级策略 ：设置默认策略，当无匹配策略时自动应用
(3) 策略执行层
- 策略引擎 ：执行选中策略的具体规则和算法
- 参数注入 ：将客户端请求数据转换为策略所需的输入参数
- 结果标准化 ：将不同策略的执行结果转换为统一格式
(4) 策略监控层
- 执行日志 ：记录每个请求使用的策略、输入参数和执行结果
- 效果分析 ：统计策略的通过率、拒绝率、准确率等指标
- 异常告警 ：监控策略执行异常和性能问题
4. 策略生命周期管理
- 创建 ：通过策略管理界面或API定义新策略
- 测试 ：在测试环境验证策略效果
- 部署 ：将验证通过的策略发布到生产环境
- 监控 ：实时监控策略执行效果和性能
- 更新 ：根据业务需要调整策略参数和规则
- 下线 ：将不再使用的策略标记为失效
5. 优势与价值
- 灵活性 ：快速响应业务变化，无需修改核心代码
- 可维护性 ：集中管理所有策略，降低维护成本
- 可扩展性 ：支持新增策略类型和执行逻辑
- 可审计性 ：完整记录策略执行历史和变更记录
- 高效性 ：通过策略路由快速匹配适用策略
