Go 项目启动 Install 函数设计指南：优雅初始化的实践方案

package main

import (
    "database/sql"
    "github.com/go-redis/redis/v8"
    "log"
    "sync"
)

// 全局配置结构体，聚合各模块配置
type AppConfig struct {
    DBConfig   DBConfig   // 数据库配置
    RedisConfig RedisConfig // Redis配置
    LogConfig  LogConfig  // 日志配置
    ServerConfig ServerConfig // 服务配置
}

// 数据库配置
type DBConfig struct {
    DSN      string // 连接地址
    MaxOpenConns int // 最大打开连接数
    MaxIdleConns int // 最大空闲连接数
}

// Redis配置
type RedisConfig struct {
    Addr     string // 地址
    Password string // 密码
    DB       int    // 数据库编号
}

// 日志配置
type LogConfig struct {
    Level string // 日志级别
    Path  string // 日志路径
}

// 服务配置
type ServerConfig struct {
    Port int // 端口
}

// 全局资源结构体，存储初始化后的实例
type AppResources struct {
    DB    *sql.DB
    Redis *redis.Client
    Logger *log.Logger
}

var (
    resources AppResources // 全局资源实例
    once      sync.Once    // 用于保证初始化只执行一次
)

// 日志模块初始化
func LogInstall(config LogConfig) (*log.Logger, error) {
    // 1. 打印初始化日志
    log.Printf("开始初始化日志模块，配置：%+v", config)

    // 2. 模拟日志初始化逻辑（实际可替换为zap、logrus等库）
    logger := log.Default()
    // 这里可根据config配置日志输出路径、级别等

    log.Println("日志模块初始化成功")
    return logger, nil
}

// 数据库模块初始化
func DBInstall(config DBConfig, logger *log.Logger) (*sql.DB, error) {
    // 1. 打印初始化日志
    logger.Printf("开始初始化数据库模块，配置：%+v", config)

    // 2. 幂等性处理：如果已初始化则直接返回
    if resources.DB != nil {
        logger.Println("数据库模块已初始化，直接返回实例")
        return resources.DB, nil
    }

    // 3. 实际初始化逻辑
    db, err := sql.Open("mysql", config.DSN)
    if err != nil {
        logger.Printf("数据库连接失败：%v", err)
        return nil, err
    }

    // 4. 配置连接池
    db.SetMaxOpenConns(config.MaxOpenConns)
    db.SetMaxIdleConns(config.MaxIdleConns)

    // 5. 验证连接
    if err := db.Ping(); err != nil {
        logger.Printf("数据库 ping 失败：%v", err)
        return nil, err
    }

    logger.Println("数据库模块初始化成功")
    return db, nil
}

// Redis模块初始化
func RedisInstall(config RedisConfig, logger *log.Logger) (*redis.Client, error) {
    logger.Printf("开始初始化Redis模块，配置：%+v", config)

    if resources.Redis != nil {
        logger.Println("Redis模块已初始化，直接返回实例")
        return resources.Redis, nil
    }

    client := redis.NewClient(&redis.Options{
        Addr:     config.Addr,
        Password: config.Password,
        DB:       config.DB,
    })

    // 验证连接
    _, err := client.Ping(context.Background()).Result()
    if err != nil {
        logger.Printf("Redis连接失败：%v", err)
        return nil, err
    }

    logger.Println("Redis模块初始化成功")
    return client, nil
}

// 主初始化函数，统一调度所有模块
func AppInstall(config AppConfig) (AppResources, error) {
    var err error
    // 使用sync.Once保证整个应用初始化只执行一次
    once.Do(func() {
        // 1. 先初始化日志模块（后续模块依赖日志）
        resources.Logger, err = LogInstall(config.LogConfig)
        if err != nil {
            err = fmt.Errorf("日志模块初始化失败：%w", err)
            return
        }

        // 2. 初始化数据库模块（依赖日志）
        resources.DB, err = DBInstall(config.DBConfig, resources.Logger)
        if err != nil {
            resources.Logger.Printf("数据库模块初始化失败：%v", err)
            err = fmt.Errorf("数据库模块初始化失败：%w", err)
            return
        }

        // 3. 初始化Redis模块（依赖日志）
        resources.Redis, err = RedisInstall(config.RedisConfig, resources.Logger)
        if err != nil {
            resources.Logger.Printf("Redis模块初始化失败：%v", err)
            err = fmt.Errorf("Redis模块初始化失败：%w", err)
            return
        }

        // 4. 初始化服务（依赖前面所有模块）
        resources.Logger.Printf("开始初始化服务，端口：%d", config.ServerConfig.Port)
        // 这里可添加HTTP服务初始化逻辑，如gin、echo等框架的初始化
        resources.Logger.Println("服务模块初始化成功")
    })

    if err != nil {
        return AppResources{}, err
    }
    return resources, nil
}

func main() {
    // 1. 加载配置（实际开发中可从文件、环境变量、配置中心加载）
    config := AppConfig{
        DBConfig: DBConfig{
            DSN:      "root:123456@tcp(127.0.0.1:3306)/testdb",
            MaxOpenConns: 10,
            MaxIdleConns: 5,
        },
        RedisConfig: RedisConfig{
            Addr:     "127.0.0.1:6379",
            Password: "",
            DB:       0,
        },
        LogConfig: LogConfig{
            Level: "info",
            Path:  "./logs/app.log",
        },
        ServerConfig: ServerConfig{
            Port: 8080,
        },
    }

    // 2. 执行初始化
    resources, err := AppInstall(config)
    if err != nil {
        log.Fatalf("应用初始化失败，退出程序：%v", err)
    }

    // 3. 启动服务（这里仅做示例，实际可启动HTTP服务等）
    resources.Logger.Printf("应用启动成功，端口：%d", config.ServerConfig.Port)

    // 4. 阻塞进程（实际开发中可监听信号量，实现优雅关闭）
    select {}
}