如何从扁平表映射数据生成复杂实体对象？

不用手动写重复的映射代码，主流开发语言都有成熟的对象映射框架，支持通过属性、注解或配置类来定义扁平字段到嵌套对象的映射规则，以下是常见语言的实现示例：

C#（AutoMapper） #

假设你的扁平实体类是：

public class FlatCustomer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string BillingAddress { get; set; }
    public string BillingCity { get; set; }
    public string BillingState { get; set; }
    public string BillingZip { get; set; }
}

目标DTO类（匹配JSON结构）：

public class CustomerDto
{
    [JsonProperty("first_name")]
    public string FirstName { get; set; }
    [JsonProperty("last_name")]
    public string LastName { get; set; }
    [JsonProperty("billing_address")]
    public AddressDto BillingAddress { get; set; }
}

public class AddressDto
{
    [JsonProperty("address")]
    public string Street { get; set; }
    [JsonProperty("city")]
    public string City { get; set; }
    [JsonProperty("state")]
    public string State { get; set; }
    [JsonProperty("zip")]
    public string Zip { get; set; }
}

通过AutoMapper的Profile配置映射规则：

public class CustomerProfile : Profile
{
    public CustomerProfile()
    {
        CreateMap<FlatCustomer, CustomerDto>()
            .ForMember(dest => dest.BillingAddress, opt => opt.MapFrom(src => new AddressDto
            {
                Street = src.BillingAddress,
                City = src.BillingCity,
                State = src.BillingState,
                Zip = src.BillingZip
            }));
        // 若字段命名符合驼峰转下划线规则，AutoMapper可自动映射，无需额外配置
    }
}

初始化Mapper后直接调用映射：

var mapper = new MapperConfiguration(cfg => cfg.AddProfile<CustomerProfile>()).CreateMapper();
var flatCustomer = GetFromFlatTable(); // 从扁平表获取数据
var customerDto = mapper.Map<CustomerDto>(flatCustomer);
// 序列化customerDto即可得到符合要求的JSON

Java（MapStruct） #

定义扁平实体类：

public class FlatCustomer {
    private String firstName;
    private String lastName;
    private String billingAddress;
    private String billingCity;
    private String billingState;
    private String billingZip;
    // getter、setter省略
}

目标DTO类：

public class CustomerDto {
    @JsonProperty("first_name")
    private String firstName;
    @JsonProperty("last_name")
    private String lastName;
    @JsonProperty("billing_address")
    private AddressDto billingAddress;
    // getter、setter省略
}

public class AddressDto {
    @JsonProperty("address")
    private String street;
    @JsonProperty("city")
    private String city;
    @JsonProperty("state")
    private String state;
    @JsonProperty("zip")
    private String zip;
    // getter、setter省略
}

创建MapStruct映射接口，用@Mapping注解指定字段映射路径：

@Mapper(componentModel = "spring") // 若用Spring框架，可指定组件模型
public interface CustomerMapper {
    CustomerMapper INSTANCE = Mappers.getMapper(CustomerMapper.class);

    @Mapping(source = "billingAddress", target = "billingAddress.street")
    @Mapping(source = "billingCity", target = "billingAddress.city")
    @Mapping(source = "billingState", target = "billingAddress.state")
    @Mapping(source = "billingZip", target = "billingAddress.zip")
    CustomerDto flatToDto(FlatCustomer flatCustomer);
}

使用时直接调用接口方法：

FlatCustomer flatCustomer = getFromFlatTable(); // 从扁平表取数
CustomerDto customerDto = CustomerMapper.INSTANCE.flatToDto(flatCustomer);
// 用Jackson序列化customerDto得到目标JSON

Python（Marshmallow） #

假设从扁平表获取的数据是字典，用Marshmallow Schema定义映射规则：

from marshmallow import Schema, fields

flat_customer = {
    "first_name": "Greg", 
    "last_name": "Gum", 
    "billing_address": "123 Main St", 
    "billing_city": "New York", 
    "billing_state": "New York", 
    "billing_zip": "12345"
}

class AddressSchema(Schema):
    address = fields.String(data_key="billing_address")
    city = fields.String(data_key="billing_city")
    state = fields.String(data_key="billing_state")
    zip = fields.String(data_key="billing_zip")

class CustomerSchema(Schema):
    first_name = fields.String()
    last_name = fields.String()
    billing_address = fields.Nested(AddressSchema)

# 序列化示例
schema = CustomerSchema()
result = schema.dump(flat_customer)
# result就是符合要求的嵌套字典，转成JSON即可

如果用Pydantic v2，也可以通过Field的validation_alias实现：

from pydantic import BaseModel, Field

class AddressDto(BaseModel):
    address: str = Field(validation_alias="billing_address")
    city: str = Field(validation_alias="billing_city")
    state: str = Field(validation_alias="billing_state")
    zip: str = Field(validation_alias="billing_zip")

class CustomerDto(BaseModel):
    first_name: str
    last_name: str
    billing_address: AddressDto

# 从扁平字典解析
flat_customer = {"first_name": "Greg", "last_name": "Gum", "billing_address": "123 Main St", "billing_city": "New York", "billing_state": "New York", "billing_zip": "12345"}
customer_dto = CustomerDto(**flat_customer)
# 转JSON：customer_dto.model_dump_json()

这些框架都能帮你省去手动逐个字段赋值的繁琐工作，只需要通过注解/属性配置映射规则即可实现扁平数据到嵌套JSON结构的转换。

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