Go语言模型结构化：避免循环引用与管理依赖的实践指南

// models/person/person.go
package person

import "models/team" // 引入team包

type Person struct {
    Name string
    Team team.Team // Person引用Team
}

// ... 其他方法

// models/team/team.go
package team

import "models/person" // 引入person包

type Team struct {
    Name   string
    People []*person.Person // Team引用Person
}

// ... 其他方法

// models/entities.go (或 models/person.go, models/team.go，只要包名相同即可)
package models

// Person 结构体定义
type Person struct {
    ID   int
    Name string
    Team *Team // 使用指针，允许Team为nil，避免值拷贝，并处理潜在的循环引用
}

// 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 NewTeam(id int, name string) *Team {
    return &Team{ID: id, Name: name, People: []*Person{}}
}

// 其他操作Person或Team的方法可以作为这些结构体的方法，或作为包级别的函数
// 例如：
// func GetPersonByID(id int) (*Person, error) { /* ... */ }
// func GetAllTeams() ([]*Team, error) { /* ... */ }

import "your_project/models"

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

    teamA.People = append(teamA.People, person1, person2)

    // 使用模型
    _ = person1.Name
    _ = teamA.Name
}

// repository/person_repository.go
package repository

import (
    "context"
    "database/sql"
    "your_project/models" // 引入模型包
)

// PersonRepository 定义了对Person模型进行数据操作的接口
type PersonRepository interface {
    GetByID(ctx context.Context, id int) (*models.Person, error)
    Save(ctx context.Context, person *models.Person) error
    GetAll(ctx context.Context) ([]*models.Person, error)
    // ... 其他操作
}

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

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

// GetByID 实现了从数据库获取Person的方法
func (r *SQLPersonRepository) GetByID(ctx context.Context, id int) (*models.Person, error) {
    // 实际的数据库查询逻辑
    row := r.db.QueryRowContext(ctx, "SELECT id, name, team_id FROM persons WHERE id = ?", id)
    var p models.Person
    var teamID sql.NullInt64 // 使用sql.NullInt64处理可空的team_id
    err := row.Scan(&p.ID, &p.Name, &teamID)
    if err == sql.ErrNoRows {
        return nil, nil // 或返回特定的NotFound错误
    }
    if err != nil {
        return nil, err
    }
    // 假设Team信息需要额外查询或通过Join获取
    if teamID.Valid {
        // 这里可以根据teamID查询Team，或者在更高级的服务层处理关联
        // 为简化示例，这里不进行Team的完整查询
        p.Team = &models.Team{ID: int(teamID.Int64)} // 仅设置ID
    }
    return &p, nil
}

// Save 实现了将Person保存到数据库的方法
func (r *SQLPersonRepository) Save(ctx context.Context, person *models.Person) error {
    // 实际的数据库插入或更新逻辑
    stmt, err := r.db.PrepareContext(ctx, "INSERT INTO persons(id, name, team_id) VALUES(?, ?, ?) ON DUPLICATE KEY UPDATE name=?, team_id=?")
    if err != nil {
        return err
    }
    defer stmt.Close()

    var teamID sql.NullInt64
    if person.Team != nil {
        teamID = sql.NullInt64{Int64: int64(person.Team.ID), Valid: true}
    } else {
        teamID = sql.NullInt64{Valid: false}
    }

    _, err = stmt.ExecContext(ctx, person.ID, person.Name, teamID, person.Name, teamID)
    return err
}

// ... 其他方法

// service/person_service.go
package service

import (
    "context"
    "fmt"
    "your_project/models"
    "your_project/repository"
)

// PersonService 提供了与Person相关的业务逻辑
type PersonService struct {
    personRepo repository.PersonRepository // 依赖PersonRepository接口
}

// NewPersonService 创建一个新的PersonService实例
func NewPersonService(repo repository.PersonRepository) *PersonService {
    return &PersonService{personRepo: repo}
}

// GetPersonDetails 获取Person的详细信息，可能涉及多个数据源
func (s *PersonService) GetPersonDetails(ctx context.Context, id int) (*models.Person, error) {
    person, err := s.personRepo.GetByID(ctx, id)
    if err != nil {
        return nil, fmt.Errorf("failed to get person by ID %d: %w", id, err)
    }
    if person == nil {
        return nil, fmt.Errorf("person with ID %d not found", id)
    }
    // 这里可以添加更多业务逻辑，例如获取关联的Team信息
    // if person.Team != nil {
    //    team, err := s.teamRepo.GetByID(ctx, person.Team.ID)
    //    person.Team = team
    // }
    return person, nil
}

// CreatePerson 创建一个新Person
func (s *PersonService) CreatePerson(ctx context.Context, person *models.Person) error {
    // 业务逻辑验证等
    if person.Name == "" {
        return fmt.Errorf("person name cannot be empty")
    }
    return s.personRepo.Save(ctx, person)
}

// main.go
package main

import (
    "context"
    "database/sql"
    "log"
    "your_project/models"
    "your_project/repository"
    "your_project/service"

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

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

    if err = db.Ping(); err != nil {
        log.Fatalf("failed to ping database: %v", err)
    }
    log.Println("Database connection established.")

    // 2. 创建Repository实现
    personRepo := repository.NewSQLPersonRepository(db)

    // 3. 创建Service层，并注入Repository依赖
    personService := service.NewPersonService(personRepo)

    // 4. 使用Service进行业务操作
    ctx := context.Background()

    // 示例：创建一个人
    newPerson := models.NewPerson(1, "Jane Doe", nil) // 假设Team后续关联
    err = personService.CreatePerson(ctx, newPerson)
    if err != nil {
        log.Printf("Error creating person: %v", err)
    } else {
        log.Printf("Person created: %+v", newPerson)
    }

    // 示例：获取一个人
    fetchedPerson, err := personService.GetPersonDetails(ctx, 1)
    if err != nil {
        log.Printf("Error fetching person: %v", err)
    } else if fetchedPerson != nil {
        log.Printf("Fetched person: %+v", fetchedPerson)
    }
}