掌握Go语言组合模式下的通用CRUD操作：解决gorp反射类型识别问题

package models

import (
    "database/sql"
    "fmt"
    "log" // 引入log包用于错误日志

    _ "github.com/go-sql-driver/mysql" // 导入MySQL驱动
    "github.com/coopernurse/gorp"
)

// GorpModel 可以包含通用的字段，但不再包含CRUD方法
type GorpModel struct {
    // Id        int64 `db:"id"` // 如果所有模型都有Id，可以放在这里
    // CreatedAt time.Time `db:"created_at"`
    // UpdatedAt time.Time `db:"updated_at"`
    // New       bool      `db:"-"` // 如果Save方法由具体结构体实现，这个字段可能仍有用
}

// dbm 实例应作为单例在应用启动时初始化一次
var dbm *gorp.DbMap

// InitDbMap 用于初始化数据库连接和注册所有表
// tables 参数接受任意数量的结构体实例，gorp将用它们来注册表
func InitDbMap(dataSourceName string, tables ...interface{}) error {
    if dbm != nil {
        log.Println("DbMap already initialized.")
        return nil // 已经初始化
    }

    db, err := sql.Open("mysql", dataSourceName)
    if err != nil {
        return fmt.Errorf("failed to open database: %w", err)
    }

    // 确保数据库连接在应用程序关闭时关闭
    // defer db.Close() // 注意：这里不应该关闭，DbMap会管理连接池

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

    for _, table := range tables {
        // 假设所有表都有Id作为主键，且是自增的
        // 实际应用中可能需要更灵活的配置，例如SetKeys(false, "UUID")
        dbm.AddTable(table).SetKeys(true, "Id")
    }

    // 创建表（如果不存在）
    if err = dbm.CreateTablesIfNotExists(); err != nil {
        return fmt.Errorf("failed to create tables: %w", err)
    }

    log.Println("DbMap initialized and tables checked.")
    return nil
}

// 通用创建函数，接受一个接口类型参数
func Create(obj interface{}) error {
    if err := dbm.Insert(obj); err != nil {
        return fmt.Errorf("failed to create object: %w", err)
    }
    return nil
}

// 通用删除函数，接受一个接口类型参数
func Delete(obj interface{}) (int64, error) {
    nrows, err := dbm.Delete(obj)
    if err != nil {
        return 0, fmt.Errorf("failed to delete object: %w", err)
    }
    return nrows, nil
}

// 通用更新函数，接受一个接口类型参数
func Update(obj interface{}) (int64, error) {
    nrows, err := dbm.Update(obj)
    if err != nil {
        return 0, fmt.Errorf("failed to update object: %w", err)
    }
    return nrows, nil
}

package models

import "fmt"

// User 结构体，嵌入 GorpModel
type User struct {
    GorpModel // 嵌入 GorpModel，获取其通用字段（如果定义了）
    Id        int64  `db:"id"`   // gorp会根据此字段自动填充
    Name      string `db:"name"`
    Email     string `db:"email"`
    // 其他业务字段
}

// Save 方法：根据Id是否为0判断是创建还是更新
func (u *User) Save() error {
    if u.Id == 0 { // 假设Id为0表示新记录
        return Create(u) // 调用通用创建函数，传入 *User 实例
    }
    _, err := Update(u) // 调用通用更新函数，传入 *User 实例
    return err
}

// FindUserById 示例：查询方法通常也接受参数，而不是直接在模型上
func FindUserById(id int64) (*User, error) {
    user := &User{}
    err := dbm.SelectOne(user, "SELECT * FROM users WHERE id=?", id)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, nil // 未找到
        }
        return nil, fmt.Errorf("failed to find user by id %d: %w", id, err)
    }
    return user, nil
}

// 注意：通常情况下，查询方法不会定义在 GorpModel 上，因为查询逻辑往往是针对特定表的。
// gorp.DbMap.SelectOne 或 Select 接受一个目标对象和SQL查询。

package main

import (
    "log"
    "myproject/models" // 假设你的models包路径是myproject/models
)

func main() {
    // 1. 初始化数据库连接和注册所有表
    // 注意：数据库连接字符串需要替换为你的实际信息
    dataSourceName := "username:password@tcp(127.0.0.1:3306)/my_db?charset=utf8mb4&parseTime=True&loc=Local"
    err := models.InitDbMap(dataSourceName, models.User{}) // 注册 User 表
    if err != nil {
        log.Fatalf("数据库初始化失败: %v", err)
    }

    // 2. 创建一个新用户
    user := &models.User{Name: "Alice", Email: "alice@example.com"}
    err = user.Save() // 调用 User 自己的 Save 方法，内部会调用通用的 Create
    if err != nil {
        log.Printf("创建用户失败: %v", err)
    } else {
        log.Printf("用户创建成功，ID: %d\n", user.Id)
    }

    // 3. 更新用户
    if user.Id != 0 {
        user.Name = "Alice Smith"
        err = user.Save() // 调用 User 自己的 Save 方法，内部会调用通用的 Update
        if err != nil {
            log.Printf("更新用户失败: %v", err)
        } else {
            log.Printf("用户更新成功，ID: %d, 新名称: %s\n", user.Id, user.Name)
        }
    }

    // 4. 查询用户
    fetchedUser, err := models.FindUserById(user.Id)
    if err != nil {
        log.Printf("查询用户失败: %v", err)
    } else if fetchedUser != nil {
        log.Printf("查询到用户: ID=%d, Name=%s, Email=%s\n", fetchedUser.Id, fetchedUser.Name, fetchedUser.Email)
    } else {
        log.Printf("未查询到用户 ID: %d\n", user.Id)
    }

    // 5. 删除用户
    if user.Id != 0 {
        nrows, err := models.Delete(user) // 调用通用删除函数，传入 *User 实例
        if err != nil {
            log.Printf("删除用户失败: %v", err)
        } else {
            log.Printf("删除用户成功，影响行数: %d\n", nrows)
        }
    }
}