基于Spring实现源数据部分属性分发给多目标系统的方案咨询

Hey there! Let's walk through practical Spring-based solutions for your integration scenario where you need to map a 10-property source object to two target systems requiring 6 and 4 properties respectively. These approaches are widely used in Spring ecosystems and balance maintainability, performance, and simplicity.

1. DTO Layer + Spring's Built-in Converter Interface #

This is a native Spring approach that fits seamlessly with the framework's conversion system.

• Step 1: Define Target DTOs
  Create dedicated Data Transfer Objects for each target system to match their required properties:

  // Target System 1 DTO (6 properties)
  public class TargetSystem1DTO {
      private String prop1;
      private Integer prop2;
      private Double prop3;
      private LocalDate prop4;
      private Boolean prop5;
      private String prop6;
      // Getters, setters, constructors
  }
  
  // Target System 2 DTO (4 properties)
  public class TargetSystem2DTO {
      private String prop1;
      private Integer prop7;
      private String prop8;
      private LocalDateTime prop9;
      // Getters, setters, constructors
  }
  

• Step 2: Implement Spring Converter
  Write converter classes that implement Spring's Converter<S, T> interface to handle mapping from your source object to each target DTO:

  @Component
  public class SourceToTarget1Converter implements Converter<SourceData, TargetSystem1DTO> {
      @Override
      public TargetSystem1DTO convert(SourceData source) {
          TargetSystem1DTO dto = new TargetSystem1DTO();
          dto.setProp1(source.getProp1());
          dto.setProp2(source.getProp2());
          dto.setProp3(source.getProp3());
          dto.setProp4(source.getProp4());
          dto.setProp5(source.getProp5());
          dto.setProp6(source.getProp6());
          // Handle any custom conversion logic here (e.g. type conversion, default values)
          return dto;
      }
  }
  
  @Component
  public class SourceToTarget2Converter implements Converter<SourceData, TargetSystem2DTO> {
      @Override
      public TargetSystem2DTO convert(SourceData source) {
          TargetSystem2DTO dto = new TargetSystem2DTO();
          dto.setProp1(source.getProp1());
          dto.setProp7(source.getProp7());
          dto.setProp8(source.getProp8());
          dto.setProp9(source.getProp9());
          return dto;
      }
  }
  

• Step 3: Use ConversionService in Your Service
  Inject Spring's ConversionService into your integration service to trigger the conversions:

  @Service
  public class IntegrationService {
      private final ConversionService conversionService;
  
      public IntegrationService(ConversionService conversionService) {
          this.conversionService = conversionService;
      }
  
      public void sendToTargetSystems(SourceData sourceData) {
          TargetSystem1DTO target1 = conversionService.convert(sourceData, TargetSystem1DTO.class);
          TargetSystem2DTO target2 = conversionService.convert(sourceData, TargetSystem2DTO.class);
          
          // Call APIs for Target System 1 and 2 with the respective DTOs
          // targetSystem1Client.send(target1);
          // targetSystem2Client.send(target2);
      }
  }
  

2. MapStruct (Recommended for Scalable Scenarios) #

MapStruct is a code-generation library that creates type-safe mapping implementations at compile time (no reflection overhead). It integrates smoothly with Spring.

• Step 1: Add MapStruct Dependency
  For Maven, add this to your pom.xml:

  <dependency>
      <groupId>org.mapstruct</groupId>
      <artifactId>mapstruct</artifactId>
      <version>1.5.5.Final</version>
  </dependency>
  <dependency>
      <groupId>org.mapstruct</groupId>
      <artifactId>mapstruct-processor</artifactId>
      <version>1.5.5.Final</version>
      <scope>provided</scope>
  </dependency>
  

• Step 2: Define Mapping Interfaces
  Create mapper interfaces annotated with @Mapper and set componentModel = "spring" to let Spring manage the bean:

  @Mapper(componentModel = "spring")
  public interface TargetSystem1Mapper {
      TargetSystem1Mapper INSTANCE = Mappers.getMapper(TargetSystem1Mapper.class);
      
      TargetSystem1DTO sourceToTarget1(SourceData source);
      // MapStruct automatically maps properties with matching names; use @Mapping for custom mappings
      // e.g., @Mapping(source = "sourceProp", target = "targetProp")
  }
  
  @Mapper(componentModel = "spring")
  public interface TargetSystem2Mapper {
      TargetSystem2Mapper INSTANCE = Mappers.getMapper(TargetSystem2Mapper.class);
      
      TargetSystem2DTO sourceToTarget2(SourceData source);
  }
  

• Step 3: Inject Mappers in Your Service
  Use the generated mapper beans directly in your integration service:

  @Service
  public class IntegrationService {
      private final TargetSystem1Mapper target1Mapper;
      private final TargetSystem2Mapper target2Mapper;
  
      public IntegrationService(TargetSystem1Mapper target1Mapper, TargetSystem2Mapper target2Mapper) {
          this.target1Mapper = target1Mapper;
          this.target2Mapper = target2Mapper;
      }
  
      public void sendToTargetSystems(SourceData sourceData) {
          TargetSystem1DTO target1 = target1Mapper.sourceToTarget1(sourceData);
          TargetSystem2DTO target2 = target2Mapper.sourceToTarget2(sourceData);
          
          // Proceed to send data to target systems
      }
  }
  

3. Manual Mapping (For Simple, One-Off Cases) #

If your mapping logic is trivial and you don't want to introduce extra dependencies, manual mapping in your service layer works:

@Service
public class IntegrationService {
    public void sendToTargetSystems(SourceData sourceData) {
        // Map to Target System 1
        TargetSystem1DTO target1 = new TargetSystem1DTO();
        target1.setProp1(sourceData.getProp1());
        target1.setProp2(sourceData.getProp2());
        // ... set remaining 4 properties

        // Map to Target System 2
        TargetSystem2DTO target2 = new TargetSystem2DTO();
        target2.setProp1(sourceData.getProp1());
        target2.setProp7(sourceData.getProp7());
        // ... set remaining 2 properties

        // Send to target systems
    }
}

Key Best Practices #

• Keep Source Object Pure: Never modify your source data object to accommodate target system requirements; use DTOs to adapt the data.
• Test Mappings: Write unit tests for your converters/mappers to ensure all required properties are mapped correctly (especially if you have custom logic).
• Handle Edge Cases: Add null checks, default values, or type conversion logic in your mappings to avoid runtime errors when source fields are missing.

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