Golang中如何管理数百个结构体？

在Go中管理数百个结构体时，通常需要结合设计模式和代码组织策略。以下是几种实用的方法：

1. 使用包和模块化组织

// models/person.go
package models

type Person struct {
    FirstName, LastName string
    Age int
}

// models/employee.go  
package models

type Employee struct {
    Person
    EmployeeID string
    Department string
}

// models/customer.go
package models

type Customer struct {
    Person
    CustomerID string
    Tier       string
}

2. 工厂模式创建实例

// factory/struct_factory.go
package factory

import "your-project/models"

func CreatePerson(firstName, lastName string, age int) models.Person {
    return models.Person{
        FirstName: firstName,
        LastName: lastName,
        Age: age,
    }
}

func CreateEmployee(person models.Person, empID, dept string) models.Employee {
    return models.Employee{
        Person:     person,
        EmployeeID: empID,
        Department: dept,
    }
}

3. 使用接口统一管理

// interfaces/entity.go
package interfaces

type Entity interface {
    GetID() string
    Validate() error
    ToMap() map[string]interface{}
}

// models/person.go 实现接口
func (p Person) GetID() string {
    return fmt.Sprintf("%s-%s", p.FirstName, p.LastName)
}

func (p Person) Validate() error {
    if p.Age < 0 {
        return errors.New("age cannot be negative")
    }
    return nil
}

4. 注册表模式管理结构体

// registry/struct_registry.go
package registry

import "reflect"

var structRegistry = make(map[string]reflect.Type)

func RegisterStruct(name string, typ reflect.Type) {
    structRegistry[name] = typ
}

func CreateInstance(name string) interface{} {
    if typ, exists := structRegistry[name]; exists {
        return reflect.New(typ).Interface()
    }
    return nil
}

// 初始化时注册
func init() {
    RegisterStruct("Person", reflect.TypeOf(models.Person{}))
    RegisterStruct("Employee", reflect.TypeOf(models.Employee{}))
}

5. 使用代码生成工具

// 使用go:generate自动生成代码
//go:generate go run github.com/vektra/mockery/v2 --name=Entity --output=mocks

// 或使用结构体标签自动生成验证、序列化代码
type Person struct {
    FirstName string `json:"first_name" validate:"required"`
    LastName  string `json:"last_name" validate:"required"`
    Age       int    `json:"age" validate:"min=0,max=150"`
}

6. 数据库映射示例

// repository/person_repo.go
package repository

import (
    "database/sql"
    "your-project/models"
)

type PersonRepository struct {
    db *sql.DB
}

func (r *PersonRepository) GetAll() ([]models.Person, error) {
    rows, err := r.db.Query("SELECT first_name, last_name, age FROM persons")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var persons []models.Person
    for rows.Next() {
        var p models.Person
        if err := rows.Scan(&p.FirstName, &p.LastName, &p.Age); err != nil {
            return nil, err
        }
        persons = append(persons, p)
    }
    return persons, nil
}

// 批量操作
func (r *PersonRepository) BatchCreate(persons []models.Person) error {
    tx, err := r.db.Begin()
    if err != nil {
        return err
    }

    stmt, err := tx.Prepare("INSERT INTO persons (first_name, last_name, age) VALUES (?, ?, ?)")
    if err != nil {
        return err
    }
    defer stmt.Close()

    for _, p := range persons {
        _, err := stmt.Exec(p.FirstName, p.LastName, p.Age)
        if err != nil {
            tx.Rollback()
            return err
        }
    }
    
    return tx.Commit()
}

7. 使用依赖注入容器

// container/container.go
package container

import "sync"

type Container struct {
    services map[string]interface{}
    mu       sync.RWMutex
}

func (c *Container) Register(name string, service interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.services[name] = service
}

func (c *Container) Get(name string) interface{} {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.services[name]
}

// 使用
var container = &Container{
    services: make(map[string]interface{}),
}

func init() {
    container.Register("PersonService", &services.PersonService{})
    container.Register("EmployeeService", &services.EmployeeService{})
}

管理数百个结构体的关键在于良好的代码组织和架构设计。通过合理的包划分、接口抽象和设计模式应用，可以有效管理大量结构体。数据库操作与结构体管理并不冲突，可以使用Repository模式将两者结合。