Go语言中结构体嵌入与ORM通用CRUD的实现策略：规避反射陷阱

package models

import (
    "database/sql"
    "fmt"
    "reflect" // 用于调试和理解gorp的反射机制
    _ "github.com/go-sql-driver/mysql"
    "github.com/coopernurse/gorp"
)

// GorpModel 包含通用的数据库模型属性
type GorpModel struct {
    New bool `db:"-"` // 标记是否为新创建的模型
}

var dbm *gorp.DbMap = nil

// DbInit 初始化数据库连接和gorp的DbMap
func (gm *GorpModel) DbInit() {
    if dbm == nil {
        db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/my_db?charset=utf8mb4&parseTime=True&loc=Local")
        if err != nil {
            panic(fmt.Errorf("failed to open database connection: %w", err))
        }
        // 建议在这里为所有需要持久化的模型添加表映射
        dbm = &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
        // 示例：添加User表的映射，实际应用中应为所有模型添加
        dbm.AddTable(User{}).SetKeys(true, "Id")

        // 生产环境中通常不在这里调用CreateTables，而是在迁移脚本中处理
        err = dbm.CreateTablesIfNotExists()
        if err != nil {
            panic(fmt.Errorf("failed to create tables: %w", err))
        }
    }
    gm.New = true // 标记为新创建，以便后续判断是Insert还是Update
}

// Create 方法试图在GorpModel上实现通用创建操作
// 这种实现方式存在问题，将在下文详细解释
func (gm *GorpModel) Create() {
    // gorp.Insert(gm) 会基于反射认为要操作的表是 "GorpModel"
    err := dbm.Insert(gm) 
    if err != nil {
        panic(fmt.Errorf("failed to insert GorpModel: %w", err))
    }
}

// User 业务模型，嵌入GorpModel
type User struct {
    GorpModel `db:"-"` // 嵌入GorpModel，db:"-" 表示不映射GorpModel的字段到User表
    Id        int64  `db:"id"`
    Name      string `db:"name"`
    Email     string `db:"email"`
}

// 示例：User结构体如何使用GorpModel的New字段
func (u *User) Save() {
    if u.New {
        // 理想情况下，这里希望调用一个通用的Insert方法
        // 但如果通用方法定义在GorpModel上，会遇到反射问题
        fmt.Println("Inserting new user...")
        // dbm.Insert(u) // 这才是我们真正想要的
    } else {
        fmt.Println("Updating existing user...")
        // dbm.Update(u)
    }
}

package models

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "github.com/coopernurse/gorp"
)

// GorpModel 仅包含通用字段，不再包含CRUD方法
type GorpModel struct {
    New bool `db:"-"` // 标记是否为新创建的模型
}

var dbm *gorp.DbMap = nil

// InitDbMap 负责初始化gorp的DbMap，建议在应用程序启动时只调用一次
func InitDbMap() *gorp.DbMap {
    if dbm == nil {
        db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/my_db?charset=utf8mb4&parseTime=True&loc=Local")
        if err != nil {
            panic(fmt.Errorf("failed to open database connection: %w", err))
        }
        dbm = &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}

        // 注册所有需要持久化的模型
        dbm.AddTable(User{}).SetKeys(true, "Id")
        // dbm.AddTable(AnotherModel{}).SetKeys(true, "Id") // 更多模型

        // 生产环境中通常不在这里调用CreateTables，而是在迁移脚本中处理
        err = dbm.CreateTablesIfNotExists()
        if err != nil {
            panic(fmt.Errorf("failed to create tables: %w", err))
        }
    }
    return dbm
}

// EnsureDbMapInitialized 确保DbMap已初始化，并在必要时返回
func EnsureDbMapInitialized() *gorp.DbMap {
    if dbm == nil {
        return InitDbMap()
    }
    return dbm
}

// GenericCreate 通用创建函数，接收任何结构体实例
func GenericCreate(obj interface{}) error {
    dbMap := EnsureDbMapInitialized()
    err := dbMap.Insert(obj)
    if err != nil {
        return fmt.Errorf("failed to insert object of type %T: %w", obj, err)
    }
    return nil
}

// GenericDelete 通用删除函数，接收任何结构体实例
func GenericDelete(obj interface{}) (int64, error) {
    dbMap := EnsureDbMapInitialized()
    nrows, err := dbMap.Delete(obj)
    if err != nil {
        return 0, fmt.Errorf("failed to delete object of type %T: %w", obj, err)
    }
    return nrows, nil
}

// GenericUpdate 通用更新函数，接收任何结构体实例
func GenericUpdate(obj interface{}) (int64, error) {
    dbMap := EnsureDbMapInitialized()
    nrows, err := dbMap.Update(obj)
    if err != nil {
        return 0, fmt.Errorf("failed to update object of type %T: %w", obj, err)
    }
    return nrows, nil
}

// User 业务模型
type User struct {
    GorpModel // 嵌入GorpModel，但通常不需要db:"-"，因为GorpModel的字段已标记db:"-"
    Id        int64  `db:"id"`
    Name      string `db:"name"`
    Email     string `db:"email"`
}

// Save 方法可以在业务模型上定义，利用通用的CRUD函数
func (u *User) Save() error {
    if u.New {
        fmt.Println("Inserting new user...")
        u.New = false // 插入后标记为非新
        return GenericCreate(u)
    } else {
        fmt.Println("Updating existing user...")
        _, err := GenericUpdate(u)
        return err
    }
}

// GetUserById 示例：根据ID获取用户
func GetUserById(id int64) (*User, error) {
    dbMap := EnsureDbMapInitialized()
    var user User
    err := dbMap.SelectOne(&user, "SELECT * FROM users WHERE id=?", id)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, nil // 未找到
        }
        return nil, fmt.Errorf("failed to get user by id %d: %w", id, err)
    }
    user.New = false // 从数据库加载的不是新记录
    return &user, nil
}

func main() {
    // 确保DbMap初始化
    InitDbMap()

    // 创建新用户
    newUser := &User{
        GorpModel: GorpModel{New: true},
        Name:      "Alice",
        Email:     "alice@example.com",
    }
    err := newUser.Save() // 调用业务模型的Save方法，内部调用GenericCreate
    if err != nil {
        fmt.Printf("Error saving new user: %v\n", err)
    } else {
        fmt.Printf("New user saved with ID: %d\n", newUser.Id)
    }

    // 获取并更新用户
    fetchedUser, err := GetUserById(newUser.Id)
    if err != nil {
        fmt.Printf("Error fetching user: %v\n", err)
    } else if fetchedUser != nil {
        fetchedUser.Name = "Alice Smith"
        err = fetchedUser.Save() // 内部调用GenericUpdate
        if err != nil {
            fmt.Printf("Error updating user: %v\n", err)
        } else {
            fmt.Printf("User updated: %s\n", fetchedUser.Name)
        }
    }

    // 删除用户
    if fetchedUser != nil {
        rowsAffected, err := GenericDelete(fetchedUser) // 直接调用通用删除函数
        if err != nil {
            fmt.Printf("Error deleting user: %v\n", err)
        } else {
            fmt.Printf("Deleted %d row(s).\n", rowsAffected)
        }
    }
}