Go语言中嵌入结构体与ORM反射：实现通用CRUD操作的策略

package models

import (
    "database/sql"
    "fmt"
    "reflect"

    "github.com/coopernurse/gorp"
    _ "github.com/go-sql-driver/mysql"
)

type GorpModel struct {
    New bool `db:"-"`
}

var dbm *gorp.DbMap = nil

func (gm *GorpModel) DbInit() {
    gm.New = true
    if dbm == nil {
        db, err := sql.Open("mysql", "username:password@my_db")
        if err != nil {
            panic(err)
        }
        dbm = &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
        // 这里的User{}需要是具体模型，但GorpModel方法无法得知
        dbm.AddTable(User{}).SetKeys(true, "Id") 
        dbm.CreateTables()
    }
}

func (gm *GorpModel) Create() {
    // 问题所在：dbm.Insert(gm) 会将 gm 的类型识别为 *GorpModel
    err := dbm.Insert(gm) 
    if err != nil {
        panic(err)
    }
}

func (gm *GorpModel) Delete() int64 {
    // 同理，dbm.Delete(gm) 会将 gm 的类型识别为 *GorpModel
    nrows, err := dbm.Delete(gm)
    if err != nil {
        panic(err)
    }
    return nrows
}

func (gm *GorpModel) Update() {
    // 同理，dbm.Update(gm) 会将 gm 的类型识别为 *GorpModel
    _, err := dbm.Update(gm)
    if err != nil {
        panic(err)
    }
}

package models

import (
    "database/sql"
    "log" // 使用log替代panic，更优雅地处理错误

    "github.com/coopernurse/gorp"
    _ "github.com/go-sql-driver/mysql"
)

// GorpModel 包含所有模型通用的字段
type GorpModel struct {
    New bool `db:"-"` // 标记是否为新创建的模型
    // 可以在这里添加其他通用字段，如 CreateAt, UpdateAt 等
}

// DbMap实例，通常在应用程序启动时初始化一次
var dbm *gorp.DbMap = nil

// InitDb 初始化数据库连接和gorp的DbMap
// 这是一个独立的函数，或者可以作为某个服务的一部分
func InitDb() *gorp.DbMap {
    if dbm == nil {
        db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/my_db?parseTime=true") // 示例连接字符串
        if err != nil {
            log.Fatalf("Failed to open database connection: %v", err)
        }
        // 确保数据库连接在程序退出时关闭
        // defer db.Close() // 注意：对于全局dbm，不应在此处defer Close()，而应在应用程序生命周期结束时手动关闭

        dbm = &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}

        // 示例：添加一个User表。在实际应用中，这里应该根据所有需要持久化的模型动态添加。
        // 通常会在应用启动时遍历所有模型并调用AddTable。
        // dbm.AddTable(User{}).SetKeys(true, "Id") // 这行应该在具体模型的初始化或注册阶段完成

        // dbm.CreateTables() // 仅在开发环境或首次部署时使用，生产环境需谨慎
    }
    return dbm
}

// Create 插入一个对象到数据库
func Create(obj interface{}) error {
    if dbm == nil {
        return fmt.Errorf("database map is not initialized")
    }
    if err := dbm.Insert(obj); err != nil {
        return fmt.Errorf("failed to insert object: %w", err)
    }
    return nil
}

// Update 更新数据库中的一个对象
func Update(obj interface{}) error {
    if dbm == nil {
        return fmt.Errorf("database map is not initialized")
    }
    if _, err := dbm.Update(obj); err != nil {
        return fmt.Errorf("failed to update object: %w", err)
    }
    return nil
}

// Delete 从数据库中删除一个对象
func Delete(obj interface{}) (int64, error) {
    if dbm == nil {
        return 0, fmt.Errorf("database map is not initialized")
    }
    nrows, err := dbm.Delete(obj)
    if err != nil {
        return 0, fmt.Errorf("failed to delete object: %w", err)
    }
    return nrows, nil
}

// GetById 根据ID从数据库获取一个对象
// 注意：此函数需要知道具体的类型和ID字段，通常需要类型断言或泛型（Go 1.18+）
// 简单示例：
func GetById(obj interface{}, id interface{}) error {
    if dbm == nil {
        return fmt.Errorf("database map is not initialized")
    }
    if err := dbm.Get(obj, id); err != nil {
        return fmt.Errorf("failed to get object by ID: %w", err)
    }
    return nil
}

// User 是一个具体的业务模型
type User struct {
    GorpModel `db:"-"` // 嵌入GorpModel，db:"-" 表示不将其字段映射到数据库表
    Id        int64    `db:"id"`
    Name      string   `db:"name"`
    Email     string   `db:"email"`
}

// 示例用法
func main() {
    // 1. 初始化数据库
    dbMap := InitDb()
    defer func() {
        if dbMap != nil && dbMap.Db != nil {
            if err := dbMap.Db.Close(); err != nil {
                log.Printf("Error closing database: %v", err)
            }
        }
    }()

    // 2. 注册表（通常在应用启动时完成）
    // 在生产环境中，表结构通常通过迁移工具管理，这里仅为gorp注册Go结构体与数据库表的映射
    dbMap.AddTableWithName(User{}, "users").SetKeys(true, "Id")
    // dbMap.CreateTablesIfNotExists() // 仅用于开发环境

    // 3. 创建一个新用户
    newUser := &User{
        Name:  "Alice",
        Email: "alice@example.com",
    }
    newUser.New = true // 标记为新对象

    if err := Create(newUser); err != nil {
        log.Fatalf("Failed to create user: %v", err)
    }
    log.Printf("User created with ID: %d", newUser.Id) // gorp会自动填充Id

    // 4. 更新用户
    newUser.Name = "Alice Smith"
    if err := Update(newUser); err != nil {
        log.Fatalf("Failed to update user: %v", err)
    }
    log.Printf("User updated: %s", newUser.Name)

    // 5. 获取用户
    retrievedUser := &User{}
    if err := GetById(retrievedUser, newUser.Id); err != nil {
        log.Fatalf("Failed to retrieve user: %v", err)
    }
    log.Printf("Retrieved user: %+v", retrievedUser)

    // 6. 删除用户
    nrows, err := Delete(newUser)
    if err != nil {
        log.Fatalf("Failed to delete user: %v", err)
    }
    log.Printf("Deleted %d rows.", nrows)
}