Golang中Settings包的使用与配置指南

在Go生态中确实有几个流行的配置管理包可以简化应用程序设置的处理。以下是一些常用选项及其示例：

1. viper（最流行）

Viper支持JSON、YAML、TOML等多种格式，功能全面：

package main

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

func main() {
    viper.SetConfigFile("/home/user/settings.json")
    viper.SetDefault("database-connection.server", "192.168.1.1")
    viper.SetDefault("database-connection.username", "me")
    viper.SetDefault("database-connection.password", "mypassword")
    viper.SetDefault("preferences.dark-theme", true)

    // 保存配置
    viper.WriteConfig()

    // 加载配置
    viper.ReadInConfig()
    
    // 读取配置
    darkTheme := viper.GetBool("preferences.dark-theme")
    server := viper.GetString("database-connection.server")
    
    fmt.Printf("Dark theme: %v\n", darkTheme)
    fmt.Printf("Server: %s\n", server)
}

2. koanf（轻量级替代）

Koanf提供类似的API但更轻量：

package main

import (
    "fmt"
    "github.com/knadh/koanf"
    "github.com/knadh/koanf/parsers/json"
    "github.com/knadh/koanf/providers/file"
)

func main() {
    var k = koanf.New(".")
    
    // 加载配置
    if err := k.Load(file.Provider("/home/user/settings.json"), json.Parser()); err != nil {
        // 处理错误或创建默认配置
        k.Set("database-connection.server", "192.168.1.1")
        k.Set("database-connection.username", "me")
        k.Set("database-connection.password", "mypassword")
        k.Set("preferences.dark-theme", true)
        
        // 保存到文件
        b, _ := k.Marshal(json.Parser())
        // 写入文件逻辑...
    }
    
    // 读取配置
    darkTheme := k.Bool("preferences.dark-theme")
    server := k.String("database-connection.server")
    
    fmt.Printf("Dark theme: %v\n", darkTheme)
    fmt.Printf("Server: %s\n", server)
}

3. 使用标准库的简单封装

如果需求简单，可以自己封装：

package config

import (
    "encoding/json"
    "os"
    "sync"
)

type Settings struct {
    mu     sync.RWMutex
    data   map[string]interface{}
    path   string
}

func NewJSONSettings(path string) *Settings {
    return &Settings{
        data: make(map[string]interface{}),
        path: path,
    }
}

func (s *Settings) AddSettingsCategory(category string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    if _, exists := s.data[category]; !exists {
        s.data[category] = make(map[string]interface{})
    }
}

func (s *Settings) AddSetting(category, key string, value interface{}) {
    s.mu.Lock()
    defer s.mu.Unlock()
    
    if _, exists := s.data[category]; !exists {
        s.data[category] = make(map[string]interface{})
    }
    
    categoryMap := s.data[category].(map[string]interface{})
    categoryMap[key] = value
}

func (s *Settings) Save() error {
    s.mu.RLock()
    defer s.mu.RUnlock()
    
    data, err := json.MarshalIndent(s.data, "", "  ")
    if err != nil {
        return err
    }
    
    return os.WriteFile(s.path, data, 0644)
}

func (s *Settings) Load() error {
    s.mu.Lock()
    defer s.mu.Unlock()
    
    data, err := os.ReadFile(s.path)
    if err != nil {
        return err
    }
    
    return json.Unmarshal(data, &s.data)
}

func (s *Settings) Get(category, key string) interface{} {
    s.mu.RLock()
    defer s.mu.RUnlock()
    
    if categoryMap, ok := s.data[category].(map[string]interface{}); ok {
        return categoryMap[key]
    }
    return nil
}

使用示例：

package main

import (
    "fmt"
    "yourmodule/config"
)

func main() {
    setting := config.NewJSONSettings("/home/user/setting.json")
    setting.AddSettingsCategory("database-connection")
    setting.AddSetting("database-connection", "server", "192.168.1.1")
    setting.AddSetting("database-connection", "username", "me")
    setting.AddSetting("database-connection", "password", "mypassword")
    setting.AddSettingsCategory("preferences")
    setting.AddSetting("preferences", "dark-theme", true)
    
    err := setting.Save()
    if err != nil {
        fmt.Println("保存失败:", err)
    }
    
    // 加载
    err = setting.Load()
    if err != nil {
        fmt.Println("加载失败:", err)
    }
    
    darkTheme := setting.Get("preferences", "dark-theme")
    fmt.Printf("Dark theme: %v\n", darkTheme)
}

Viper是目前最全面的解决方案，支持环境变量、命令行参数、配置热重载等高级功能。对于小型应用，标准库封装或Koanf也是不错的选择。