Go语言中命令行标志冲突的解析与最佳实践

// package settings (不推荐在init中调用flag.Parse())
package settings

import (
    "flag"
    "fmt"
)

var (
    ConfigPath = flag.String("config", "/etc/app/config.json", "Path to configuration file")
    DebugMode  = flag.Bool("debug", false, "Enable debug mode")
)

func init() {
    // 强烈不推荐在这里调用 flag.Parse()，因为它会导致全局标志冲突
    // if !flag.Parsed() {
    //     flag.Parse() // 错误示例！可能导致冲突
    // }
    fmt.Println("Settings package init called. Flags defined but not parsed here.")
}

// GetConfigPath 允许其他包获取配置路径，但解析应由main包负责
func GetConfigPath() string {
    // 理论上，在调用此函数时，flag.Parse()应该已经被main包调用
    // 如果没有，这里获取到的将是默认值
    return *ConfigPath
}

// package main (推荐的调用方式)
/*
package main

import (
    "flag"
    "fmt"
    "your_module/settings" // 假设settings包在你自己的模块中
)

func main() {
    // 在main函数中统一调用flag.Parse()
    flag.Parse()

    fmt.Printf("Config Path: %s\n", settings.GetConfigPath())
    fmt.Printf("Debug Mode: %t\n", *settings.DebugMode)

    // ... 应用程序逻辑
}
*/

package settings

import (
    "flag"
    "fmt"
)

var (
    DatabaseURL = flag.String("db-url", "localhost:5432", "Database connection URL")
    MaxConnections = flag.Int("max-conn", 10, "Maximum database connections")
)

func init() {
    fmt.Println("Settings package init: Database flags defined.")
}

// GetDatabaseConfig 返回数据库配置，确保标志已被解析
func GetDatabaseConfig() (string, int) {
    if !flag.Parsed() {
        // 这是一个警告或错误处理，表明flag.Parse()尚未被调用
        // 在实际应用中，如果此函数在main包调用flag.Parse()之前被调用，
        // 那么获取到的值将是默认值。
        fmt.Println("Warning: flag.Parse() has not been called yet. Returning default database config.")
    }
    return *DatabaseURL, *MaxConnections
}

package component

import (
    "flag"
    "fmt"
)

type ComponentConfig struct {
    WorkerCount int
    QueueName   string
}

// NewComponentConfigFromArgs 从给定的参数中解析组件配置
func NewComponentConfigFromArgs(args []string) (*ComponentConfig, error) {
    // 创建一个独立的FlagSet
    fs := flag.NewFlagSet("component", flag.ContinueOnError) // ContinueOnError允许解析在出错时继续
    workerCount := fs.Int("workers", 5, "Number of worker goroutines")
    queueName := fs.String("queue", "default", "Name of the message queue")

    // 解析传入的参数，而不是全局os.Args
    err := fs.Parse(args)
    if err != nil {
        return nil, fmt.Errorf("failed to parse component flags: %w", err)
    }

    return &ComponentConfig{
        WorkerCount: *workerCount,
        QueueName:   *queueName,
    }, nil
}

// 示例：如何在main包中使用
/*
package main

import (
    "flag"
    "fmt"
    "os"
    "your_module/component" // 假设component包在你自己的模块中
)

func main() {
    // 定义main包的全局标志
    verbose := flag.Bool("v", false, "Enable verbose output")
    flag.Parse() // 解析全局标志

    if *verbose {
        fmt.Println("Verbose mode enabled.")
    }

    // 模拟传递给组件的参数
    // 注意：这里需要手动构造传递给FlagSet的参数切片
    // 实际应用中，你可能需要从os.Args中筛选出特定前缀的参数
    componentArgs := []string{"-workers", "10", "-queue", "priority"}

    // 使用FlagSet解析组件的特定参数
    config, err := component.NewComponentConfigFromArgs(componentArgs)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("Component Config: Workers=%d, Queue=%s\n", config.WorkerCount, config.QueueName)
}
*/

package service

import "fmt"

// ServiceConfig 定义了服务的配置
type ServiceConfig struct {
    Host string
    Port int
    Timeout int
}

// NewService 创建一个新服务实例
func NewService(cfg ServiceConfig) *Service {
    // 根据配置初始化服务
    fmt.Printf("Initializing Service with Host: %s, Port: %d, Timeout: %d\n", cfg.Host, cfg.Port, cfg.Timeout)
    return &Service{
        config: cfg,
    }
}

type Service struct {
    config ServiceConfig
    // ... 其他服务状态
}

func (s *Service) Start() {
    fmt.Println("Service started.")
    // ... 启动服务逻辑
}

// 示例：如何在main包中配置和使用
/*
package main

import (
    "flag"
    "fmt"
    "your_module/service" // 假设service包在你自己的模块中
)

func main() {
    // 定义全局标志，用于配置服务
    host := flag.String("service-host", "localhost", "Service host address")
    port := flag.Int("service-port", 8080, "Service port")
    timeout := flag.Int("service-timeout", 30, "Service timeout in seconds")

    flag.Parse() // 解析所有全局标志

    // 使用解析到的标志值来构造服务配置
    cfg := service.ServiceConfig{
        Host: *host,
        Port: *port,
        Timeout: *timeout,
    }

    // 通过API传递配置来创建服务实例
    myService := service.NewService(cfg)
    myService.Start()
}
*/