MapStruct能否将对象字段映射为类型名+字段值字符串形式？

Great question! Yes, MapStruct fully supports this custom mapping requirement. Since it’s not a standard out-of-the-box scenario, you’ll need to add custom conversion logic—either using a default method in your mapper interface (for dynamic field handling) or explicit mappings (for fixed, compile-time safe handling).

Option 1: Dynamic field handling with reflection (matches your expected logic) #

If you want to automatically handle all fields in ConvertFrom without manually listing each one, you can embed your reflection-based logic into a default method in the MapStruct mapper. MapStruct will call this method to populate the result field in ConvertTo.

Here’s how the mapper would look:

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

@Mapper
public interface ConvertFromToConvertToMapper {
    // Singleton instance for easy use
    ConvertFromToConvertToMapper INSTANCE = Mappers.getMapper(ConvertFromToConvertToMapper.class);

    // Map the entire ConvertFrom object to the 'result' field using our custom method
    @Mapping(target = "result", source = "convertFrom")
    ConvertTo toDto(ConvertFrom convertFrom);

    // Default method to handle the nested Map conversion
    default Map<String, Map<String, String>> mapFieldsToNestedMap(ConvertFrom convertFrom) {
        if (Objects.isNull(convertFrom)) {
            return null;
        }

        Map<String, Map<String, String>> resultMap = new HashMap<>();
        Field[] fields = ConvertFrom.class.getDeclaredFields();

        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object fieldValue = field.get(convertFrom);

                if (Objects.nonNull(fieldValue)) {
                    // Create the inner map with type name and stringified value
                    Map<String, String> innerMap = Map.of(
                        field.getType().getSimpleName(),
                        fieldValue.toString()
                    );
                    resultMap.put(field.getName(), innerMap);
                }
            } catch (IllegalAccessException e) {
                // Replace with your preferred error handling (e.g., custom exception)
                throw new RuntimeException("Failed to process field: " + field.getName(), e);
            }
        }

        return resultMap;
    }
}

MapStruct will generate an implementation that calls your mapFieldsToNestedMap method directly to populate the result field—this aligns almost exactly with the manual implementation you provided.

Option 2: Explicit field mapping (compile-time safe, no reflection) #

If you prefer to avoid reflection and want compile-time safety (e.g., if your ConvertFrom fields won’t change often), you can manually map each field using a custom method:

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

@Mapper
public interface ConvertFromToConvertToMapper {
    ConvertFromToConvertToMapper INSTANCE = Mappers.getMapper(ConvertFromToConvertToMapper.class);

    @Mapping(target = "result", expression = "java(buildResultMap(convertFrom))")
    ConvertTo toDto(ConvertFrom convertFrom);

    default Map<String, Map<String, String>> buildResultMap(ConvertFrom convertFrom) {
        if (Objects.isNull(convertFrom)) {
            return null;
        }

        Map<String, Map<String, String>> resultMap = new HashMap<>();

        // Map strValue explicitly
        if (Objects.nonNull(convertFrom.getStrValue())) {
            resultMap.put("strValue", Map.of("String", convertFrom.getStrValue()));
        }

        // Map longValue explicitly
        if (Objects.nonNull(convertFrom.getLongValue())) {
            resultMap.put("longValue", Map.of("Long", convertFrom.getLongValue().toString()));
        }

        return resultMap;
    }
}

This approach eliminates reflection overhead and ensures that if you rename a field in ConvertFrom, your IDE will flag the missing getter immediately.

Key Notes #

• Both approaches use MapStruct’s core feature of integrating custom conversion logic into generated mappers.
• The reflection-based option is better for classes with many fields or dynamic field changes, while the explicit mapping is safer for stable class structures.

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