Golang中读取和解析/验证配置文件的惯用方法是什么

在Go中处理配置解析和验证的惯用方法是采用“解析而非验证”的模式。以下是一个结合Viper的实现示例，包含类型安全的解析、默认值设置和错误处理：

package logging

import (
    "fmt"
    "strconv"
    "strings"

    "github.com/spf13/viper"
)

type LogLevel int

const (
    LevelDebug LogLevel = iota
    LevelInfo
    LevelWarn
    LevelError
)

type Configuration struct {
    Level LogLevel `mapstructure:"LOGGING_LEVEL"`
}

// 解析函数，将配置转换为类型安全的结构
func ParseConfiguration() (Configuration, error) {
    var config Configuration
    
    // 设置默认值
    viper.SetDefault("LOGGING_LEVEL", "info")
    
    // 获取原始值并解析
    levelStr := viper.GetString("LOGGING_LEVEL")
    level, err := parseLogLevel(levelStr)
    if err != nil {
        return Configuration{}, fmt.Errorf("invalid log level: %w", err)
    }
    
    config.Level = level
    return config, nil
}

// 类型安全的解析函数
func parseLogLevel(s string) (LogLevel, error) {
    switch strings.ToLower(s) {
    case "debug", "0":
        return LevelDebug, nil
    case "info", "1":
        return LevelInfo, nil
    case "warn", "warning", "2":
        return LevelWarn, nil
    case "error", "err", "3":
        return LevelError, nil
    default:
        // 尝试解析为数字
        if i, err := strconv.Atoi(s); err == nil {
            if i >= 0 && i <= 3 {
                return LogLevel(i), nil
            }
        }
        return LevelInfo, fmt.Errorf("invalid log level: %s", s)
    }
}

// 使用示例
func init() {
    viper.SetEnvPrefix("MY_APP")
    viper.AutomaticEnv()
}

func GetConfiguration() (Configuration, error) {
    return ParseConfiguration()
}

对于更复杂的配置结构，可以使用工厂模式：

package config

import (
    "time"
    
    "github.com/spf13/viper"
)

type DatabaseConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    Timeout  time.Duration
}

type ServerConfig struct {
    Addr         string
    ReadTimeout  time.Duration
    WriteTimeout time.Duration
}

type Config struct {
    Database DatabaseConfig
    Server   ServerConfig
    LogLevel string
}

func ParseConfig() (*Config, error) {
    // 设置默认值
    viper.SetDefault("SERVER_ADDR", ":8080")
    viper.SetDefault("SERVER_READ_TIMEOUT", "30s")
    viper.SetDefault("SERVER_WRITE_TIMEOUT", "30s")
    viper.SetDefault("DB_HOST", "localhost")
    viper.SetDefault("DB_PORT", 5432)
    viper.SetDefault("DB_TIMEOUT", "10s")
    viper.SetDefault("LOG_LEVEL", "info")
    
    // 解析持续时间
    readTimeout, err := time.ParseDuration(viper.GetString("SERVER_READ_TIMEOUT"))
    if err != nil {
        return nil, fmt.Errorf("invalid read timeout: %w", err)
    }
    
    writeTimeout, err := time.ParseDuration(viper.GetString("SERVER_WRITE_TIMEOUT"))
    if err != nil {
        return nil, fmt.Errorf("invalid write timeout: %w", err)
    }
    
    dbTimeout, err := time.ParseDuration(viper.GetString("DB_TIMEOUT"))
    if err != nil {
        return nil, fmt.Errorf("invalid database timeout: %w", err)
    }
    
    // 验证端口范围
    dbPort := viper.GetInt("DB_PORT")
    if dbPort < 1 || dbPort > 65535 {
        return nil, fmt.Errorf("invalid database port: %d", dbPort)
    }
    
    return &Config{
        Database: DatabaseConfig{
            Host:     viper.GetString("DB_HOST"),
            Port:     dbPort,
            Username: viper.GetString("DB_USERNAME"),
            Password: viper.GetString("DB_PASSWORD"),
            Timeout:  dbTimeout,
        },
        Server: ServerConfig{
            Addr:         viper.GetString("SERVER_ADDR"),
            ReadTimeout:  readTimeout,
            WriteTimeout: writeTimeout,
        },
        LogLevel: viper.GetString("LOG_LEVEL"),
    }, nil
}

对于需要严格验证的配置，可以使用自定义类型和解析方法：

package config

type Port int

func (p *Port) UnmarshalText(text []byte) error {
    port, err := strconv.Atoi(string(text))
    if err != nil {
        return fmt.Errorf("invalid port: %w", err)
    }
    if port < 1 || port > 65535 {
        return fmt.Errorf("port out of range: %d", port)
    }
    *p = Port(port)
    return nil
}

type Duration time.Duration

func (d *Duration) UnmarshalText(text []byte) error {
    dur, err := time.ParseDuration(string(text))
    if err != nil {
        return fmt.Errorf("invalid duration: %w", err)
    }
    *d = Duration(dur)
    return nil
}

type StrictConfig struct {
    Port     Port     `mapstructure:"PORT"`
    Timeout  Duration `mapstructure:"TIMEOUT"`
}

func LoadStrictConfig() (StrictConfig, error) {
    viper.SetDefault("PORT", "8080")
    viper.SetDefault("TIMEOUT", "30s")
    
    var config StrictConfig
    if err := viper.Unmarshal(&config); err != nil {
        return StrictConfig{}, fmt.Errorf("failed to unmarshal config: %w", err)
    }
    
    return config, nil
}

这些示例展示了如何在解析阶段进行类型转换和验证，确保配置值的有效性，同时提供有意义的默认值。