Golang中单表设计的最佳实践与处理方法

在单表设计中处理多实体类型时，推荐使用结构化映射而非大型结构体或动态map。以下是具体实现方案：

方案一：接口驱动设计（推荐）

// 定义基础接口
type CartItem interface {
    GetID() string
    GetSubType() string
    Validate() error
}

// 基础结构体
type BaseItem struct {
    ID      string `dynamodbav:"Id"`
    SubType string `dynamodbav:"SubType"`
}

func (b BaseItem) GetID() string    { return b.ID }
func (b BaseItem) GetSubType() string { return b.SubType }

// 具体类型实现
type ProductItem struct {
    BaseItem
    Name  string `dynamodbav:"Name"`
    Price string `dynamodbav:"Price"`
}

func (p ProductItem) Validate() error {
    if p.Name == "" || p.Price == "" {
        return errors.New("product fields missing")
    }
    return nil
}

type MemberItem struct {
    BaseItem
    Username string `dynamodbav:"Username"`
    Email    string `dynamodbav:"Email"`
}

func (m MemberItem) Validate() error {
    if m.Username == "" || m.Email == "" {
        return errors.New("member fields missing")
    }
    return nil
}

// 工厂函数解析
func ParseCartItem(attrs map[string]interface{}) (CartItem, error) {
    // 先解析基础字段
    data, err := dynamodbattribute.MarshalMap(attrs)
    if err != nil {
        return nil, err
    }
    
    var base BaseItem
    if err := dynamodbattribute.UnmarshalMap(data, &base); err != nil {
        return nil, err
    }
    
    // 根据SubType选择具体类型
    switch {
    case strings.HasPrefix(base.SubType, "Product"):
        var product ProductItem
        if err := dynamodbattribute.UnmarshalMap(data, &product); err != nil {
            return nil, err
        }
        return product, nil
        
    case strings.HasPrefix(base.SubType, "Member"):
        var member MemberItem
        if err := dynamodbattribute.UnmarshalMap(data, &member); err != nil {
            return nil, err
        }
        return member, nil
        
    default:
        return nil, fmt.Errorf("unknown subtype: %s", base.SubType)
    }
}

// 使用示例
func GetCartItems(id string) ([]CartItem, error) {
    result, err := dynamodbClient.Query(&dynamodb.QueryInput{
        TableName:              aws.String("ShoppingCart"),
        KeyConditionExpression: aws.String("Id = :id"),
        ExpressionAttributeValues: map[string]*dynamodb.AttributeValue{
            ":id": {S: aws.String(id)},
        },
    })
    if err != nil {
        return nil, err
    }
    
    var items []CartItem
    for _, item := range result.Items {
        cartItem, err := ParseCartItem(item)
        if err != nil {
            return nil, err
        }
        items = append(items, cartItem)
    }
    
    return items, nil
}

方案二：类型安全的JSON编组

// 使用自定义JSON编组
type CartItem struct {
    ID      string                 `json:"id"`
    SubType string                 `json:"subType"`
    Data    map[string]interface{} `json:"data"`
}

// 类型安全的获取方法
func (c CartItem) AsProduct() (*Product, error) {
    if !strings.HasPrefix(c.SubType, "Product") {
        return nil, errors.New("not a product")
    }
    
    jsonData, err := json.Marshal(c.Data)
    if err != nil {
        return nil, err
    }
    
    var product Product
    if err := json.Unmarshal(jsonData, &product); err != nil {
        return nil, err
    }
    
    return &product, nil
}

func (c CartItem) AsMember() (*Member, error) {
    if !strings.HasPrefix(c.SubType, "Member") {
        return nil, errors.New("not a member")
    }
    
    jsonData, err := json.Marshal(c.Data)
    if err != nil {
        return nil, err
    }
    
    var member Member
    if err := json.Unmarshal(jsonData, &member); err != nil {
        return nil, err
    }
    
    return &member, nil
}

方案三：使用泛型（Go 1.18+）

// 泛型解析器
type ItemParser[T any] struct {
    SubTypePrefix string
}

func (p ItemParser[T]) Parse(attrs map[string]interface{}) (*T, error) {
    // 检查SubType
    subType, ok := attrs["SubType"].(string)
    if !ok || !strings.HasPrefix(subType, p.SubTypePrefix) {
        return nil, errors.New("type mismatch")
    }
    
    // 解析到具体类型
    var item T
    if err := dynamodbattribute.UnmarshalMap(attrs, &item); err != nil {
        return nil, err
    }
    
    return &item, nil
}

// 使用示例
func GetCartItemsGeneric(id string) ([]interface{}, error) {
    // 查询逻辑...
    
    var items []interface{}
    for _, attr := range result.Items {
        switch {
        case strings.HasPrefix(attr["SubType"].(string), "Product"):
            parser := ItemParser[ProductItem]{SubTypePrefix: "Product"}
            product, err := parser.Parse(attr)
            if err != nil {
                return nil, err
            }
            items = append(items, product)
            
        case strings.HasPrefix(attr["SubType"].(string), "Member"):
            parser := ItemParser[MemberItem]{SubTypePrefix: "Member"}
            member, err := parser.Parse(attr)
            if err != nil {
                return nil, err
            }
            items = append(items, member)
        }
    }
    
    return items, nil
}

避免大型结构体的原因

1. 内存浪费：每个实例都包含所有字段的内存分配
2. 类型安全缺失：编译器无法检查字段使用的正确性
3. 维护困难：添加新类型需要修改所有使用该结构体的代码
4. 序列化问题：空字段在JSON/DynamoDB中仍会占用空间

查询优化建议

// 使用GSI进行类型过滤
func GetCartItemsByType(id, subTypePrefix string) ([]CartItem, error) {
    result, err := dynamodbClient.Query(&dynamodb.QueryInput{
        TableName:              aws.String("ShoppingCart"),
        IndexName:              aws.String("Id-SubType-index"), // GSI
        KeyConditionExpression: aws.String("Id = :id AND begins_with(SubType, :prefix)"),
        ExpressionAttributeValues: map[string]*dynamodb.AttributeValue{
            ":id":     {S: aws.String(id)},
            ":prefix": {S: aws.String(subTypePrefix)},
        },
    })
    // 解析逻辑...
}

接口驱动方案提供最佳的类型安全和可维护性，同时保持DynamoDB单表设计的优势。