双向映射/展平嵌套属性：通用实体与DTO映射方案问询

Hey there! I’ve run into this exact mapping pattern before, so I’ve got a couple of practical, reusable solutions to share with you:

The core requirement here is to map all entity fields except id into a nested attributes field in the DTO, while keeping the mapper reusable across multiple entity-DTO pairs that follow the same pattern. Here are two solid approaches:

Option 1: Use MapStruct (Recommended) #

MapStruct is a compile-time mapping library that generates type-safe, high-performance mapper code. It’s perfect for this scenario because it supports inheritance and generic mappings out of the box.

Step 1: Add MapStruct Dependency #

First, include MapStruct in your project (Maven example):

<dependencies>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>1.5.5.Final</version>
    </dependency>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.5.5.Final</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

Step 2: Create a Generic Base Mapper #

Define a generic interface that encapsulates the common mapping logic for all entity-DTO pairs following your pattern:

import org.mapstruct.Mapping;

// Generic base mapper: E = Entity, D = DTO, A = DTO's nested attributes class
public interface BaseEntityDtoMapper<E, D, A> {

    // Map entity's id directly to DTO's id, and all other fields to DTO's attributes
    @Mapping(target = "id", source = "id")
    @Mapping(target = "attributes", source = ".") // "." refers to the entire source entity
    D toDto(E entity);

    // Reverse mapping: map DTO's id to entity's id, and attributes to entity's fields
    @Mapping(target = "id", source = "id")
    @Mapping(target = ".", source = "attributes") // "." refers to the entire target entity
    E toEntity(D dto);
}

Step 3: Implement Specific Mappers #

For each entity-DTO pair, just extend the base interface—MapStruct will auto-generate the implementation:

import org.mapstruct.Mapper;

@Mapper(componentModel = "spring") // Use "cdi" or default if not using Spring
public interface SomeEntityDtoMapper extends BaseEntityDtoMapper<SomeEntity, SomeDto, SomeDto.SomeDtoAttributes> {
    // No extra code needed! MapStruct handles all field matching automatically
}

Why This Works #

• The source = "." tells MapStruct to map all matching fields from the source (entity) to the target (attributes nested class), as long as field names and types are identical.
• Any new entity-DTO pair following the same pattern only needs a new interface extending BaseEntityDtoMapper—no duplicate code.

Option 2: Manual Generic Mapper with Reflection #

If you prefer not to introduce a third-party library, you can build a generic mapper using Java Reflection. This works for simple cases but has tradeoffs (performance, type safety).

Generic Mapper Implementation #

import java.lang.reflect.Field;

public class GenericEntityDtoMapper {

    // Generic method to convert entity to DTO with nested attributes
    public static <E, D, A> D toDto(E entity, Class<D> dtoClass, Class<A> attributesClass) throws Exception {
        // Initialize DTO and attributes instances
        D dto = dtoClass.getDeclaredConstructor().newInstance();
        A attributes = attributesClass.getDeclaredConstructor().newInstance();

        // Iterate over all fields in the entity
        for (Field entityField : entity.getClass().getDeclaredFields()) {
            entityField.setAccessible(true);
            String fieldName = entityField.getName();
            Object fieldValue = entityField.get(entity);

            if ("id".equals(fieldName)) {
                // Set DTO's id field
                Field dtoIdField = dtoClass.getDeclaredField(fieldName);
                dtoIdField.setAccessible(true);
                dtoIdField.set(dto, fieldValue);
            } else {
                // Set corresponding field in attributes
                Field attrField = attributesClass.getDeclaredField(fieldName);
                attrField.setAccessible(true);
                attrField.set(attributes, fieldValue);
            }
        }

        // Attach attributes to DTO
        Field attributesField = dtoClass.getDeclaredField("attributes");
        attributesField.setAccessible(true);
        attributesField.set(dto, attributes);

        return dto;
    }

    // Reverse mapping method (similar logic, omitted for brevity)
    public static <E, D, A> E toEntity(D dto, Class<E> entityClass, Class<A> attributesClass) throws Exception {
        // Implement reverse logic here: map DTO's id to entity, and attributes to entity fields
        // ...
        return null;
    }
}

Usage Example #

// Convert SomeEntity to SomeDto
SomeEntity entity = new SomeEntity();
entity.setId(1);
entity.setName("Test");
entity.setCreated(new Date());

try {
    SomeDto dto = GenericEntityDtoMapper.toDto(entity, SomeDto.class, SomeDto.SomeDtoAttributes.class);
} catch (Exception e) {
    // Handle reflection exceptions (e.g., missing fields, access issues)
    e.printStackTrace();
}

Notes on Reflection Approach #

• Pros: No external dependencies, works for any entity-DTO pair following the pattern.
• Cons: Runtime overhead, no compile-time type safety (will fail at runtime if fields don’t match), requires handling exceptions.

Final Recommendation #

Go with MapStruct if you can—it’s type-safe, fast, and reduces boilerplate drastically. The reflection approach is a decent fallback if you can’t add dependencies, but be mindful of its limitations.

内容的提问来源于stack exchange，提问作者niltz