Go语言中模型（Model）的结构化实践与依赖管理

// project_root/pkg/model/model.go
package model

// Person 定义了个人信息
type Person struct {
    ID   int
    Name string
    Team *Team // Person可以直接引用同一包内的Team类型
}

// Team 定义了团队信息
type Team struct {
    ID     int
    Name   string
    People []*Person // Team可以直接引用同一包内的Person类型
}

// NewPerson 是一个创建Person实例的辅助函数
func NewPerson(id int, name string, team *Team) *Person {
    return &Person{ID: id, Name: name, Team: team}
}

// NewTeam 是一个创建Team实例的辅助函数
func Team(id int, name string, people []*Person) *Team {
    return &Team{ID: id, Name: name, People: people}
}

// 外部包使用示例
package main

import (
    "fmt"
    "project_root/pkg/model"
)

func main() {
    teamA := model.NewTeam(1, "Alpha Team", nil)
    person1 := model.NewPerson(101, "Alice", teamA)
    person2 := model.NewPerson(102, "Bob", teamA)

    teamA.People = []*model.Person{person1, person2}

    fmt.Printf("Person: %s, Team: %s\n", person1.Name, person1.Team.Name)
    fmt.Printf("Team: %s, Members: %d\n", teamA.Name, len(teamA.People))
}

// project_root/pkg/repository/person_repository.go
package repository

import (
    "database/sql"
    "fmt"
    "project_root/pkg/model" // 导入模型包
)

// PersonRepository 定义了对Person模型的数据库操作接口
type PersonRepository interface {
    GetByID(id int) (*model.Person, error)
    GetAll() ([]*model.Person, error)
    Save(person *model.Person) error
    Delete(id int) error
}

// SQLPersonRepository 是PersonRepository接口的一个SQL实现
type SQLPersonRepository struct {
    db *sql.DB // 数据库连接实例
}

// NewSQLPersonRepository 创建一个新的SQLPersonRepository实例
func NewSQLPersonRepository(db *sql.DB) *SQLPersonRepository {
    return &SQLPersonRepository{db: db}
}

// GetByID 根据ID从数据库中获取Person
func (r *SQLPersonRepository) GetByID(id int) (*model.Person, error) {
    row := r.db.QueryRow("SELECT id, name, team_id FROM persons WHERE id = ?", id)
    p := &model.Person{}
    var teamID sql.NullInt64 // 使用sql.NullInt64处理可能为NULL的team_id
    err := row.Scan(&p.ID, &p.Name, &teamID)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, nil // 表示未找到
        }
        return nil, fmt.Errorf("failed to get person by ID %d: %w", id, err)
    }

    // 如果teamID有效，可以进一步查询Team信息并赋值给p.Team
    if teamID.Valid {
        // 假设有一个TeamRepository或者可以直接查询
        // team, err := r.teamRepo.GetByID(teamID.Int64)
        // if err != nil { /* handle error */ }
        // p.Team = team
    }
    return p, nil
}

// GetAll 从数据库中获取所有Person
func (r *SQLPersonRepository) GetAll() ([]*model.Person, error) {
    rows, err := r.db.Query("SELECT id, name, team_id FROM persons")
    if err != nil {
        return nil, fmt.Errorf("failed to get all persons: %w", err)
    }
    defer rows.Close()

    var persons []*model.Person
    for rows.Next() {
        p := &model.Person{}
        var teamID sql.NullInt64
        if err := rows.Scan(&p.ID, &p.Name, &teamID); err != nil {
            return nil, fmt.Errorf("failed to scan person row: %w", err)
        }
        // ... 处理teamID
        persons = append(persons, p)
    }
    if err = rows.Err(); err != nil {
        return nil, fmt.Errorf("rows iteration error: %w", err)
    }
    return persons, nil
}

// Save 将Person保存到数据库（插入或更新）
func (r *SQLPersonRepository) Save(person *model.Person) error {
    // 实际的插入或更新逻辑
    // ...
    return nil
}

// Delete 根据ID删除Person
func (r *SQLPersonRepository) Delete(id int) error {
    // 实际的删除逻辑
    // ...
    return nil
}

// project_root/cmd/api/main.go
package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"

    _ "github.com/go-sql-driver/mysql" // 导入数据库驱动

    "project_root/pkg/handler"
    "project_root/pkg/repository"
)

func main() {
    // 1. 初始化数据库连接
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
    if err != nil {
        log.Fatalf("failed to open database connection: %v", err)
    }
    defer db.Close()

    // 检查数据库连接是否有效
    if err = db.Ping(); err != nil {
        log.Fatalf("failed to connect to database: %v", err)
    }
    fmt.Println("Successfully connected to database!")

    // 2. 创建仓库实例，并注入数据库连接
    personRepo := repository.NewSQLPersonRepository(db)
    // teamRepo := repository.NewSQLTeamRepository(db) // 如果有TeamRepository

    // 3. 创建HTTP处理器，并注入仓库实例
    personHandler := handler.NewPersonHandler(personRepo)

    // 4. 注册路由
    http.HandleFunc("/persons", personHandler.ListPersons)
    http.HandleFunc("/persons/", personHandler.GetPerson) // 假设有路径参数处理

    fmt.Println("Server starting on port 8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}