双向Hibernate关联的MapStruct自定义列表映射

Question

从数据传输对象（DTO）到具有双向一对多关联的Hibernate实体执行MapStruct映射的最佳方法是什么？

假设我们有一个BookDto，其中链接了多个类型为ReviewTo的评论：

public class BookDto {
  private List<ReviewDto> reviews;
  // getter and setters...
}

相应的Hibernate实体<代码>书籍<代码>与<代码>评论<代码>有一对多关联：

@Entity
public class Book {
  @OneToMany(mappedBy = "book", orphanRemoval = true, cascade = CascadeType.ALL)
  private List<Review> reviews = new ArrayList<>();
  
  public void addReview(Review review) {
    this.reviews.add(review);
    review.setBook(this);
  }
  //...
}

@Entity
public class Review {
  @ManyToOne(fetch = FetchType.LAZY)
  private Book book;

  public void setBook(Book book) {
    this.book = book;
  }
  //...
}

请注意，本书的addReview方法还通过调用review.setBook（this）来双向设置关联，这是Hibernate专家推荐的（例如，Thorben Janssen的“Hibernate Tips：如何映射双向多对一关联”或Vlad Mihalcea的“如何将双向实体关联与JPA和Hibernate同步”），以确保域模型关系的一致性。

现在，我们需要一个自动将评论链接回书的MapSTRt映射器。到目前为止，我找到了多个选项，每个选项都有一些缺点：

1. 自定义映射方法：

@Mapper
public interface BookMapper {
  default Book mapBookDtoToBook(BookDto bookDto) {
    //...
    for (ReviewDto reviewDto : bookDto.getReviews()) {
      book.addReview(mapReviewDtoToReview(reviewDto));
    }
    //...
  }
  //...
}

如果这本书还有许多其他字段需要映射，那么这会变得很麻烦。[更新：本的回答可以简化这一点。]

@Mapper
public interface BookMapper {
  Book mapBookDtoToBook(Book book); // Implementation generated by MapStruct

  @AfterMapping
  void linkReviewsToBook(@MappingTarget Book book) {
    for (Review review : book.getReviews()) {
      review.setBook(book);
    }
  }
  //...
}

这种方法允许MapStruct生成所有其他字段映射；但是，通过在after映射中将自动生成的setReviews与setBook操作分离，我们失去了内聚性。

@Entity
public class Book {
  //...
  public void setBiDirectionalReviews(List<Review> reviews) {
    this.reviews = reviews;
    for (Review review : this.reviews) {
      review.setBook(this);
    }
  }
}

@Mapper
public class BookMapper {
  @Mapping(source = "reviews", target = "biDirectionalReviews")
  Book mapBookDtoToBook(Book book);
}

现在我们已经重新建立了凝聚力，但是（1）如果我们想在其他地方修改现有的评论，我们可能仍然需要额外的方法addReview，并且（2）通过假装有一个名为“biDirectionalReview”的字段来滥用MapSTRt的访问器命名策略感觉有点笨拙。
无论如何，这是我迄今为止能找到的最好的方法。

有没有更好的解决方案来映射Map结构中的双向关联？

Answer 1

您可以使用抽象类来代替接口。这样，您就可以公开主要方法，同时仍然对所有映射使用mapstruct，除了书的评论。这也消除了需要手动映射其他字段的缺点，因为可以使用辅助方法。

@Mapper
public abstract class BookMapper {

    public Book map(BookDto dto) {
        Book book = mapBook( dto );

        for ( ReviewDto reviewDto : dto.getReviews() ) {
            Review review = mapReview( reviewDto );
            book.addReview( review );
        }

        return book;
    }

    // mapstruct annotations
    @Mapping(target = "reviews", ignore=true) // if needed
    abstract Book mapBook(BookDto dto);

    // mapstruct annotations
    @Mapping(target = "book", ignore=true) // if needed
    abstract Review mapReview(ReviewDto reviewDto);
}

编辑：我认为尤金的答案更好。

Answer 2

解决方案1，@Context
这个问题可以通过@Context解决
Mapstruct贡献者提供了如何在JPA中的父/子关系中使用@Context的示例。

例子：

@Mapper
public interface JpaMapper {
    JpaMapper MAPPER = Mappers.getMapper( JpaMapper.class );

    Book toEntity(BookDTO s, @Context JpaContext ctx);

    @Mapping(target = "book", ignore = true)
    Review toEntity(ReviewDTO s, @Context JpaContext ctx);
}

public class JpaContext {
    private Book bookEntity;

    @BeforeMapping
    public void setEntity(@MappingTarget Book parentEntity) {
        this.bookEntity = parentEntity;
        // you could do stuff with the EntityManager here
    }

    @AfterMapping
    public void establishRelation(@MappingTarget Review childEntity) {
        childEntity.setBook(bookEntity);
        // you could do stuff with the EntityManager here
    }
}

用法：

Book book = JpaMapper.MAPPER.toEntity(bookDTO, new JpaContext());

生成的代码：

java prettyprint-override">public class JpaMapperImpl implements JpaMapper {

    @Override
    public Book toEntity(BookDTO s, JpaContext ctx) {
        if ( s == null ) {
            return null;
        }

        Book book = new Book();

        ctx.setEntity( book );

        book.setId( s.getId() );
        book.setName( s.getName() );
        book.setReviews( reviewDTOListToReviewList( s.getReviews(), ctx ) );

        return book;
    }

    @Override
    public Review toEntity(ReviewDTO s, JpaContext ctx) {
        if ( s == null ) {
            return null;
        }

        Review review = new Review();

        review.setId( s.getId() );
        review.setName( s.getName() );

        ctx.establishRelation( review );

        return review;
    }

    protected List<Review> reviewDTOListToReviewList(List<ReviewDTO> list, JpaContext ctx) {
        if ( list == null ) {
            return null;
        }

        List<Review> list1 = new ArrayList<Review>( list.size() );
        for ( ReviewDTO reviewDTO : list ) {
            list1.add( toEntity( reviewDTO, ctx ) );
        }

        return list1;
    }
}

解决方案2，集合映射策略
您可以指定CollectionMappingStrategy。ADDER_是集合映射的首选策略。这意味着Mapstruct将使用addReview（Review Review）方法将Review对象添加到集合中<我认为这是正确的解决方案。

@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED)
public interface JpaMapper {
    JpaMapper MAPPER = Mappers.getMapper( JpaMapper.class );

    Book toEntity(BookDTO s);

    @Mapping(target = "book", ignore = true)
    Review toEntity(ReviewDTO s);
}

生成的代码：

public class JpaMapperImpl implements JpaMapper {

    @Override
    public Book toEntity(BookDTO s) {
        if ( s == null ) {
            return null;
        }

        Book book = new Book();

        book.setId( s.getId() );
        book.setName( s.getName() );
        if ( s.getReviews() != null ) {
            for ( ReviewDTO review : s.getReviews() ) {
                book.addReview( toEntity( review ) );
            }
        }

        return book;
    }

    @Override
    public Review toEntity(ReviewDTO s) {
        if ( s == null ) {
            return null;
        }

        Review review = new Review();

        review.setId( s.getId() );
        review.setName( s.getName() );

        return review;
    }
}

单元测试：

    @Test
    public void test() {
        BookDTO bookDTO = new BookDTO();
        bookDTO.setId(1L);
        bookDTO.setName("Book 1");

        ReviewDTO reviewDTO1 = new ReviewDTO();
        reviewDTO1.setId(1L);
        reviewDTO1.setName("Review 1");

        ReviewDTO reviewDTO2 = new ReviewDTO();
        reviewDTO2.setId(2L);
        reviewDTO2.setName("Review 2");

        List<ReviewDTO> reviewDTOS = Arrays.asList(reviewDTO1, reviewDTO2);
        bookDTO.setReviews(reviewDTOS);

        Book book = JpaMapper.MAPPER.toEntity(bookDTO, new JpaContext());
        //Book book = JpaMapper.MAPPER.toEntity(bookDTO);

        Assert.assertNotNull(book);
        Assert.assertEquals(book.getId(), book.getId());
        Assert.assertEquals(book.getName(), bookDTO.getName());

        Assert.assertEquals(book.getReviews().size(), bookDTO.getReviews().size());
        Assert.assertEquals(book.getReviews().get(0).getId(), bookDTO.getReviews().get(0).getId());
        Assert.assertEquals(book.getReviews().get(1).getId(), bookDTO.getReviews().get(1).getId());

        book.getReviews().forEach(review -> Assert.assertEquals(review.getBook(), book));
    }