Como mapear pais e filhos usando Mapstruct no Spring Boot?

Question

Tenho pais (produto) e filhos (livro, móveis) e gostaria de mapear a entidade do produto para o DTO do produto. Como você pode ver, o produto é mapeado e armazenado em tabela única no banco de dados. Como posso mapear o pai, produto, que tem detalhes extras de seu filho?

Eu olhei isso , isso e isso para ter alguma ideia, mas sem sorte

Entidade

@Entity
@Table(name = "product")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Product {
  @Id
  private long id;
  private String productName;
}

@Entity
@DiscriminatorValue("Book")
public class Book extends Product { 
  private String author;
  ...
}
@Entity
@DiscriminatorValue("Furniture")
public class Furniture extends Product {
  String color;
  ...
}

DTO

public class ProductDto {
  private long id;
  private String productName;
  ...
}

public class BookDto extends ProductDto {
  private String author;
  ...
}
public class FurnitureDto extends ProductDto {
   String color;
   ... 
}

Mapeador

@Mapper(uses = {BookMapper.class,FurnitureMapper.class})
public interface ProductMapper {
    
    ProductDto productToProductDto(Product product);
    Product productDtoToProduct(ProductDto productDto);
}

@Mapper
public interface BookMapper {
    BookDto bookToBookDto(Book book);
    Book bookDtoToBook(BookDto bookDto);
}

@Mapper
public interface FurnitureMapper {
    FurnitureDto furnitureToFurnitureDto(Furniture furniture);
    Furniture furnitureDtoToFurniture(FurnitureDto furnitureDto);
}

Serviço

@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    ProductRepository productRepository;
    @Autowired
    ProductMapper productMapper;

    @Override
    public List<ProductDto> getAllProducts() {
        List<ProductDto> listOfProducts = new ArrayList<>();
        productRepository.findAll().forEach(i -> 
        listOfProducts.add(productMapper.productToProductDto(i)));
        return listOfProducts;
    }
}

Editado

Obtenho o seguinte resultado após mapear a entidade do produto para o produto dto. Ele não vincula os dados e não inclui seus atributos filhos. A seção do mapeador acima está correta?

[
    {
        "id": 0,
        "productName": null
    },
    {
        "id": 0,
        "productName": null
    },
    ...
]

O resultado, entretanto, deve ser como abaixo:

[
    {
        "id": 11,
        "productName": ABC,
        "author":"James"
    },
    {
        "id": 22,
        "productName": XYZ,
        "color":"Oak"
    },
    ...
]

Answer 1

TL; DR

Não existe uma maneira limpa de fazer isso. A razão está na seleção do método de tempo de compilação do Java. Mas existe uma maneira um tanto limpa de usar o padrão de visitante.

Por que não está funcionando

Enquanto você itera a lista de entidades, que contém diferentes tipos (Produto, Livro, Móveis), você precisa chamar um método de mapeamento diferente para cada tipo (ou seja, um mapeador MapStruct diferente).

A menos que você siga o instanceofcaminho, como sugere Amir, e selecione explicitamente o mapeador, você precisa usar a sobrecarga de método para invocar diferentes métodos de mapeamento por classe de entidade. O problema é que o Java selecionará o método sobrecarregado no momento da compilação e, nesse ponto, o compilador verá apenas uma lista de Productobjetos (aqueles retornados pelo seu método de repositório). Realmente não importa se MapStruct ou Spring ou seu próprio código personalizado tentam fazer isso. É também por isso que o seu ProductMapperé sempre chamado: é o único tipo visível em tempo de compilação.

Usando o padrão de visitante

Como precisamos escolher o mapeador certo manualmente , podemos escolher qual caminho é mais limpo ou mais sustentável. Isso é definitivamente opinativo.

Minha sugestão é usar o padrão de visitante (na verdade, uma variação dele) da seguinte maneira:

Apresente uma nova interface para suas entidades que precisam ser mapeadas:

public interface MappableEntity {

    public ProductDto map(EntityMapper mapper);
}

Suas entidades precisarão implementar esta interface, por exemplo:

public class Book extends Product implements MappableEntity {
//...
@Override
    public ProductDto map(EntityMapper mapper) {
        return mapper.map(this);//This is the magic part. We choose which method to call because the parameter is this, which is a Book!
    }
}

EntityMapper é a interface do visitante:

public interface EntityMapper {

    ProductDto map(Product entity);

    BookDto map(Book entity);

    FurnitureDto map(Furniture entity);

    // Add your next entity here
}

Finalmente, você precisa do MasterMapper:

// Not a class name I'm proud of
public class MasterMapper implements EntityMapper {

    // Inject your mappers here

    @Override
    public ProductDto map(Product product) {
        ProductMapper productMapper = Mappers.getMapper(ProductMapper.class);
        return productMapper.map(product);
    }

    @Override
    public BookDto map(Book product) {
        BookMapper productMapper = Mappers.getMapper(BookMapper.class);
        return productMapper.map(product);
    }

    @Override
    public FurnitureDto map(Furniture product) {
        FurnitureMapper productMapper = Mappers.getMapper(FurnitureMapper.class);
        return productMapper.map(product);
    }

    // Add your next mapper here

}

Seu método de serviço será assim:

MasterMapper mm = new MasterMapper();
List<Product> listOfEntities = productRepository.findAll();
List<ProductDto> listOfProducts = new ArrayList<>(listOfEntities.size());
listOfEntities.forEach(i -> {
        if (i instanceof MappableEntity) {
            MappableEntity me = i;
            ProductDto dto = me.map(mm);
            listOfProducts.add(dto);
        } else {
            // Throw an AssertionError during development (who would run server VMs with -ea ?!?!)
            assert false : "Can't properly map " + i.getClass() + " as it's not implementing MappableEntity";
            // Use default mapper as a fallback
            final ProductDto defaultDto = Mappers.getMapper(ProductMapper.class).map(i);
            listOfProducts.add(defaultDto);
        }
     });
    return listOfProducts;

Você pode ignorar Mappers.getMapper()chamadas com segurança : como o problema não está relacionado ao Spring, criei um exemplo prático no GitHub usando as fábricas do MapStruct para simplificar. Você apenas injetará seus mapeadores usando CDI.

Answer 2

Este é exatamente o mesmo cenário descrito nesta edição .
Infelizmente, este problema ainda está aberto e ninguém forneceu uma solução até agora. Então eu acho que o que você quer não é possível.

A única maneira de resolver seu problema é alterar o código em seu serviço.

Uma coisa que você pode fazer, conforme mencionado no problema, é testar cada Productobjeto com instanceof:

@Autowired
BookMapper bookMapper;
@Autowired
FurnitureMapper furnitureMapper;

public List<ProductDto> getAllProducts() {
    List<ProductDto> listOfProducts = new ArrayList<>();
    List<Product> all = productRepository.findAll();
    for(Product product : all) {
        if(product instanceof Book) {
            listOfProducts.add(bookMapper.bookToBookDto((Book)product));
        } else if(product instanceof Furniture) {
            listOfProducts.add(furnitureMapper.furnitureToFurnitureDto((Furniture)product));
        }
    }
    return listOfProducts;
}

Você também pode fazer sua ProductMapperextensão BookMappere FurnitureMapper, para não precisar injetá-los.