What is the best way to map Optional to Optional in a generic way and not do a manually mapping for every Optional?
e.g.
Optional<PersonDto> mapDto(Optional<Person> person)
Optional<Integer> mapInt(Optional<Integer> person)
EDIT:
Currently what I tried
public abstract class DefaultOptionalMapper<E, D> {
public abstract D entityToDTO( E entity );
public abstract E dtoToEntity( D dto );
public Optional<D> optionalEntityToOptionalDTO( final Optional<E> optionalEntity ) {
return optionalEntity.map( this::entityToDTO );
}
public Optional<E> optionalDTOToOptionalEntity( final Optional<D> optionalDTO ) {
return optionalDTO.map( this::dtoToEntity );
}
}
1
Using stream api it’s possible, but it’s necessary to write java code. MapStruct is good for mapping fields, also default values, constants, some checks, but not for dynamic mapping, here it’s necessary to right native java code.
Something like:
import java.util.Optional;
import java.util.function.Function;
public interface GenericMapper {
static <T, U> Optional<U> mapOptional(Optional<T> source, Function<T, U> mapper) {
return source.map(mapper);
}
}
And in your code it would look like :
Optional<Person> person = Optional.of(new Person("John", 30));
Optional<PersonDto> personDto = GenericMapper.mapOptional(person, p -> new PersonDto(p.getName(), p.getAge()));
6