Golang 配置管理：环境变量、配置文件和标签初始化

在 Go 项目中，管理配置通常涉及多种方式，包括环境变量、配置文件和结构体标签。下面我将介绍这些方法以及如何使用流行的配置管理库。

1. 环境变量配置

使用标准库 os 可以轻松读取环境变量：

package main

import (
	"fmt"
	"os"
)

func main() {
	// 设置环境变量(通常在系统或容器中设置)
	os.Setenv("APP_PORT", "8080") // 仅为演示，实际不应在代码中设置

	// 获取环境变量
	port := os.Getenv("APP_PORT")
	if port == "" {
		port = "3000" // 默认值
	}
	fmt.Printf("Server will run on port: %s\n", port)
}

2. 配置文件解析

JSON 配置文件

package main

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

type Config struct {
	Database struct {
		Host     string `json:"host"`
		Port     int    `json:"port"`
		Username string `json:"username"`
		Password string `json:"password"`
	} `json:"database"`
	Server struct {
		Port int `json:"port"`
	} `json:"server"`
}

func main() {
	file, err := os.Open("config.json")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	var config Config
	decoder := json.NewDecoder(file)
	err = decoder.Decode(&config)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Database host: %s\n", config.Database.Host)
	fmt.Printf("Server port: %d\n", config.Server.Port)
}

YAML 配置文件

需要先安装 gopkg.in/yaml.v3 包：

package main

import (
	"fmt"
	"os"

	"gopkg.in/yaml.v3"
)

type Config struct {
	Database struct {
		Host     string `yaml:"host"`
		Port     int    `yaml:"port"`
		Username string `yaml:"username"`
		Password string `yaml:"password"`
	} `yaml:"database"`
	Server struct {
		Port int `yaml:"port"`
	} `yaml:"server"`
}

func main() {
	data, err := os.ReadFile("config.yaml")
	if err != nil {
		panic(err)
	}

	var config Config
	err = yaml.Unmarshal(data, &config)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Database host: %s\n", config.Database.Host)
	fmt.Printf("Server port: %d\n", config.Server.Port)
}

3. 使用结构体标签初始化配置

结合环境变量和结构体标签可以创建灵活的配置系统：

package main

import (
	"fmt"
	"os"
	"reflect"
	"strconv"
	"strings"
)

type Config struct {
	Database struct {
		Host     string `env:"DB_HOST" default:"localhost"`
		Port     int    `env:"DB_PORT" default:"5432"`
		Username string `env:"DB_USER" default:"postgres"`
		Password string `env:"DB_PASS" default:""`
	}
	Server struct {
		Port int `env:"APP_PORT" default:"8080"`
	}
}

func LoadConfig(cfg interface{}) error {
	val := reflect.ValueOf(cfg).Elem()
	return parseConfig(val)
}

func parseConfig(val reflect.Value) error {
	typ := val.Type()

	for i := 0; i < val.NumField(); i++ {
		field := val.Field(i)
		fieldType := typ.Field(i)

		// 如果是嵌套结构体，递归处理
		if field.Kind() == reflect.Struct {
			if err := parseConfig(field); err != nil {
				return err
			}
			continue
		}

		// 获取标签
		envTag := fieldType.Tag.Get("env")
		defaultTag := fieldType.Tag.Get("default")

		// 从环境变量获取值
		envValue := os.Getenv(envTag)
		if envValue == "" {
			envValue = defaultTag
		}

		// 根据字段类型设置值
		switch field.Kind() {
		case reflect.String:
			field.SetString(envValue)
		case reflect.Int:
			intValue, err := strconv.Atoi(envValue)
			if err != nil {
				return fmt.Errorf("invalid integer value for %s: %v", envTag, err)
			}
			field.SetInt(int64(intValue))
		case reflect.Bool:
			boolValue, err := strconv.ParseBool(strings.ToLower(envValue))
			if err != nil {
				return fmt.Errorf("invalid boolean value for %s: %v", envTag, err)
			}
			field.SetBool(boolValue)
		}
	}

	return nil
}

func main() {
	var config Config
	if err := LoadConfig(&config); err != nil {
		panic(err)
	}

	fmt.Printf("Database config: %+v\n", config.Database)
	fmt.Printf("Server config: %+v\n", config.Server)
}

4. 使用配置管理库

使用 viper 库

Viper 是一个流行的配置解决方案，支持多种配置源：

package main

import (
	"fmt"
	"log"

	"github.com/spf13/viper"
)

type Config struct {
	Database struct {
		Host     string `mapstructure:"host"`
		Port     int    `mapstructure:"port"`
		Username string `mapstructure:"username"`
		Password string `mapstructure:"password"`
	} `mapstructure:"database"`
	Server struct {
		Port int `mapstructure:"port"`
	} `mapstructure:"server"`
}

func main() {
	viper.SetConfigName("config") // 配置文件名称(不带扩展名)
	viper.SetConfigType("yaml")   // 配置文件类型
	viper.AddConfigPath(".")      // 配置文件路径

	// 读取环境变量
	viper.AutomaticEnv()
	viper.SetEnvPrefix("APP") // 设置环境变量前缀
	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

	// 设置默认值
	viper.SetDefault("database.host", "localhost")
	viper.SetDefault("database.port", 5432)
	viper.SetDefault("server.port", 8080)

	// 读取配置文件
	if err := viper.ReadInConfig(); err != nil {
		if _, ok := err.(viper.ConfigFileNotFoundError); ok {
			log.Println("Config file not found, using defaults and environment variables")
		} else {
			log.Fatalf("Error reading config file: %v", err)
		}
	}

	var config Config
	if err := viper.Unmarshal(&config); err != nil {
		log.Fatalf("Unable to decode into struct: %v", err)
	}

	fmt.Printf("Database config: %+v\n", config.Database)
	fmt.Printf("Server config: %+v\n", config.Server)
}

使用 koanf 库

Koanf 是另一个灵活的配置管理库：

package main

import (
	"fmt"
	"log"

	"github.com/knadh/koanf"
	"github.com/knadh/koanf/parsers/yaml"
	"github.com/knadh/koanf/providers/env"
	"github.com/knadh/koanf/providers/file"
	"github.com/knadh/koanf/providers/structs"
)

type Config struct {
	Database struct {
		Host     string `koanf:"host"`
		Port     int    `koanf:"port"`
		Username string `koanf:"username"`
		Password string `koanf:"password"`
	} `koanf:"database"`
	Server struct {
		Port int `koanf:"port"`
	} `koanf:"server"`
}

func main() {
	var k = koanf.New(".")

	// 加载默认值
	if err := k.Load(structs.Provider(Config{
		Database: struct {
			Host     string
			Port     int
			Username string
			Password string
		}{
			Host:     "localhost",
			Port:     5432,
			Username: "postgres",
		},
		Server: struct {
			Port int
		}{
			Port: 8080,
		},
	}, "koanf"), nil); err != nil {
		log.Fatalf("Error loading defaults: %v", err)
	}

	// 加载配置文件
	if err := k.Load(file.Provider("config.yaml"), yaml.Parser()); err != nil {
		log.Printf("Error loading config file: %v", err)
	}

	// 加载环境变量
	if err := k.Load(env.Provider("APP_", ".", func(s string) string {
		return strings.Replace(strings.ToLower(
			strings.TrimPrefix(s, "APP_")), "_", ".", -1)
	}), nil); err != nil {
		log.Printf("Error loading env vars: %v", err)
	}

	var config Config
	if err := k.Unmarshal("", &config); err != nil {
		log.Fatalf("Error unmarshaling config: %v", err)
	}

	fmt.Printf("Database config: %+v\n", config.Database)
	fmt.Printf("Server config: %+v\n", config.Server)
}

最佳实践建议

1. 配置优先级：通常环境变量 > 配置文件 > 默认值
2. 敏感信息：密码等敏感信息应通过环境变量或密钥管理系统提供
3. 配置验证：加载配置后应进行验证
4. 热重载：生产环境中可能需要配置热重载功能
5. 文档：为所有配置选项提供清晰的文档

以上方法可以根据项目需求组合使用，构建灵活可靠的配置管理系统。