Golang 语言怎么使用 Viper 管理配置信息？

go get github.com/spf13/viper

viper.SetDefault("ContentDir", "content")viper.SetDefault("LayoutDir", "layouts")viper.SetDefault("Taxonomies", map[string]string{"tag": "tags", "category": "categories"})

viper.SetConfigName("config") // name of config file (without extension)viper.SetConfigType("yaml") // REQUIRED if the config file does not have the extension in the nameviper.AddConfigPath("/etc/appname/")   // path to look for the config file inviper.AddConfigPath("$HOME/.appname")  // call multiple times to add many search pathsviper.AddConfigPath(".")               // optionally look for config in the working directoryerr := viper.ReadInConfig() // Find and read the config fileif err != nil { // Handle errors reading the config file  panic(fmt.Errorf("Fatal error config file: %s \n", err))}

if err := viper.ReadInConfig(); err != nil {    if _, ok := err.(viper.ConfigFileNotFoundError); ok {        // Config file not found; ignore error if desired    } else {        // Config file was found but another error was produced    }}
// Config file found and successfully parsed

viper.WriteConfig() // writes current config to predefined path set by 'viper.AddConfigPath()' and 'viper.SetConfigName'viper.SafeWriteConfig()viper.WriteConfigAs("/path/to/my/.config")viper.SafeWriteConfigAs("/path/to/my/.config") // will error since it has already been writtenviper.SafeWriteConfigAs("/path/to/my/.other_config")

viper.WatchConfig()viper.OnConfigChange(func(e fsnotify.Event) {  fmt.Println("Config file changed:", e.Name)})

viper.SetConfigType("yaml") // or viper.SetConfigType("YAML")
// any approach to require this configuration into your program.var yamlExample = []byte(`Hacker: truename: stevehobbies:- skateboarding- snowboarding- goclothing:  jacket: leather  trousers: denimage: 35eyes : brownbeard: true`)
viper.ReadConfig(bytes.NewBuffer(yamlExample))
viper.Get("name") // this would be "steve"

viper.Set("Verbose", true)viper.Set("LogFile", LogFile)

viper.RegisterAlias("loud", "Verbose")
viper.Set("verbose", true) // same result as next lineviper.Set("loud", true)   // same result as prior line
viper.GetBool("loud") // trueviper.GetBool("verbose") // true

SetEnvPrefix("spf") // will be uppercased automaticallyBindEnv("id")
os.Setenv("SPF_ID", "13") // typically done outside of the app
id := Get("id") // 13

serverCmd.Flags().Int("port", 1138, "Port to run Application server on")viper.BindPFlag("port", serverCmd.Flags().Lookup("port"))

pflag.Int("flagname", 1234, "help message for flagname")
pflag.Parse()viper.BindPFlags(pflag.CommandLine)
i := viper.GetInt("flagname") // retrieve values from viper instead of pflag

package main
import (  "flag"  "github.com/spf13/pflag")
func main() {
  // using standard library "flag" package  flag.Int("flagname", 1234, "help message for flagname")
  pflag.CommandLine.AddGoFlagSet(flag.CommandLine)  pflag.Parse()  viper.BindPFlags(pflag.CommandLine)
  i := viper.GetInt("flagname") // retrieve value from viper
  ...}

type myFlag struct {}func (f myFlag) HasChanged() bool { return false }func (f myFlag) Name() string { return "my-flag-name" }func (f myFlag) ValueString() string { return "my-flag-value" }func (f myFlag) ValueType() string { return "string" }

viper.BindFlagValue("my-flag-name", myFlag{})

type myFlagSet struct {  flags []myFlag}
func (f myFlagSet) VisitAll(fn func(FlagValue)) {  for _, flag := range flags {    fn(flag)  }}

fSet := myFlagSet{  flags: []myFlag{myFlag{}, myFlag{}},}viper.BindFlagValues("my-flags", fSet)

import _ "github.com/spf13/viper/remote"

$ go get github.com/bketelsen/crypt/bin/crypt$ crypt set -plaintext /config/hugo.json /Users/hugo/settings/config.json

$ crypt get -plaintext /config/hugo.json

viper.AddRemoteProvider("etcd", "http://127.0.0.1:4001","/config/hugo.json")viper.SetConfigType("json") // because there is no file extension in a stream of bytes, supported extensions are "json", "toml", "yaml", "yml", "properties", "props", "prop", "env", "dotenv"err := viper.ReadRemoteConfig()

{    "port": 8080,    "hostname": "myhostname.com"}

viper.AddRemoteProvider("consul", "localhost:8500", "MY_CONSUL_KEY")viper.SetConfigType("json") // Need to explicitly set this to jsonerr := viper.ReadRemoteConfig()
fmt.Println(viper.Get("port")) // 8080fmt.Println(viper.Get("hostname")) // myhostname.com

viper.AddRemoteProvider("firestore", "google-cloud-project-id", "collection/document")viper.SetConfigType("json") // Config's format: "json", "toml", "yaml", "yml"err := viper.ReadRemoteConfig()

viper.AddSecureRemoteProvider("etcd","http://127.0.0.1:4001","/config/hugo.json","/etc/secrets/mykeyring.gpg")viper.SetConfigType("json") // because there is no file extension in a stream of bytes,  supported extensions are "json", "toml", "yaml", "yml", "properties", "props", "prop", "env", "dotenv"err := viper.ReadRemoteConfig()

// alternatively, you can create a new viper instance.var runtime_viper = viper.New()
runtime_viper.AddRemoteProvider("etcd", "http://127.0.0.1:4001", "/config/hugo.yml")runtime_viper.SetConfigType("yaml") // because there is no file extension in a stream of bytes, supported extensions are "json", "toml", "yaml", "yml", "properties", "props", "prop", "env", "dotenv"
// read from remote config the first time.err := runtime_viper.ReadRemoteConfig()
// unmarshal configruntime_viper.Unmarshal(&runtime_conf)
// open a goroutine to watch remote changes forevergo func(){  for {      time.Sleep(time.Second * 5) // delay after each request
      // currently, only tested with etcd support      err := runtime_viper.WatchRemoteConfig()      if err != nil {          log.Errorf("unable to read remote config: %v", err)          continue      }
      // unmarshal new config into our runtime config struct. you can also use channel      // to implement a signal to notify the system of the changes      runtime_viper.Unmarshal(&runtime_conf)  }}()

viper.GetString("logfile") // case-insensitive Setting & Gettingif viper.GetBool("verbose") {    fmt.Println("verbose enabled")}

{    "host": {        "address": "localhost",        "port": 5799    },    "datastore": {        "metric": {            "host": "127.0.0.1",            "port": 3099        },        "warehouse": {            "host": "198.0.0.1",            "port": 2112        }    }}

GetString("datastore.metric.host") // (returns "127.0.0.1")

{    "host": {        "address": "localhost",        "ports": [            5799,            6029        ]    },    "datastore": {        "metric": {            "host": "127.0.0.1",            "port": 3099        },        "warehouse": {            "host": "198.0.0.1",            "port": 2112        }    }}
GetInt("host.ports.1") // returns 6029

{    "datastore.metric.host": "0.0.0.0",    "host": {        "address": "localhost",        "port": 5799    },    "datastore": {        "metric": {            "host": "127.0.0.1",            "port": 3099        },        "warehouse": {            "host": "198.0.0.1",            "port": 2112        }    }}
GetString("datastore.metric.host") // returns "0.0.0.0"

cache:  cache1:    max-items: 100    item-size: 64  cache2:    max-items: 200    item-size: 80

cache1Config := viper.Sub("cache.cache1")if cache1Config == nil { // Sub returns nil if the key cannot be found    panic("cache configuration not found")}
cache1 := NewCache(cache1Config)

func NewCache(v *Viper) *Cache {    return &Cache{        MaxItems: v.GetInt("max-items"),        ItemSize: v.GetInt("item-size"),    }}

type config struct {  Port int  Name string  PathMap string `mapstructure:"path_map"`}
var C config
err := viper.Unmarshal(&C)if err != nil {  t.Fatalf("unable to decode into struct, %v", err)}

v := viper.NewWithOptions(viper.KeyDelimiter("::"))
v.SetDefault("chart::values", map[string]interface{}{    "ingress": map[string]interface{}{        "annotations": map[string]interface{}{            "traefik.frontend.rule.type":                 "PathPrefix",            "traefik.ingress.kubernetes.io/ssl-redirect": "true",        },    },})
type config struct {  Chart struct{        Values map[string]interface{}    }}
var C config
v.Unmarshal(&C)

/*Example config:
module:    enabled: true    token: 89h3f98hbwf987h3f98wenf89ehf*/type config struct {  Module struct {    Enabled bool
    moduleConfig `mapstructure:",squash"`  }}
// moduleConfig could be in a module specific packagetype moduleConfig struct {  Token string}
var C config
err := viper.Unmarshal(&C)if err != nil {  t.Fatalf("unable to decode into struct, %v", err)}

import (    yaml "gopkg.in/yaml.v2"    // ...)
func yamlStringSettings() string {    c := viper.AllSettings()    bs, err := yaml.Marshal(c)    if err != nil {        log.Fatalf("unable to marshal config to YAML: %v", err)    }    return string(bs)}

x := viper.New()y := viper.New()
x.SetDefault("ContentDir", "content")y.SetDefault("ContentDir", "foobar")
//...

.├── configs│   └── config.yaml├── go.mod├── go.sum└── main.go

Server:  RunMode: debug  HttpPort: 8080  ReadTimeout: 60  WriteTimeout: 60

type ServerSetting struct {  RunMode      string  HttpPort     string  ReadTimeout  time.Duration  WriteTimeout time.Duration}
var server ServerSetting
func main() {  // 实例化 viper 实例  vp := viper.New()  // 设置配置文件名称  vp.SetConfigName("config")  // 设置配置文件类型  vp.SetConfigType("yaml")  // 添加配置文件路径  vp.AddConfigPath("configs/")  // 读取配置文件内容  err := vp.ReadInConfig()  if err != nil {    panic(fmt.Errorf("Fatal error config file: %s\n", err))  }  //  解码 key 到 struct  err = vp.UnmarshalKey("Server", &server)  if err != nil {    panic(fmt.Errorf("unable to decode into struct, %v", err))  }  // 打印  fmt.Printf("Server: %+v\n", server)}