Java电商场景多源字段按业务规则映射TargetDTO的OO设计方案咨询

我正在开发一个Java Spring Boot电商领域后端服务，该服务从Order-Service(OS)获取数据，需要提取部分数据进行转发。

待提取的数据类如下：

class TargetDTO {
    String orderId;
    String shipmentId;
    String trackingUrl;
    String deliveryDate;
    // 其他字段..
}

从OS获取的源数据包含在JsonNode中，无固定Schema，结构如下：

class OSResponseDTO {
   String field1;
   String field2;
   JsonNode sourceData; // 本次问题关注的核心数据
   // 其他字段..
}

数据映射存在两个维度：

1. 源到目标的映射规则：
   • 直接提取：如orderId <=> sourceData.orderId
   • 多字段组合：如shipmentId <=> sourceData.orderId + sourceData.shipments.number
   • 带逻辑转换：如根据地域将sourceData中的deliveryDate转换为指定格式
2. 同一目标字段需根据业务条件（如orderPlacedOnline、orderOutForDelivery等，目前约200种，可归为8-10类）从sourceData的不同JSON路径映射。例如trackingUrl的映射逻辑：

if(orderOutForDelivery) {
  trackingUrl = sourceData.orderDetails.url;
} 
else if(orderPlaced) {
  trackingUrl = sourceData.url;
}
// ...其他条件分支
else if(orderShipped) {
  trackingUrl = sourceData.shipments.url;
}
else {
}

问题 #

我该采用何种可扩展的设计方案来实现上述需求？

已尝试方案 #

为每个目标属性定义映射策略，建立业务场景与策略的映射表，但需维护200+业务场景的映射，且未来场景可能持续增加，扩展性不足。

interface OrderIdStrategy {
  void mapOrderId();
}
class OrderIdStrategy1 implements OrderIdStrategy {
}
class OrderIdStrategy2 implements OrderIdStrategy {
}

interface TrackingUrlStrategy {
  void mapTrackingUrl();
}
class TrackingUrlStrategy1 implements TrackingUrlStrategy {
}
class TrackingUrlStrategy2 implements TrackingUrlStrategy {
}

class DataExtractor {
  Map<String, Set<String>> businessCaseAndUsedStrategiesMapping;

  @PostConstruct
  init() {
     businessCaseAndUsedStrategiesMapping.put("orderPlacedOnline", Set.of("OrderIdStrategy1", "TrackingUrlStrategy2"));
     businessCaseAndUsedStrategiesMapping.put("orderOutForDelivery", Set.of("OrderIdStrategy2", "TrackingUrlStrategy2"));
  // 其他200+场景映射
  }

  mapOrderId(String businessCase) {
     businessCaseAndUsedStrategiesMapping.get(businessCase).mapOrderId();
  }

  mapShipmentId(String businessCase) {
     businessCaseAndUsedStrategiesMapping.get(businessCase).mapShipmentId();
  }

  mapTrackingUrl(String businessCase) {
     businessCaseAndUsedStrategiesMapping.get(businessCase).mapTrackingUrl();
  }
}

1. 抽象通用字段映射器 #

定义一个通用的字段映射接口，替代每个字段单独的策略接口，统一处理所有字段的映射逻辑：

public interface FieldMapper<T> {
    // 从sourceData中提取并转换字段值，返回目标字段类型
    T map(JsonNode sourceData, Map<String, Object> context);
}

这里的context用来传递业务场景标识、地域等额外参数，供映射逻辑使用。

2. 分类实现字段映射逻辑 #

针对不同的映射规则类型，实现通用的FieldMapper：

• 直接提取映射器：根据JSON路径直接取值

public class DirectExtractMapper implements FieldMapper<String> {
    private final String jsonPath;

    public DirectExtractMapper(String jsonPath) {
        this.jsonPath = jsonPath;
    }

    @Override
    public String map(JsonNode sourceData, Map<String, Object> context) {
        return sourceData.at(jsonPath).asText();
    }
}

• 多字段组合映射器：拼接多个路径的取值

public class CombineFieldsMapper implements FieldMapper<String> {
    private final List<String> jsonPaths;
    private final String separator;

    public CombineFieldsMapper(List<String> jsonPaths, String separator) {
        this.jsonPaths = jsonPaths;
        this.separator = separator;
    }

    @Override
    public String map(JsonNode sourceData, Map<String, Object> context) {
        return jsonPaths.stream()
                .map(path -> sourceData.at(path).asText())
                .collect(Collectors.joining(separator));
    }
}

• 带逻辑转换的映射器：比如日期格式转换，可自定义转换逻辑

public class TransformMapper<T> implements FieldMapper<T> {
    private final String jsonPath;
    private final Function<String, T> transformer;

    public TransformMapper(String jsonPath, Function<String, T> transformer) {
        this.jsonPath = jsonPath;
        this.transformer = transformer;
    }

    @Override
    public T map(JsonNode sourceData, Map<String, Object> context) {
        String rawValue = sourceData.at(jsonPath).asText();
        return transformer.apply(rawValue);
    }
}

3. 基于业务场景组的映射配置 #

既然200+业务场景可归为8-10类，先定义场景组，再将具体业务场景关联到场景组，避免重复配置。用配置类或外部配置文件（如YAML）维护字段映射关系，而非硬编码：

配置类示例 #

@ConfigurationProperties(prefix = "order.mapping")
public class MappingConfig {
    // 场景组到字段映射的配置：key是场景组，value是字段名到对应的FieldMapper配置
    private Map<String, Map<String, MapperConfig>> groupMappings;
    // 具体业务场景到场景组的映射
    private Map<String, String> caseToGroup;

    // 内部类，描述单个字段的映射器配置
    public static class MapperConfig {
        private String type; // direct/combine/transform
        private List<String> paths;
        private String separator;
        private String transformerBeanName; // 自定义转换Bean的名称
    }

    // getter/setter
}

YAML配置示例 #

order:
  mapping:
    groupMappings:
      online-order-group:
        orderId:
          type: direct
          paths: ["$.orderId"]
        trackingUrl:
          type: direct
          paths: ["$.url"]
      delivery-group:
        orderId:
          type: direct
          paths: ["$.orderDetails.orderId"]
        trackingUrl:
          type: direct
          paths: ["$.orderDetails.url"]
    caseToGroup:
      orderPlacedOnline: online-order-group
      orderOutForDelivery: delivery-group
      # 其他200+场景关联到对应组

4. 映射器工厂与数据提取器 #

实现工厂类根据配置创建对应的FieldMapper实例；再实现通用的数据提取器，根据业务场景找到对应场景组配置，批量完成TargetDTO的映射：

@Component
public class FieldMapperFactory {
    @Autowired
    private ApplicationContext applicationContext;

    public FieldMapper<?> createMapper(MapperConfig config) {
        switch (config.getType()) {
            case "direct":
                return new DirectExtractMapper(config.getPaths().get(0));
            case "combine":
                return new CombineFieldsMapper(config.getPaths(), config.getSeparator());
            case "transform":
                Function<String, ?> transformer = applicationContext.getBean(config.getTransformerBeanName(), Function.class);
                return new TransformMapper<>(config.getPaths().get(0), transformer);
            default:
                throw new IllegalArgumentException("Unknown mapper type: " + config.getType());
        }
    }
}

@Component
public class GenericDataExtractor {
    @Autowired
    private MappingConfig mappingConfig;
    @Autowired
    private FieldMapperFactory mapperFactory;

    public TargetDTO mapToTarget(OSResponseDTO osResponse, String businessCase) {
        TargetDTO target = new TargetDTO();
        String group = mappingConfig.getCaseToGroup().get(businessCase);
        Map<String, MapperConfig> fieldMappings = mappingConfig.getGroupMappings().get(group);
        Map<String, Object> context = new HashMap<>();
        context.put("businessCase", businessCase);
        // 可添加地域等其他上下文参数

        // 反射或手动设置字段值，这里用手动示例，也可结合ModelMapper等工具
        if (fieldMappings.containsKey("orderId")) {
            FieldMapper<String> mapper = (FieldMapper<String>) mapperFactory.createMapper(fieldMappings.get("orderId"));
            target.setOrderId(mapper.map(osResponse.getSourceData(), context));
        }
        if (fieldMappings.containsKey("trackingUrl")) {
            FieldMapper<String> mapper = (FieldMapper<String>) mapperFactory.createMapper(fieldMappings.get("trackingUrl"));
            target.setTrackingUrl(mapper.map(osResponse.getSourceData(), context));
        }
        // 其他字段同理
        return target;
    }
}

5. 扩展性优化 #

• 新增映射规则类型：只需实现新的FieldMapper，并在工厂类中添加对应的类型分支即可。
• 新增业务场景：只需在YAML配置中添加场景到现有组的关联，无需修改代码；如果场景需要特殊映射，新增一个场景组并配置字段映射即可。
• 复杂转换逻辑：将自定义转换逻辑封装成Spring Bean，在配置中指定Bean名称，实现解耦。

内容的提问来源于stack exchange，提问作者user14642363