Lazily transform attributes in Mappers

[debembe]

I am currently working on a Codebase with complex datatypes and cyclic references between them.
When I try to convert from one type to the next, I eventually run into the following exception:

Caused by: org.springframework.core.convert.ConversionFailedException: Failed to convert from type [X] to type [Y] for value [X@2b86b984]
...
Caused by: java.lang.StackOverflowError: null

I already implemented the CycleAvoidingMappingContext referenced in the examples and read through a lot of discussions online.

The core problem as I see it is, that there are too many entities that are loaded when I try to convert types. These attributes however are needed and cannot be ignored like suggested in other issues.

Is there any possible way to transform these fields lazily, only when their getter is called? Or is there another solution to this problem?

Thanks in advance!

[filiphr]

Is there any possible way to transform these fields lazily, only when their getter is called? Or is there another solution to this problem?

Can you provide an example of how you would do it without MapStruct?

MapStruct is an annotation processor that is going to generate mapping code as if it has been written by hand. We don't do any reflection during runtime.

These attributes however are needed and cannot be ignored like suggested in other issues.

Why do you need to carry the cycles in the mapping? What's the use case that you have?

[debembe]

Can you provide an example of how you would do it without MapStruct?

If I would have the following sets of classes:

class Person {
    @Getter
    @Setter
    private Car car;
}

class Car {
    @Getter
    @Setter
    private String brand;
}

class PersonV1 {
    @Getter
    @Setter
    private CarV1 car;
}

class CarV1 {
    @Getter
    @Setter
    private String brandName;
}

These would be (roughly) the manual converters:

class PersonConverter implements Converter<PersonV1, Person> {
    CarConverter carConverter;

    @Override
    public Person convert(PersonV1 source) {
        var person = new Person();

        var car = carConverter.convert(source.getCar());
        person.setCar(car);

        return person;
    }
}

class CarConverter implements Converter<CarV1, Car> {
    @Override
    public Car convert(CarV1 source) {
        var car = new Car();
        car.setBrand(source.getBrandName());
        return car;
    }
}

My question is: can the conversion of complex datatypes, the car in this example, be lazily triggered when getCar is called and not beforehand?

var car = carConverter.convert(source.getCar());
person.setCar(car);

var car = person.getCar() // ideally the conversion should happen only here

Why do you need to carry the cycles in the mapping? What's the use case that you have?
It's not only about cycles. I have to represent complex data structures with lots of entities and connections between them. Mapping one entity greedily, like it is currently done by mapstruct, overloads the process, because all of those transitive entities are also converted and their entitites also. I only want to convert what fields are actually requested, which I do not know at compile time.

Another option would be to "filter" the fields beforehand and set everything that is not needed to null, but ideally I would love to have the flexibility to only transform fields lazily when needed. Any ideas?

Thanks in advance for your help!

[filiphr]

@debembe I am not sure that I am following your example. How would the code for this lazy conversion look like if MapStruct was not there?

[debembe]

Ideally the conversion would happen within the getter itself:

class Person {
   private CarV1 originalCar;
   private Car car;
   
   public void setCar(Car car) {
       this.car = car;
   }
   
   public Car getCar() {
       var car = carConverter.convert(this.originalCar);
       this.setCar(car);
       return car;
   }
}

This way, the conversion would only happen when needed (when getCar is called). When the Car is not needed, it isn't transformed. But this would require keeping the original objects (e.g. originalCar) in memory and modifying the original class, so maybe you have a better idea!

Thanks in advance :)

[filiphr]

I don't have a better idea, that's why I am asking you how you would write this by hand.

MapStruct only generates mapping code between two objects, if you want to do some things lazy then you would have to invoke MapStruct on your side at the right time. We are not using any reflection in the generated code.