Golang中命令行参数冲突的解决策略与最佳实践

// main.go
package main

import (
    "flag"
    "fmt"
    // 假设你的其他包定义了旗标，但不在init()中调用flag.Parse()
    "your_module/config"
)

var (
    globalVerbose = flag.Bool("v", false, "Enable verbose output globally")
)

func main() {
    // 在此处集中调用flag.Parse()
    flag.Parse()

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

    // 其他包定义的旗标，如config.MySetting，现在可以安全地访问其值
    fmt.Printf("Config setting from another package: %s\n", *config.MySetting)

    // 应用程序的其他逻辑
}

// config/config.go
package config

import "flag"

var (
    MySetting = flag.String("mysetting", "default-value", "A setting from the config package.")
)

// 注意：不要在此包的init()函数中调用 flag.Parse()
// func init() {
//     flag.Parse() // 错误！会导致冲突
// }

// mylib/mylib.go
package mylib

import (
    "flag"
    "fmt"
)

var (
    // 定义一个库特定的旗标
    LibSpecificFlag = flag.String("lib-flag", "default-lib-value", "A flag specific to mylib.")
)

// GetLibFlagValue 提供一个方法来获取旗标的值
func GetLibFlagValue() string {
    // 理论上，在访问旗标值之前，flag.Parse() 应该已经被调用。
    // 如果不确定，可以使用 flag.Parsed() 进行检查，但这通常意味着设计上可能存在问题。
    if !flag.Parsed() {
        fmt.Println("Warning: flag.Parse() has not been called yet. Value might be default or unparsed.")
    }
    return *LibSpecificFlag
}

// main.go
package main

import (
    "flag"
    "fmt"
    "your_module/mylib" // 导入定义了旗标的库
)

func main() {
    // 在主函数中统一解析所有旗标
    flag.Parse()

    // 现在可以安全地访问mylib中定义的旗标值
    fmt.Printf("Value from mylib: %s\n", mylib.GetLibFlagValue())
}

// mycomponent/component.go
package mycomponent

import (
    "flag"
    "fmt"
    "os"
)

type ComponentConfig struct {
    Name string
    Port int
}

// NewComponentConfigFromArgs 从给定的参数列表中解析组件配置
func NewComponentConfigFromArgs(args []string) (*ComponentConfig, error) {
    // 创建一个独立的FlagSet
    fs := flag.NewFlagSet("mycomponent", flag.ContinueOnError) // ContinueOnError 允许在解析错误时继续执行
    name := fs.String("name", "default-comp", "Component name")
    port := fs.Int("port", 8080, "Component port")

    // 解析传入的参数列表
    err := fs.Parse(args)
    if err != nil {
        return nil, fmt.Errorf("failed to parse component flags: %w", err)
    }

    return &ComponentConfig{
        Name: *name,
        Port: *port,
    }, nil
}

// main.go
package main

import (
    "flag"
    "fmt"
    "os"
    "strings"
    "your_module/mycomponent" // 导入组件包
)

var (
    globalDebug = flag.Bool("debug", false, "Enable global debug mode")
)

func main() {
    // 先解析全局旗标
    flag.Parse()

    if *globalDebug {
        fmt.Println("Global debug mode is enabled.")
    }

    // 假设组件的旗标以 "--comp." 前缀开头
    var componentArgs []string
    for _, arg := range os.Args[1:] { // 遍历原始命令行参数
        if strings.HasPrefix(arg, "--comp.") {
            // 移除前缀，将剩余部分作为组件的独立参数
            componentArgs = append(componentArgs, strings.TrimPrefix(arg, "--comp."))
        }
    }

    // 使用FlagSet解析组件的特定参数
    compConfig, err := mycomponent.NewComponentConfigFromArgs(componentArgs)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("Component Config: Name=%s, Port=%d\n", compConfig.Name, compConfig.Port)

    // 应用程序的其他逻辑
}

// mylib/service.go
package mylib

import "fmt"

// ServiceSettings 定义了服务的所有可配置项
type ServiceSettings struct {
    LogLevel       string
    MaxConnections int
    TimeoutSeconds int
}

// NewService 创建并返回一个新的服务实例
// 配置通过ServiceSettings结构体传入
func NewService(settings ServiceSettings) *Service {
    fmt.Printf("Service initialized with LogLevel: %s, MaxConnections: %d, Timeout: %d s\n",
        settings.LogLevel, settings.MaxConnections, settings.TimeoutSeconds)
    return &Service{
        settings: settings,
    }
}

// Service 是一个示例服务
type Service struct {
    settings ServiceSettings
}

// Start 启动服务
func (s *Service) Start() {
    fmt.Println("Service started.")
    // ... 使用 s.settings 中的配置启动服务
}

// main.go
package main

import (
    "flag"
    "fmt"
    "your_module/mylib" // 导入库
)

var (
    // 定义全局命令行参数，用于配置mylib服务
    logLevel       = flag.String("log-level", "info", "Log level for the service")
    maxConnections = flag.Int("max-conns", 10, "Maximum connections for the service")
    timeout        = flag.Int("timeout", 30, "Service timeout in seconds")
)

func main() {
    // 在主函数中统一解析所有旗标
    flag.Parse()

    // 将解析到的参数组装成mylib所需的配置结构体
    serviceSettings := mylib.ServiceSettings{
        LogLevel:       *logLevel,
        MaxConnections: *maxConnections,
        TimeoutSeconds: *timeout,
    }

    // 使用配置创建服务实例
    service := mylib.NewService(serviceSettings)
    service.Start()

    fmt.Println("Application finished.")
}