Go语言中跨包变量访问与模块化设计实践

/src/github.com/Adel92/Sophie
  + user/
     - service.go
  - main.go

// main.go
package main

import "fmt"

// Application 结构体，首字母大写可导出
type Application struct {
    Name string
}

// Config 结构体，首字母大写可导出
type Config struct {
    Port int
}

var (
    App Application // 可导出的全局变量
    Cfg Config      // 可导出的全局变量
)

func init() {
    App = Application{Name: "SophieApp"}
    Cfg = Config{Port: 8080}
    fmt.Println("Main package initialized with App:", App.Name, "and Cfg Port:", Cfg.Port)
}

func main() {
    // 应用程序的入口点
    // ...
}

// user/service.go
package user

import (
    "fmt"
    "github.com/Adel92/Sophie" // 导入main包，假设项目根目录为Sophie
)

// RegisterUser 演示如何访问main包导出的变量
func RegisterUser() {
    // 通过导入的包名访问导出的变量
    fmt.Println("User package accessing App name:", sophie.App.Name)
    fmt.Println("User package accessing Cfg port:", sophie.Cfg.Port)
    // ... 用户注册逻辑
}

// user/service.go (在user包中定义服务)
package user

import (
    "fmt"
    "github.com/Adel92/Sophie" // 导入main包，以便使用其导出的类型
)

// UserService 结构体持有应用和配置的引用
type UserService struct {
    App *sophie.Application // 注入Application实例
    Cfg *sophie.Config      // 注入Config实例
}

// NewUserService 构造函数，用于创建UserService实例并注入依赖
func NewUserService(app *sophie.Application, cfg *sophie.Config) *UserService {
    return &UserService{App: app, Cfg: cfg}
}

// RegisterUser 是UserService的方法，通过其字段访问依赖
func (s *UserService) RegisterUser() {
    fmt.Println("UserService: Registering user with App name:", s.App.Name, "and Cfg port:", s.Cfg.Port)
    // ... 用户注册业务逻辑
}

// topic/service.go (在topic包中定义服务)
package topic

import (
    "fmt"
    "github.com/Adel92/Sophie"
)

type TopicService struct {
    App *sophie.Application
    Cfg *sophie.Config
}

func NewTopicService(app *sophie.Application, cfg *sophie.Config) *TopicService {
    return &TopicService{App: app, Cfg: cfg}
}

func (s *TopicService) ViewTopic() {
    fmt.Println("TopicService: Viewing topic with App name:", s.App.Name, "and Cfg port:", s.Cfg.Port)
    // ... 话题查看业务逻辑
}

// main.go (保持App和Cfg的定义)
package main

import (
    "fmt"
    "github.com/Adel92/Sophie/user"  // 导入user包
    "github.com/Adel92/Sophie/topic" // 导入topic包
)

// ... App, Cfg, init() ...

func main() {
    // 在main函数中初始化服务，并将App和Cfg的地址注入
    userService := user.NewUserService(&App, &Cfg)
    topicService := topic.NewTopicService(&App, &Cfg)

    // 调用服务方法
    userService.RegisterUser()
    topicService.ViewTopic()

    fmt.Println("Application started successfully.")
}

// store/store.go
package store

// DataStore 定义了通用的数据存储接口
type DataStore interface {
    Save(data interface{}) error
    FindByID(id string) (interface{}, error)
    // ... 其他通用操作
}

// user/repository.go
package user

import "github.com/Adel92/Sophie/store"

type UserRepository struct {
    DB store.DataStore // 注入数据存储接口
}

func NewUserRepository(db store.DataStore) *UserRepository {
    return &UserRepository{DB: db}
}

// SaveUser 实现用户保存逻辑，使用注入的DB
func (r *UserRepository) SaveUser(u User) error {
    return r.DB.Save(u)
}