We Keep Coding

can't map property. Consider to declare/implement a mapping method. Can't generate mapping method from non-iterable type to iterable type

I can't seem to use mapstruct correctly
#Mapping(target = "products", source = "itemBookType")
SearchBookingResult backToTp(ItemBook itemBook);
When running this code I get the following error:
Can't map property "ProductType itemBookType" to "List<ProductOverview> products". Consider to declare/implement a mapping method: "List<ProductOverview> map(ProductType value)".
I added the following code at the bottom:
List<ProductOverview> map(ProductType value);
but still it returns me the following error:
Can't generate mapping method from non-iterable type to iterable type from java stdlib.
Itembook class:
public class ItemBook {
private ProductType itemBookType; //ProductType class
private Integer idref;
private String reference;
}
ProductType class:
public enum ProductType {
BOOK, PHONE, GAME
}
SearchBookingResult class:
public class SearchBookingResult extends BaseResponse<SearchBookingResult> {
private String reference;
private List<ProductOverview> products;
}
the Mapper
#Mapper(componentModel = "spring")
public interface ItemBookMapper {
ItemBookTpMapper INSTANCE = Mappers.getMapper(ItemBookTpMapper.class);
#Mapping(target = "reference", source = "idref")
#Mapping(target = "products", source = "itemBookType")
SearchBookingResult backToTp(ItemBook itemBook);
List<ProductOverview> map(ProductType value);
}
ProductOverView class is abstract:
public abstract class ProductOverview implements Serializable {
private ProductType productType;
public ProductOverview(ProductType productType) {
this.productType = productType;
}
public ProductType getProductType() {
return productType;
}
}
map reference work but products return many error.

MapStruct can't generate mapping method from non-iterable type to iterable type because it's impossible to create a generic mapping.
The only solution, as suggested by the exception, is to create a custom method where you can implement your own mapping algorithm.
#Mapper(componentModel = "spring")
public interface ItemBookMapper {
ItemBookMapper INSTANCE = Mappers.getMapper(ItemBookMapper.class);
#Mapping(target = "reference", source = "idref")
#Mapping(target = "products", source = "itemBookType", qualifiedByName = "mapProducts")
SearchBookingResult backToTp(ItemBook itemBook);
#Named("mapProducts")
default List<ProductOverview> mapProducts(ProductType value){
List<ProductOverview> products = new ArrayList<>();
//add your custom mapping implementation
return products;
}
}
Official documentation: adding-custom-methods
Baeldung tutorial: mapstruct-custom-mapper

How can I use spring injection, A repository class in a mapstruct mapper?

#Data
public class FilesDTO {
private int issue;
private String uniqueStr;
private StorageDomain xml;
private StorageDomain pdf;
private StorageDomain stop;
}
#Data
public class BackHalfDomain {
private int articleId;
private String uniqueStrr;
private long xmlContentId;
private long pdfContentId;
private long stopId;
private int issueNumber;
}
Using a repository class I have to fetch a StorageDomain object from the ID in BackHalfDomain. So I have to map StorageDomain object with respective fields.
like StorgeDomain sd = repo.findById(id).get(); and set this sd object in FilesDTO's xml field and so on.
This is my mapper
#Mapper(componentModel = "spring")
public interface FilesDTOMapper {
public static final FilesDTOMapper fileDTOMapper = Mappers.getMapper(FilesDTOMapper.class);
#Mapping(target = "issue", source = "domain.issueNumber")
#Mapping(target = "DOI", source = "domain.doi")
public FilesDTO map(BackHalfDomain domain);
}
I have used uses but wasn't successful.
I have used #Mapping(target="xyz", expression="java(repo.findById(id))")"
but all I got was NullPointerException
Spring injection isin't working.
Can someone have a solution for this? I am just started with mapstruct

Since mapstruct 1.2 you can use a combination of #AfterMapping and #Context.
#Mapper(componentModel="spring")
public interface FilesDTOMapper {
#Mapping(target = "xyz", ignore = true)
#Mapping(target = "issue", source = "domain.issueNumber")
#Mapping(target = "DOI", source = "domain.doi")
FilesDTO map( BackHalfDomain domain, #Context MyRepo repo);
#AfterMapping
default void map( #MappingTarget FilesDTO target, BackHalfDomain domain, #Context MyRepo repo) {
target.setXYZ(repo.findById(domain.getId()));
}
}
In 1.1 you would need to transform the mapper to a abstract class
#Mapper(unmappedTargetPolicy = org.mapstruct.ReportingPolicy.IGNORE,
componentModel = "spring",
uses = {})
public abstract class FilesDTOMapper {
#Autowired
protected MyRepo repo;
#Mapping(target = "issue", source = "domain.issueNumber")
#Mapping(target = "DOI", source = "domain.doi")
#Mapping(target="xyz", expression="java(repo.findById(domain.getId())))")
public FilesDTO map(BackHalfDomain domain);
}

I ran into this same problem. The solution was to use a Decorator as suggested in this answer. Following your code, the solution would be something like the following.
First, we have to specifiy the Decorator in the Mapper:
#Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
#Primary
#DecoratedWith(FilesDTOMapperDecorator.class)
public interface FilesDTOMapper {
// basic mapping here
public FilesDTO map(BackHalfDomain domain);
}
Then, implement the Decorator:
public abstract class FilesDTOMapperDecorator implements FilesDTOMapper {
#Autowired
#Qualifier("delegate")
private FilesDTOMapper delegate;
#Autowired
private SomeRepository someRepository;
#Override
public FilesDTO map(BackHalfDomain domain) {
// Delegate basic mapping
FilesDTO filesDTO = delegate.map(domain);
// Use the repository as needed to set additional mapping
filesDTO.setSomeValue(repo.findById(id).getSomeValue());
return filesDTO;
}
}

Transform Entity-object into an Object with framework the MapStruct

I have an entity that gets "userType" during a query to the database.
public class OrderEntityXml {
#Id
#SequenceGenerator(name = "jpa.Sequence.t.order", sequenceName = "T_ORDER_SEQ", allocationSize = 1)
#GeneratedValue(generator = "jpa.Sequence.t.order", strategy = GenerationType.SEQUENCE)
private Long id;
private String customer;
#Type(type = "Order")
#Column(name = "order_xml")
private Order order;
public OrderEntityXml() {
}
There is an container for getting from an entity.
This container is using by Jackson.
This container also is using marshaller and unmarshaller
#XmlRootElement
#JacksonXmlRootElement(localName = "order")
public class Order implements Serializable {
private String customer;
#XmlElement(name = "orderItem")
#JacksonXmlProperty(localName = "orderItem")
#JacksonXmlElementWrapper(useWrapping = false)
private List<OrderItem> orderItems = new ArrayList<>();
public Order() {
}
public class OrderItem {
private String sku;
private Double price;
public OrderItem() {
}
I have set up a MapStruct.
CycleAvoidingMappingContext - ( This is necessary to avoid Cycling (and the appearance of stack overflow))
#Component
public class CycleAvoidingMappingContext {
private Map<Object, Object> knownInstances = new IdentityHashMap<Object, Object>();
#BeforeMapping
public <T> T getMappedInstance(Object source, #TargetType Class<T> targetType) {
T t = (T) knownInstances.get(source);
return t;
}
#BeforeMapping
public void storeMappedInstance(Object source, #MappingTarget Object target) {
knownInstances.put( source, target );
}
}
public interface CommonMapper<D, E> {
D toDto(E e, #Context CycleAvoidingMappingContext context);
E toEntity(D d, #Context CycleAvoidingMappingContext context);
Iterable<D> toListDto(Iterable<E> entityList);
Iterable<E> toListEntity(Iterable<D> dtoList);
}
MapperUtils - (This is utils for MapStruct)
public static Order convertToDto(OrderEntityXml orderEntityXml){
Order order = new Order();
String customer = orderEntityXml.getCustomer();
order.setCustomer(customer);
Order xmlOrder = orderEntityXml.getOrder();
List<OrderItem> orderItems = xmlOrder.getOrderItems();
order.setOrderItems(orderItems);
return order;
}
public static OrderEntityXml convertToEntity(Order order){
OrderEntityXml orderEntityXml = new OrderEntityXml();
String customer = order.getCustomer();
orderEntityXml.setCustomer(customer);
List<OrderItem> orderItems = order.getOrderItems();
Order orderInEntity = new Order();
orderInEntity.setOrderItems(orderItems);
orderInEntity.setCustomer(customer);
orderEntityXml.setOrder(orderInEntity);
return orderEntityXml;
}
OrderDtoMapper - It is basic interface for me, for classes generation
#Mapper(componentModel = "spring")
public interface OrderDtoMapper extends CommonMapper<Order, OrderEntityXml> {
#Override
default Order toDto(OrderEntityXml orderEntityXml, CycleAvoidingMappingContext context) {
return convertToDto(orderEntityXml);
}
#Override
default OrderEntityXml toEntity(Order order, CycleAvoidingMappingContext context) {
return convertToEntity(order);
}
#Override
default Iterable<Order> toListDto(Iterable<OrderEntityXml> entityList) {
Iterable<Order> collect = StreamSupport.stream(entityList.spliterator(), false)
.map(MapperUtils::convertToDto)
.collect(Collectors.toList());
return collect;
}
}
For each data type, you will have to make your own utilities, and this is cumbersome.
Сan I remove extra code and configure it via MapStruct interfaces ?
I suspect I've complicated the code.
Сan anyone tell you what needs to be tweaked or what technology can be applied to mapStruct to make the code unified

Looking at the posted entities I don't see why you need to use CycleAvoidingMappingContext. There is no cyclic dependency between your objects.
In order to avoid the manual code you've written you can use the MapStruct #Mapping annotation to customize how certain fields need to be mapped.
So in your case it would be something like:
#Mapper(componentModel = "spring")
public interface OrderDtoMapper extends CommonMapper<Order, OrderEntityXml> {
#Override
#Mapping(target = "orderItems", source = "order.orderItems")
Order toDto(OrderEntityXml orderEntityXml, #Context CycleAvoidingMappingContext context);
#Override
#Mapping(target = "order", source = "order")
OrderEntityXml toEntity(Order order, CycleAvoidingMappingContext context);
Order cloneOrder(Order order);
}
The only customizations you need are the following:
For toDto to tell MapStruct that when you are mapping from OrderEntityXml to Order you want to map the order.orderItems into the orderItems.
For toEntity to tell MapStruct that you when you are mapping from Order to OrderEntityXml you want to map the method order parameters into the order of the `OrderEntityXml
Additionally we add Order cloneOrder(Order) so that MapStruct creates a new object when mapping between Order otherwise the same object will be used.
The customer in both cases will be automatically mapped, since it matches on both sides.
There is no need to provide custom method for the Iterable mapping because MapStruct will do that automatically for you. It knows

Passing additional parameters to MapStruct mapper

Haven't figured out how to pass in additional arguments or an alternative.
Currently I'm mapping an Order and OrderLines. Both objects are different and need #mappings. Example I have an Order and OrderRequest object both are different and need #Mappings annotation to map the values, same with OrderLines.
I've created the following mappers
OrderMapper (uses = OrderLineMappers.class)
OrderLineMappers (uses = OrderLineMapper.class)
OrderLineMapper
So my issue is the OrderLine needs the OrderId from the Order object. However in the OrderLineMapper it's passing in the OrderLine and not the Order. How can I send the OrderId to the OrderLineMapper? Currently I have the OrderMapper doing an #AfterMapper, looping through the orderLines and populating with the OrderId.
Any help would be great.
Class OrderMapper
#Mapper(componentModel = "spring", uses = {OrderLineMappers.class})
public abstract class OrderMapper {
#AfterMapping
protected void orderRequestFromOrder( Order order, #MappingTarget
OrderRequest orderRequest ) {
//Wanting to do this at the OrderLineMapper class and not here
String orderId = order.getId();
List<OrderLineRequest> lines = orderRequest.getOrderLines();
List<OrderLineRequest> updatedLines = new ArrayList<>();
for (OrderLineRequest line : lines) {
line.setOrderId(orderId);
updatedLines.add(line);
}
orderRequest.setOrderLines(updatedLines);
}
#Mappings({
#Mapping( source = "orderId", target = "id" ),
#Mapping( source = "orderNumber", target = "order_number" ),
#Mapping( source = "orderLines", target = "orderLines")
})
public abstract Order orderRequestToOrder(OrderRequest orderRequest);
Class OrderLineMappers
#Mapper(componentModel = "spring", uses = {OrderLineMapper.class})
public interface OrderLineMappers {
List<OrderLine> orderLines(List<OrderLineRequest> orderLineRequest);
#InheritInverseConfiguration
List<OrderLineRequest> orderLineRequests(List<OrderLine> orderLine);
}
Class OrderLineMapper
#Mapper(componentModel = "spring")
public abstract class OrderLineMapper {
#Mappings({
#Mapping( target = "orderId", source = "orderLineId" ),
#Mapping( target = "order_line_number", source = "orderLineNumber")
})
public abstract OrderLine orderLineRequestToOrderLine(OrderLineRequest orderLineRequest);
}
Again just trying to pass in the OrderId to the OrderLineMapper. Not sure how to do this.

You can't really do this. What you can do instead is to use the #Context and perform your logic in it. You can have #AfterMapping and #BeforeMapping in your context where you can store the Order id and use that during its execution
e.g.
public class OrderMappingContext {
protected String currentOrderId;
#BeforeMapping
public void startMappingOrder(#MappingTarget Order order, OrderRequest request) {
this.currentOrderId = request.getId();
}
#AfterMapping
public void finishOrderMapping(#MappingTarget Order order) {
this.currentOrderId = null;
}
#AfterMapping
public void afterOrderLineMapping(#MappingTarget OrderLine orderLine) {
orderLine.setOrderId(this.currentOrderId);
}
}
Your mappers will then look like:
#Mapper(componentModel = "spring", uses = {OrderLineMappers.class})
public abstract class OrderMapper {
#Mapping( source = "orderId", target = "id" ),
#Mapping( source = "orderNumber", target = "order_number" ),
#Mapping( source = "orderLines", target = "orderLines")
public abstract Order orderRequestToOrder(OrderRequest orderRequest, #Context OrderMappingContext context);
#Mapper(componentModel = "spring", uses = {OrderLineMapper.class})
public interface OrderLineMappers {
List<OrderLine> orderLines(List<OrderLineRequest> orderLineRequest, #Context OrderMappingContext context);
#InheritInverseConfiguration
List<OrderLineRequest> orderLineRequests(List<OrderLine> orderLine);
}
#Mapper(componentModel = "spring")
public abstract class OrderLineMapper {
#Mapping( target = "orderId", source = "orderLineId" ),
#Mapping( target = "order_line_number", source = "orderLineNumber")
public abstract OrderLine orderLineRequestToOrderLine(OrderLineRequest orderLineRequest, #Context OrderMappingContext context);
}
On the invocation side you will do something like
orderMapper.orderRequestToOrder(request, new OrderMappingContext());

How to use Mapstruct when target is inline object?

I have the object like this:
class User {
private String firstName;
private String secondName;
private int age;
....
get/set methods
}
And another object has User as a property:
class UserHolder {
private User user;
....
get/set methods
}
I want to convert UserHolder to User use MapStruct.
When I write this mapper I've something like this:
#Mapper(componentModel = "spring")
public interface UserHolderMapper {
#Mapping(source = "user.firstName", target = "firstName")
#Mapping(source = "user.secondName", target = "secondName")
#Mapping(source = "user.age", target = "age")
User toUser(UserHolder source);
}
But it contains a lot of boilerplate code (in #Mapping annotation), how I can say to mapper that I want to map source.user to this target without specifying fields of target?

I may be late to the party. However following should work fine.
#Mapper(componentModel = "spring")
public interface UserHolderMapper {
#Mapping(source = "source.user", target = ".")
User toUser(UserHolder source);
}

This is currently not possible. There is already a feature request #1406 which is quite similar to what you need.
In any case as a workaround your mapper can look like:
#Mapper(componentModel = "spring")
public interface UserHolderMapper {
default User toUser(UserHolder source) {
return source == null ? null : toUser(source.getUser());
}
User toUser(UserDto source);
}
I don't know what the object in UserHolder is. UserDto is just a presumption, it can be any object.
In case you don't want to expose User toUser(UserDto source) then you can create an abstract mapper and make that method protected and abstract there. MapStruct will be able to handle it