在Golang开发博客REST API时，需为每个用例定义独立struct吗？

方案1：嵌入结构体+字段重写 #

把Post的基础字段抽成独立结构体，其他变体通过嵌入并替换特定字段实现，配合bson/json标签保证序列化/反序列化正确：

type PostBase struct {
    Title    string `bson:"title" json:"title"`
    AuthorID string `bson:"author" json:"author"` // 存ID，关联查询时替换为结构体
    CatID    string `bson:"category" json:"category"`
}

type Author struct {
    FirstName string `bson:"firstname" json:"firstname"`
    LastName  string `bson:"lastname" json:"lastname"`
}

type Category struct {
    Name   string     `bson:"name" json:"name"`
    Parent *Category `bson:"parent,omitempty" json:"parent,omitempty"`
}

// 带作者信息的Post
type PostWithAuthor struct {
    PostBase
    Author Author `bson:"author" json:"author"` // 重写PostBase的AuthorID字段
}

// 带分类信息的Post
type PostWithCategory struct {
    PostBase
    Category Category `bson:"category" json:"category"` // 重写PostBase的CatID字段
}

// 同时带作者和分类的Post
type PostWithAuthorAndCategory struct {
    PostBase
    Author   Author   `bson:"author" json:"author"`
    Category Category `bson:"category" json:"category"`
}

优点：复用基础字段，减少重复代码，类型安全；缺点：仍需定义不同的结构体变体，但每个变体的代码量极少。

方案2：使用泛型定义通用Post结构体（Go 1.18+） #

利用Go泛型的特性，定义一个通用的Post结构体，通过泛型参数指定Author和Category的类型，适配不同的查询场景：

type Author struct {
    FirstName string `bson:"firstname" json:"firstname"`
    LastName  string `bson:"lastname" json:"lastname"`
}

type Category struct {
    Name   string     `bson:"name" json:"name"`
    Parent *Category `bson:"parent,omitempty" json:"parent,omitempty"`
}

// 通用Post结构体，A代表Author类型，C代表Category类型
type GenericPost[A, C any] struct {
    Title    string `bson:"title" json:"title"`
    Author   A      `bson:"author" json:"author"`
    Category C      `bson:"category" json:"category"`
}

// 使用示例
type Post = GenericPost[string, string] // 基础Post，作者和分类存ID
type PostWithAuthor = GenericPost[Author, string] // 带作者信息的Post
type PostWithCategory = GenericPost[string, Category] // 带分类信息的Post
type PostWithAuthorAndCategory = GenericPost[Author, Category] // 全关联Post

func getPost() Post {
    // 查询逻辑
}

func getPostWithAuthor() PostWithAuthor {
    // 查询逻辑，执行$lookup关联Author
}

优点：只需要定义一个通用结构体，所有变体通过类型别名生成，代码极度精简；缺点：依赖Go 1.18+版本，对泛型不熟悉的话有学习成本。

方案3：动态map处理（适合简单场景） #

如果接口返回格式灵活，且不需要严格的类型检查，可以直接用map[string]interface{}接收查询结果，再根据需要转换字段：

func getPostWithAuthor() map[string]interface{} {
    var result map[string]interface{}
    // 执行MongoDB查询（含$lookup）并解码到result
    return result
}

优点：无需定义任何结构体变体；缺点：丢失类型安全，后续字段操作需要类型断言，容易引发运行时错误，不适合复杂业务场景。

方案4：自定义反序列化逻辑 #

实现bson.Unmarshaler接口，根据查询结果动态填充结构体字段，这种方式灵活性最高，但实现复杂度也最大：

type Post struct {
    Title    string      `bson:"title"`
    Author   interface{} `bson:"author"` // 可以是string或Author
    Category interface{} `bson:"category"` // 可以是string或Category
}

func (p *Post) UnmarshalBSON(data []byte) error {
    var temp struct {
        Title    string      `bson:"title"`
        Author   interface{} `bson:"author"`
        Category interface{} `bson:"category"`
    }
    if err := bson.Unmarshal(data, &temp); err != nil {
        return err
    }

    p.Title = temp.Title
    // 处理Author字段：判断是string还是结构体
    switch auth := temp.Author.(type) {
    case string:
        p.Author = auth
    case map[string]interface{}:
        var author Author
        authBytes, _ := bson.Marshal(auth)
        bson.Unmarshal(authBytes, &author)
        p.Author = author
    }

    // 同理处理Category字段
    switch cat := temp.Category.(type) {
    case string:
        p.Category = cat
    case map[string]interface{}:
        var category Category
        catBytes, _ := bson.Marshal(cat)
        bson.Unmarshal(catBytes, &category)
        p.Category = category
    }

    return nil
}

优点：只用一个结构体就能适配所有场景；缺点：实现繁琐，需要手动处理类型判断和转换，维护成本高。

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