Java – use the builder in mapstruct (using the immutables annotation processor) to map objects to immutable objects

We use immutables framework to generate all DTOs Now we want to map these objects to another using mapstruct However, the generated dto is immutable. There is no setter or constructor, corresponding to the builder mode They are populated only by the corresponding builder accessed by the static Builder () – method

We tried to map dto1 to dto2 Builder, mapstruct will work if it can recognize setters in the builder, but these have no void return type, but return the builder itself for smooth connection

So this is the code for the example

We have two interfaces

@Value.Immutable
public interface MammalDto {
  public Integer getNumberOfLegs();
  public Long getNumberOfStomachs();
}

and

@Value.Immutable
public interface MammalEntity {
  public Long getNumberOfLegs();
  public Long getNumberOfStomachs();
}

Then we have mapper interface of mapstruct:

@Mapper(uses = ObjectFactory.class)
public interface SourceTargetMapper {
  SourceTargetMapper MAPPER = Mappers.getMapper( SourceTargetMapper.class );

  ImmutableMammalEntity.Builder toTarget(MammalDto source);
}

In order for maporg to find the builder, we need a factory:

public class ObjectFactory {

  public ImmutableMammalDto.Builder createMammalDto() {
    return ImmutableMammalDto.builder();
  }

  public ImmutableMammalEntity.Builder createMammalEntity() {
    return ImmutableMammalEntity.builder();
  }
}

To generate code, the compiler plug-in is instructed to use two annotation processors:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.6.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <annotationProcessorPaths>
            <path>
                <groupId>org.immutables</groupId>
                <artifactId>value</artifactId>
                <version>2.2.8</version>
            </path>
            <path>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>1.2.0.Beta3</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

Note: this only applies to mapstruct version > 1.2 x. The old version has a problem in MVN clean compile, that is, they can't find the source of immutable build In the second build (not clean), they will find immutables implementations because they are in the classpath before the annotation processor runs This bug has now been fixed

It's like a charm First, immutable implementations of interfaces are generated, and mapstruct uses them to generate builders

However, the test shows that the property is not set:

@Test
public void test() {
  MammalDto s = ImmutableMammalDto.builder().numberOfLegs(4).numberOfStomachs(3l).build();
  MammalEntity t = SourceTargetMapper.MAPPER.toTarget(s).build();
    assertThat(t.getNumberOfLegs()).isEqualTo(4);
    assertThat(t.getNumberOfStomachs()).isEqualTo(3);
}

Assertion failed When you look at the mapper generated by mapstruct, you will find that it obviously does not find any setters:

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",//...
)
public class SourceTargetMapperImpl implements SourceTargetMapper {
    private final ObjectFactory objectFactory = new ObjectFactory();

    @Override
    public Builder toTarget(MammalDto source) {
        if ( source == null ) {
            return null;
        }

        Builder builder = objectFactory.createMammalEntity();
        return builder;
    }
}

Returns an empty builder I think the reason is the setter implementation of the generated builder, because it returns itself to create a smooth API:

public final Builder numberOfLegs(Long numberOfLegs) {
  this.numberOfLegs = Objects.requireNonNull(numberOfLegs,"numberOfLegs");
  return this;
}

Is there any way for mapstruct to find these setters? Or even a better way to handle these immutable objects with a builder?

Editor: as I said in my comments, I met issue #782 In version 1.2 0. Beta 3 is still not supported by the builder But there are several discussions on this topic, so if one encounters the same problem, he may be interested

Solution

Our project has the same problem

You can also try It's better to use builders and object factories directly

@ Value. Modifiable uses setters to generate implementations

@ Value. Style (create = "new") generates the public no args constructor

@Value.Immutable
@Value.Modifiable
@Value.Style(create = "new")
public interface MammalEntity {
    public Long getNumberOfLegs();
    public Long getNumberOfStomachs();
}

Then your mapper will be simpler and does not need to be in an object factory

@Mapper
public interface SourceTargetMapper {

  ModifiableMammalEntity toTarget(MammalDto source);
}

In this case, mapstruct can see the setter in modifiable mammalentity

The usage of this mapper looks like

// Here you don't need to worry about implementation of MammalEntity is. The interface `MammalEntity` is immutable.
MammalEntity mammalEntity = sourceTargetMapper.toTarget(source);