当前位置：首页 > article >正文

参数映射服务完整解决方案

article 2025/2/9 9:57:55

参数映射服务完整解决方案

1. 背景说明

在复杂的工作流程中，后续程序需要动态构造输入参数，这些参数源自多个前序程序的 JSON 数据输出。为了增强系统的灵活性和可扩展性，需要一个通用的参数映射服务来处理这种复杂的数据转换需求。

1.1 主要挑战

数据来源多样性：需要处理来自不同程序的多种格式数据
映射逻辑复杂：包含条件判断、循环处理、多源合并等场景
配置驱动：需要通过配置文件定义映射规则，避免硬编码
扩展性要求：支持新增映射类型，保持代码结构清晰

2. 核心需求

2.1 基础功能需求

简单参数映射：支持从单一来源提取数据
复杂逻辑支持：
- 条件逻辑（if-then-else）
- 循环体处理
- 字段映射和合并
多来源支持：从多个前序程序提取数据，支持不同合并策略
常量支持：允许直接使用固定值

2.2 设计目标

通用性：提供统一的配置结构
灵活性：支持多种动态逻辑
易读性：配置结构清晰直观
可扩展性：易于添加新的映射类型

3. 系统架构

3.1 架构图

+----------------+          +----------------+           +----------------+
| 前序程序输出     | ------> | 参数映射服务     | -------> | 后序程序输入参数    |
| JSON 数据       |          | (JSON 配置驱动) |           | 动态生成          |
+----------------+          +----------------+           +----------------+

3.2 核心组件

值对象基类：定义通用接口和基础功能
专用值对象：实现不同类型的参数映射逻辑
值对象工厂：负责创建具体的值对象实例
参数映射服务：统一的服务入口

4. 配置结构设计

4.1 参数配置

字段名称	类型	必填	说明
name	string	是	参数名称
value	object	是	参数值定义
description	string	否	参数描述

4.2 值对象类型

4.2.1 常量值（ConstantValue）

{
  "type": "constant",
  "value": "固定值"
}

4.2.2 单一来源（SingleSourceValue）

{
  "type": "jmespath",
  "jmespath": "data.path.to.value"
}

4.2.3 多来源（MultiSourceValue）

{
  "type": "multiSource",
  "sources": {
    "sourceA": "path.to.arrayA",
    "sourceB": "path.to.arrayB"
  },
  "mergeStrategy": "concat"
}

4.2.4 循环体（LoopValue）

{
  "type": "loop",
  "jmespath": "items[*]",
  "mappings": {
    "id": "id",
    "name": "name"
  }
}

4.2.5 条件值（ConditionalValue）

{
  "type": "conditional",
  "jmespath": "status",
  "conditions": [
    {
      "if": "status == 'success'",
      "then": {
        "type": "constant",
        "value": "成功"
      }
    }
  ],
  "else": {
    "type": "constant",
    "value": "其他"
  }
}

5. 代码实现

5.1 工具函数

import jp from "jmespath";

/**
 * 安全的 JMESPath 查询
 * @param {Object} data - 查询的上下文对象
 * @param {string} expression - JMESPath 表达式
 * @param {*} defaultValue - 查询失败时的默认值
 * @returns {*} 查询结果或默认值
 */
function safeJMESPath(data, expression, defaultValue = null) {
  try {
    const result = jp.search(data, expression);
    return result !== undefined ? result : defaultValue;
  } catch (error) {
    console.warn(`JMESPath 查询失败: ${expression}`, error);
    return defaultValue;
  }
}

5.2 值对象基类

/**
 * 值对象基类
 */
class ValueObject {
  constructor(config) {
    this.type = config.type;
    if (!this.type) {
      throw new Error("值对象类型未定义");
    }
  }

  getValue(context) {
    throw new Error("子类必须实现 getValue 方法");
  }
}

5.3 专用值对象实现

/**
 * 常量值对象
 */
class ConstantValue extends ValueObject {
  constructor(config) {
    super(config);
    this.value = config.value;
    if (this.value === undefined) {
      throw new Error("常量值未指定");
    }
  }

  getValue() {
    return this.value;
  }
}

/**
 * 单一来源值对象
 */
class SingleSourceValue extends ValueObject {
  constructor(config) {
    super(config);
    this.jmespath = config.jmespath;
    if (!this.jmespath) {
      throw new Error("JMESPath 表达式未指定");
    }
  }

  getValue(context) {
    return safeJMESPath(context, this.jmespath);
  }
}

/**
 * 多来源值对象
 */
class MultiSourceValue extends ValueObject {
  constructor(config) {
    super(config);
    this.sources = config.sources;
    this.mergeStrategy = config.mergeStrategy || "concat";
    if (!this.sources || typeof this.sources !== "object") {
      throw new Error("多来源配置无效");
    }
  }

  getValue(context) {
    const values = Object.entries(this.sources).map(([key, jmespath]) => {
      return safeJMESPath(context[key], jmespath, []);
    });

    switch (this.mergeStrategy) {
      case "concat":
        return values.flat();
      case "unique":
        return [...new Set(values.flat())];
      case "priority":
        return values.find((value) => value.length > 0) || [];
      default:
        throw new Error(`不支持的合并策略: ${this.mergeStrategy}`);
    }
  }
}

/**
 * 循环体值对象
 */
class LoopValue extends ValueObject {
  constructor(config) {
    super(config);
    this.jmespath = config.jmespath;
    this.mappings = config.mappings || {};
    if (!this.jmespath) {
      throw new Error("循环体数据源表达式未指定");
    }
  }

  getValue(context) {
    const array = safeJMESPath(context, this.jmespath, []);
    if (!Array.isArray(array)) {
      return [];
    }

    return array.map((item) => {
      const mappedItem = {};
      for (const [key, expression] of Object.entries(this.mappings)) {
        mappedItem[key] = safeJMESPath(item, expression);
      }
      return mappedItem;
    });
  }
}

/**
 * 条件值对象
 */
class ConditionalValue extends ValueObject {
  constructor(config) {
    super(config);
    this.jmespath = config.jmespath;
    this.conditions = config.conditions || [];
    this.else = config.else;
    if (!this.jmespath) {
      throw new Error("条件数据源表达式未指定");
    }
  }

  getValue(context) {
    const data = safeJMESPath(context, this.jmespath, {});
    
    for (const condition of this.conditions) {
      if (safeJMESPath(data, condition.if, false)) {
        return new ValueObjectFactory().create(condition.then).getValue(context);
      }
    }

    return this.else ? 
      new ValueObjectFactory().create(this.else).getValue(context) : 
      null;
  }
}

5.4 值对象工厂

/**
 * 值对象工厂
 */
class ValueObjectFactory {
  constructor() {
    this.typeMap = {
      constant: ConstantValue,
      jmespath: SingleSourceValue,
      multiSource: MultiSourceValue,
      loop: LoopValue,
      conditional: ConditionalValue,
    };
  }

  create(config) {
    const ValueObjectClass = this.typeMap[config.type];
    if (!ValueObjectClass) {
      throw new Error(`不支持的值对象类型: ${config.type}`);
    }
    return new ValueObjectClass(config);
  }
}

5.5 参数映射服务

/**
 * 参数映射服务
 */
class ParameterMappingService {
  constructor(config) {
    this.parameters = config.parameters || [];
    this.factory = new ValueObjectFactory();
  }

  mapParameters(context) {
    const output = {};
    for (const param of this.parameters) {
      try {
        const valueObject = this.factory.create(param.value);
        output[param.name] = valueObject.getValue(context);
      } catch (error) {
        console.error(`处理参数 ${param.name} 时发生错误:`, error);
        output[param.name] = null;
      }
    }
    return output;
  }
}

6. 使用示例

// 配置示例
const config = {
  parameters: [
    {
      name: "version",
      value: {
        type: "constant",
        value: "1.0.0"
      }
    },
    {
      name: "userId",
      value: {
        type: "jmespath",
        jmespath: "userInfo.id"
      }
    },
    {
      name: "permissions",
      value: {
        type: "multiSource",
        sources: {
          rolePerms: "permissions[*].code",
          userPerms: "customPermissions[*]"
        },
        mergeStrategy: "unique"
      }
    }
  ]
};

// 示例数据
const context = {
  userInfo: {
    id: "user123"
  },
  rolePerms: {
    permissions: [
      { code: "READ" },
      { code: "WRITE" }
    ]
  },
  userPerms: {
    customPermissions: ["ADMIN"]
  }
};

// 使用示例
const service = new ParameterMappingService(config);
const result = service.mapParameters(context);
console.log(result);
/* 输出：
{
  version: "1.0.0",
  userId: "user123",
  permissions: ["READ", "WRITE", "ADMIN"]
}
*/