mapstruct map iterable to non iterable - spring

Question

I want to map a list of Objects to an Object that contains a list:
public class Group {
private List<Person> people;
}
public class Person {
private String name;
}
I tried creating a mapper like this:
Group toGroup(List<Person> people);
and I'm getting this error:
error: Can't generate mapping method from iterable type to non-iterable type.
What is the most elegant solution for this kind of mapping?

Answer 1

Mapstruct actually can do it. I have the exact same situation, a CollectionResponse that just contains items. I worked around it by adding a dummy parameter like this:
#Mapper(componentModel = "spring", uses = ItemMapper.class)
public interface CollectionResponseMapper {
// Dummy property to prevent Mapstruct complaining "Can't generate mapping method from iterable type to non-iterable type."
#Mapping( target = "items", source = "items")
CollectionResponse map( Integer dummy, List<Item> items);
}
Mapstruct generates the desired code. Something like this:
public class CollectionResponseMapperImpl implements CollectionResponseMapper {
#Autowired
private ItemMapper itemMapper;
#Override
public CollectionResponse map(Integer dummy, List<Item> items) {
if ( dummy == null && items == null ) {
return null;
}
CollectionResponse collectionResponse = new CollectionResponse();
if ( items != null ) {
collectionResponse.setItems( itemListToItemDtoList( items ) );
}
return collectionResponse;
}
protected List<ItemDto> itemListToItemDtoList(List<Item> list) {
if ( list == null ) {
return null;
}
List<ItemDto> list1 = new ArrayList<ItemDto>( list.size() );
for ( Item item : list ) {
list1.add( itemMapper.mapItemToDto( item ) );
}
return list1;
}
}

Answer 2

General answer - Such mapping is prohibited.
To map a list of objects to an object that would wrap this list could be done by:
/// your class with business code
List<Person> people = ....
new Group(people);
/// group class
public class Group {
private List<Person> people = new ArrayList<>();
public Group(List<Person> people) {
this.people = people
}
}
When the Group would just have simply constructor with a list as param. You don't need to use Mapstruct for this.
In the mapstruct sources have this check Mapstruct github sources for MethodRetrievalProcessor.java:
Type parameterType = sourceParameters.get( 0 ).getType();
if ( parameterType.isIterableOrStreamType() && !resultType.isIterableOrStreamType() ) {
messager.printMessage( method, Message.RETRIEVAL_ITERABLE_TO_NON_ITERABLE );
return false;
}
So basically even Mapstruct team wants you to use mapping only when you need it. And doesn't want to allow transforming List<Object> to another Object as it doesn't make sense.
This would make some sense if you're adding some additional information(non-iterable :) ) for your Group object, for example:
//group class
public class Group {
private Long someCounter;
private List<Person> people;
}
//mapper
#Mapping(target= "people", source ="people")
#Mapping(target= "someCounter", source ="counterValue")
Group toGroup(Long counterValue, List<Person> people);
But better use DTOs, Views, Entites and any other kind of objects that would hide all the nested stuff. In this case Mapstruct would be your greatest friend.