ModelMapper实现DTO到不可变领域对象的构造方法映射问题

Absolutely! ModelMapper totally supports building immutable domain objects via their constructors instead of relying on setters—you just need to tweak a few configurations to handle the mismatch between your DTO and domain object field counts. Let me walk you through exactly how to make this work:

1. Configure ModelMapper for constructor-based mapping #

First, adjust ModelMapper's settings to ensure it prioritizes constructors (since your domain object has no no-arg constructor) and can map fields directly even without setters. Here's the base configuration:

ModelMapper modelMapper = new ModelMapper();
Configuration config = modelMapper.getConfiguration();

// Enable field matching to map DTO properties directly to constructor parameters
config.setFieldMatchingEnabled(true);

// Use a loose matching strategy to automatically ignore extra DTO fields not present in the domain object's constructor
config.setMatchingStrategy(MatchingStrategies.LOOSE);

2. Handle extra DTO fields #

Since your DTO has 2 more fields than your domain object, you have two straightforward options:

• Option 1: Let loose matching handle it automatically
  With MatchingStrategies.LOOSE, ModelMapper will ignore any DTO fields that don't have a corresponding parameter in the domain object's constructor (this works because you confirmed the overlapping fields have identical names and types).

• Option 2: Explicitly skip extra fields (for stricter control)
  If you prefer explicit configuration (great for long-term maintainability), create a TypeMap to define exactly which fields to skip:

modelMapper.createTypeMap(YourDTO.class, YourImmutableDomain.class)
    .addMappings(mapper -> {
        // Replace with the actual names of your extra DTO fields
        mapper.skip(YourImmutableDomain.class, "extraField1");
        mapper.skip(YourImmutableDomain.class, "extraField2");
    });

3. Ensure constructor parameter names are detectable #

ModelMapper uses constructor parameter names to match with DTO properties. By default, Java doesn't retain these names in compiled bytecode, so fix this with one of two approaches:

• Enable the -parameters compiler flag
  For Maven, add this to your pom.xml:

  <build>
      <plugins>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.11.0</version>
              <configuration>
                  <parameters>true</parameters>
              </configuration>
          </plugin>
      </plugins>
  </build>
  

  For Gradle, add this to your build.gradle:

  tasks.withType(JavaCompile) {
      options.parameters = true
  }
  

• Use the @ConstructorProperties annotation
  If you can't modify compiler settings, annotate your domain object's constructor to explicitly map parameter names to property names:

  public class YourImmutableDomain {
      private final String fieldA;
      private final int fieldB;
      // ... your other 2 fields (total 4)
  
      @ConstructorProperties({"fieldA", "fieldB", "fieldC", "fieldD"})
      public YourImmutableDomain(String fieldA, int fieldB, String fieldC, long fieldD) {
          this.fieldA = fieldA;
          this.fieldB = fieldB;
          this.fieldC = fieldC;
          this.fieldD = fieldD;
      }
  }
  

Once you have these settings in place, ModelMapper will seamlessly map your DTO to the immutable domain object using its constructor—no more errors from missing no-arg constructors or setters!

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