Mapping a list to a map and vice versa

[hinrik]

I sometimes want to flatten a map into a list (and vice versa), e.g. when I'm converting from different representations (e.g. Avro to/from application domain). I have to do the entire mapping with a default method on my mapper interface, duplicating some logic that MapStruct could have taken care of for me.

There are two general use cases I run into.

Flattening a multi-value map

{
  "monday": {
    "times": ["11:00", "16:00"],
    "type": "foo"
  },
  "wednesday": {
    "times": ["14:00", "19:00"],
    "type": "bar"
  }
}

Target:

[
  {"day": "monday", "times": ["11:00", "16:00"], "type": "foo"},
  {"day": "wednesday", "times": ["14:00", "19:00"], "type": "bar"},
]

Here I wish I could do something like @Mapping(target = "schedule", source = "flatSchedule", flatKey = "day"). which would also work if source and target were flipped.

Flattening a single-value map

Source:

{
  "monday": ["11:00", "16:00"],
  "wednesday": ["14:00", "19:00"]
}

Target:

[
  {"day": "monday", "times": ["11:00", "16:00"]},
  {"day": "wednesday", "times": ["14:00", "19:00"]},
]

This example is similar, except here the value in the source map is not a bean, so we need to introduce a key for it in the target map. Here I wish I could do @Mapping(target = "schedule", source = "flatSchedule", flatKey = "day", flatValue = "times").

Would this be worth implementing in MapStruct?

[filiphr]

I don't like to introduce something like flatKey and flatValue for MapStruct.

What I am open to consider is to provide special handling for mapping from Map.Entry and support mapping from Map to Iterable

Perhaps something in the form of:

@Mapper
public interface MyMapper {

    List<FlattenedTarget> map(Map<String, Source> source);

    @Mapping(target = "day", source = "key")
    @Mapping(target = ".", source = "value")
    FlattenedTarget map(Map.Entry<String, Source> entry);
}

The second example will look like:

@Mapper
public interface MyMapper {

    List<FlattenedTarget> map(Map<String, Source> source);

    @Mapping(target = "day", source = "key")
    @Mapping(target = "times", source = "value")
    FlattenedTarget map(Map.Entry<String, Source> entry);
}

[hinrik]

How would you do the reverse mapping? I don't know of any native map entry which MapStruct can map to (due to unambiguous constructors), so even the step of converting FlattenedSource to Map.Entry<> is unclear.

[filiphr]

From Java 9 there is Map.entry(key, value) that we could support. In addition to that we can look into extending @MapMapping to be able to map a bean or a collection of beans into a map.

We can also only support one way as a first step and let people use stream and collectors with a default method

e.g.

@Mapper
public interface MyMapper {

    default Map<String, Target> map(Collection<Source> collection) {
        return collection.stream().collect(Collectors.toMap(Source::getDay, this::map));
    }

    Target map(Source source);
}

[Michael1993]

If it's a 1 to 1 mapping, you don't have to use Map.Entry, this would be cleaner.

@Mapper
public interface MapMapper {

    List<Target> map(Map<SourceKey, SourceValue> map);

    // mapping annotations
    Target map(SourceKey key, SourceValue value);

}

@Mapper
public interface ReverseMapMapper {

    Map<TargetKey, TargetValue> map(List<Source> list);

    // mapping annotations 
    TargetKey key(Source source);

    // mapping annotations 
    TargetValue value(Source source);

}

[hinrik]

@Michael1993 Your MapMapper example would indeed be clean.

However, if the key and value types are the same (e.g. String as in my case) then ReverseMapMapper would require qualifiedByName boilerplate for both properties as well as some new target syntax to reference the key or value of a target map entry.

[Michael1993]

Hm. 🤔

How about this:

@Key("property")
@Value("otherProperty")
Map<String, String> map(List<Source> values);

Could be KeyMapping, ValueMapping but you get the general idea.

[hinrik]

It wouldn't feel so "MapStructy" if mapping in one direction would require more annotation boilerplate than the other direction.

Supporting Map.Entry as @filiphr suggested seems like it would offer a lot of flexibility. Continuing their suggestion, the reverse mapping of my original example would then look something like this:

// First example
@Mapper
public interface ReverseMapper {
    Map<String, Target> map(List<FlattenedSource> source);

    @Mapping(target = "key", source = "day")
    @Mapping(target = "value", source = ".")
    Map.Entry<String, Target> map(FlattenedSource item);

    Target map(FlattenedSource item);
}

// Second example
@Mapper
public interface ReverseMapper {
    Map<String, List<String> map(List<FlattenedSource> source);

    @Mapping(target = "key", source = "day")
    @Mapping(target = "value", source = "times")
    Map.Entry<String, List<String> map(FlattenedSource item);
}

[filiphr]

Thanks @hinrik and @Michael1993 for the discussions. I really like the direction of this. I've created #3580 so that we can track it as a feature.

This might be a bit more complex feature to implement. However, if someone from the community is interested in working on it please let us know, we can help you out