1

go get github.com/spf13/viper

1
2
3

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

1
2
3
4
5
6
7
8
9

viper.SetConfigName("config") //配置文件的名称（无扩展名）
viper.SetConfigType("yaml") // 如果配置文件名称中不包含扩展名，则必需(REQUIRED)
viper.AddConfigPath("/etc/appname/") //配置文件的搜索路径
viper.AddConfigPath("$HOME/.appname") //可多次调用以添加多个搜索路径
viper.AddConfigPath(".") // 可选地在工作目录中查找配置文件
err := viper.ReadInConfig() // 查找并读取配置文件
if err != nil { // 处理读取配置文件时的错误
	panic(fmt.Errorf("fatal error config file: %w", err))
}

1
2
3
4
5
6
7
8
9

if err := viper.ReadInConfig(); err != nil {
	if _, ok := err.(viper.ConfigFileNotFoundError); ok {
		// 未找到配置文件；如果需要，可以忽略错误
	} else {
		// 找到配置文件，但产生了其他错误
	}
}

// 找到配置文件并且已成功解析

1
2
3
4
5
6

viper.WriteConfig() // 将当前配置写入由 'viper.AddConfigPath()' 和 'viper.SetConfigName' 设置的预定义路径
viper.SafeWriteConfig()
viper.SafeWriteConfig()
viper.WriteConfigAs("/path/to/my/.config")
viper.SafeWriteConfigAs("/path/to/my/.config") // 会报错，因为已经写入过
viper.SafeWriteConfigAs("/path/to/my/.other_config")

1
2
3
4
5

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

viper.WatchConfig()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

viper.SetConfigType("yaml") // 或 viper.SetConfigType("YAML")

// 通过任何方式将此配置内容引入你的程序中。
var yamlExample = []byte(`
Hacker: true
name: steve
hobbies:
- skateboarding
- snowboarding
- go
clothing:
  jacket: leather
  trousers: denim
age: 35
eyes : brown
beard: true
`)

viper.ReadConfig(bytes.NewBuffer(yamlExample))

viper.Get("name") // 这将返回 "steve"

1
2

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

1
2
3
4
5
6
7

viper.RegisterAlias("loud", "Verbose")

viper.Set("verbose", true) // 与下一行代码的结果相同
viper.Set("loud", true)   // 与上一行代码的结果相同

viper.GetBool("loud") // 返回 true
viper.GetBool("verbose") // 返回 true

1
2
3
4
5
6

SetEnvPrefix("spf") // 将自动转为大写
BindEnv("id")

os.Setenv("SPF_ID", "13") // 通常在应用程序外部进行

id := Get("id") // 13

1
2

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

1
2
3
4
5
6

pflag.Int("flagname", 1234, "help message for flagname")

pflag.Parse()
viper.BindPFlags(pflag.CommandLine)

i := viper.GetInt("flagname") // 从viper中检索值，而不是从pflag中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import (
	"flag"
	"github.com/spf13/pflag"
)

func main() {

	// 使用标准库中的 "flag" 包
	flag.Int("flagname", 1234, "help message for flagname")

	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
	pflag.Parse()
	viper.BindPFlags(pflag.CommandLine)

	i := viper.GetInt("flagname") // 从viper中检索值

	// ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

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" 
}

1

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

1
2
3
4
5
6
7
8
9

type myFlagSet struct {
	flags []myFlag
}

func (f myFlagSet) VisitAll(fn func(FlagValue)) {
	for _, flag := range flags {
		fn(flag)
	}
}

1
2
3
4
5

fSet := myFlagSet{
	flags: []myFlag{myFlag{}, myFlag{}},
}

viper.BindFlagValues("my-flags", fSet)

1
2

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

1

$ crypt get -plaintext /config/hugo.json

1
2
3

viper.AddRemoteProvider("etcd", "http://127.0.0.1:4001","/config/hugo.json")
viper.SetConfigType("json") // 因为在字节流中没有文件扩展名，支持的扩展名有 "json"、"toml"、"yaml"、"yml"、"properties"、"props"、"prop"、"env"、"dotenv"
err := viper.ReadRemoteConfig()

1
2
3

viper.AddRemoteProvider("etcd3", "http://127.0.0.1:4001","/config/hugo.json")
viper.SetConfigType("json") // 因为在字节流中没有文件扩展名，支持的扩展名有 "json"、"toml"、"yaml"、"yml"、"properties"、"props"、"prop"、"env"、"dotenv"
err := viper.ReadRemoteConfig()

1
2
3
4

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

1
2
3
4
5
6
7

viper.AddRemoteProvider("consul", "localhost:8500", "MY_CONSUL_KEY")

viper.SetConfigType("json") // 需要显式设置为json
err := viper.ReadRemoteConfig()

fmt.Println(viper.Get("port")) // 8080
fmt.Println(viper.Get("hostname")) // myhostname.com

1
2
3
4
5

viper.AddRemoteProvider("firestore", "google-cloud-project-id", "collection/document")

viper.SetConfigType("json") // 配置的格式: "json"、"toml"、"yaml"、"yml"

err := viper.ReadRemoteConfig()

1
2
3
4
5

viper.AddSecureRemoteProvider("etcd","http://127.0.0.1:4001","/config/hugo.json","/etc/secrets/mykeyring.gpg")

viper.SetConfigType("json") // 因为在字节流中没有文件扩展名，支持的扩展名有 "json"、"toml"、"yaml"、"yml"、"properties"、"props"、"prop"、"env"、"dotenv"

err := viper.ReadRemoteConfig()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 或者，您可以创建一个新的viper实例。
var runtime_viper = viper.New()

runtime_viper.AddRemoteProvider("etcd", "http://127.0.0.1:4001", "/config/hugo.yml")
runtime_viper.SetConfigType("yaml") // 因为在字节流中没有文件扩展名，支持的扩展名有 "json"、"toml"、"yaml"、"yml"、"properties"、"props"、"prop"、"env"、"dotenv"

// 第一次从远程配置中读取。
err := runtime_viper.ReadRemoteConfig()

// 反序列化配置
runtime_viper.Unmarshal(&runtime_conf)

// 打开一个goroutine无限期地监听远程更改
go func(){
	for {
		time.Sleep(time.Second * 5) // 每个请求之后的延迟

		// 目前仅已测试etcd支持
		err := runtime_viper.WatchRemoteConfig()
		if err != nil {
			log.Errorf("unable to read remote config: %v", err)
			continue
		}

         // 反序列化新配置到我们的运行时配置结构。您还可以使用通道实现一个信号，以通知系统发生了更改
		runtime_viper.Unmarshal(&runtime_conf)
	}
}()

1
2
3
4

viper.GetString("logfile") // 不区分大小写的设置和获取
if viper.GetBool("verbose") {
	fmt.Println("verbose enabled")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

1

GetString("datastore.metric.host") // 返回 "127.0.0.1"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

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

1

GetInt("host.ports.1") // 返回 6029

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

{
    "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
        }
    }
}

1

GetString("datastore.metric.host") // 返回 "0.0.0.0"

1
2
3
4
5
6
7

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

1
2
3
4
5
6

cache1Config := viper.Sub("cache.cache1")
if cache1Config == nil { // 如果找不到键，则 Sub 方法将返回 nil。
	panic("cache configuration not found")
}

cache1 := NewCache(cache1Config)

1
2
3
4
5
6

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/*
示例配置：

module:
    enabled: true
    token: 89h3f98hbwf987h3f98wenf89ehf
*/
type config struct {
	Module struct {
		Enabled bool

		moduleConfig `mapstructure:",squash"`
	}
}

// moduleConfig 可以在特定于模块的包中
type moduleConfig struct {
	Token string
}

var C config

err := viper.Unmarshal(&C)
if err != nil {
	t.Fatalf("unable to decode into struct, %v", err)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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)
}

1
2
3
4
5
6
7

x := viper.New()
y := viper.New()

x.SetDefault("ContentDir", "content")
y.SetDefault("ContentDir", "foobar")

//...

1

var RemoteConfig remoteConfigFactory

1

var SupportedExts = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop", "hcl", "tfvars", "dotenv", "env", "ini"}

1

var SupportedRemoteProviders = []string{"etcd", "etcd3", "consul", "firestore"}

1

func AddConfigPath(in string)

1

func AddRemoteProvider(provider, endpoint, path string) error

1

func AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error

1

func AllKeys() []string

1

func AllSettings() map[string]interface{}

1

func AllowEmptyEnv(allowEmptyEnv bool)

1

func AutomaticEnv()

1

func BindEnv(input ...string) error

1

func BindFlagValue(key string, flag FlagValue) error

1

func BindFlagValues(flags FlagValueSet) error

1

func BindPFlag(key string, flag *pflag.Flag) error

1
2

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

1

func BindPFlags(flags *pflag.FlagSet) error

1

func ConfigFileUsed() string

1

func Debug()

1

func DebugTo(w io.Writer)

1

func Get(key string) interface{}

1

func GetBool(key string) bool

1

func GetDuration(key string) time.Duration

1

func GetFloat64(key string) float64

1

func GetInt(key string) int

1

func GetInt32(key string) int32

1

func GetInt64(key string) int64

1

func GetIntSlice(key string) []int

1

func GetSizeInBytes(key string) uint

1

func GetString(key string) string

1

func GetStringMap(key string) map[string]interface{}

1

func GetStringMapString(key string) map[string]string

1

func GetStringMapStringSlice(key string) map[string][]string

1

func GetStringSlice(key string) []string

1

func GetTime(key string) time.Time

1

func GetUint(key string) uint

1

func GetUint16(key string) uint16

1

func GetUint32(key string) uint32

1

func GetUint64(key string) uint64

1

func InConfig(key string) bool

1

func IsSet(key string) bool

1

func MergeConfig(in io.Reader) error

1

func MergeConfigMap(cfg map[string]interface{}) error

1

func MergeInConfig() error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func MustBindEnv(input ...string) { 
    v.MustBindEnv(input...) 
}

var v *Viper

func init() {
	v = New()
}

func (v *Viper) MustBindEnv(input ...string) {
	if err := v.BindEnv(input...); err != nil {
		panic(fmt.Sprintf("error while binding environment variable: %v", err))
	}
}

1

func OnConfigChange(run func(in fsnotify.Event))

1

func ReadConfig(in io.Reader) error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func ReadInConfig() error { 
    return v.ReadInConfig() 
}

func (v *Viper) ReadInConfig() error {
	v.logger.Info("attempting to read in config file")
	filename, err := v.getConfigFile()
	if err != nil {
		return err
	}

	if !stringInSlice(v.getConfigType(), SupportedExts) {
		return UnsupportedConfigError(v.getConfigType())
	}

	v.logger.Debug("reading file", "file", filename)
	file, err := afero.ReadFile(v.fs, filename)
	if err != nil {
		return err
	}

	config := make(map[string]interface{})

	err = v.unmarshalReader(bytes.NewReader(file), config)
	if err != nil {
		return err
	}

	v.config = config
	return nil
}

1

func ReadRemoteConfig() error

1

func RegisterAlias(alias string, key string)

1

func Reset()

1

func SafeWriteConfig() error

1

func SafeWriteConfigAs(filename string) error

1

func Set(key string, value interface{})

1
2
3
4
5
6
7
8
9

func SetConfigFile(in string) { 
    v.SetConfigFile(in) 
}

func (v *Viper) SetConfigFile(in string) {
	if in != "" {
		v.configFile = in
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func SetConfigName(in string) { 
    v.SetConfigName(in) 
}

func (v *Viper) SetConfigName(in string) {
	if in != "" {
		v.configName = in
		v.configFile = ""
	}
}

1
2
3
4
5
6
7

func SetConfigPermissions(perm os.FileMode) {
    v.SetConfigPermissions(perm) 
}

func (v *Viper) SetConfigPermissions(perm os.FileMode) {
	v.configPermissions = perm.Perm()
}

1
2
3
4
5
6
7
8
9

func SetConfigType(in string) { 
    v.SetConfigType(in) 
}

func (v *Viper) SetConfigType(in string) {
	if in != "" {
		v.configType = in
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func SetDefault(key string, value interface{}) { 
    v.SetDefault(key, value) 
}

func (v *Viper) SetDefault(key string, value interface{}) {
    // 如果传入了别名，则设置适当的默认值。
	key = v.realKey(strings.ToLower(key))
	value = toCaseInsensitiveValue(value)

	path := strings.Split(key, v.keyDelim)
	lastKey := strings.ToLower(path[len(path)-1])
	deepestMap := deepSearch(v.defaults, path[0:len(path)-1])

    // 设置最内层的值
	deepestMap[lastKey] = value
}

1
2
3
4
5
6
7

func SetEnvKeyReplacer(r *strings.Replacer) {
    v.SetEnvKeyReplacer(r) 
}

func (v *Viper) SetEnvKeyReplacer(r *strings.Replacer) {
	v.envKeyReplacer = r
}

1
2
3
4
5
6
7
8
9

func SetEnvPrefix(in string) { 
    v.SetEnvPrefix(in) 
}

func (v *Viper) SetEnvPrefix(in string) {
	if in != "" {
		v.envPrefix = in
	}
}

1
2
3
4
5
6
7

func SetFs(fs afero.Fs) { 
    v.SetFs(fs) 
}

func (v *Viper) SetFs(fs afero.Fs) {
	v.fs = fs
}

1
2
3
4
5
6
7

func SetTypeByDefaultValue(enable bool) { 
    v.SetTypeByDefaultValue(enable) 
}

func (v *Viper) SetTypeByDefaultValue(enable bool) {
	v.typeByDefValue = enable
}

1

[]string {"a", "b", "c"}

1

"a b c"

1
2
3
4
5
6
7

func Unmarshal(rawVal interface{}, opts ...DecoderConfigOption) error {
	return v.Unmarshal(rawVal, opts...)
}

func (v *Viper) Unmarshal(rawVal interface{}, opts ...DecoderConfigOption) error {
	return decode(v.AllSettings(), defaultDecoderConfig(rawVal, opts...))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func UnmarshalExact(rawVal interface{}, opts ...DecoderConfigOption) error {
	return v.UnmarshalExact(rawVal, opts...)
}

func (v *Viper) UnmarshalExact(rawVal interface{}, opts ...DecoderConfigOption) error {
	config := defaultDecoderConfig(rawVal, opts...)
	config.ErrorUnused = true

	return decode(v.AllSettings(), config)
}

1
2
3
4
5
6
7

func UnmarshalKey(key string, rawVal interface{}, opts ...DecoderConfigOption) error {
	return v.UnmarshalKey(key, rawVal, opts...)
}

func (v *Viper) UnmarshalKey(key string, rawVal interface{}, opts ...DecoderConfigOption) error {
	return decode(v.Get(key), defaultDecoderConfig(rawVal, opts...))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

func WatchConfig() {
    v.WatchConfig() 
}

// WatchConfig starts watching a config file for changes.
// WatchConfig 开始监视配置文件的变化。
func (v *Viper) WatchConfig() {
	initWG := sync.WaitGroup{}
	initWG.Add(1)
	go func() {
		watcher, err := newWatcher()
		if err != nil {
			v.logger.Error(fmt.Sprintf("failed to create watcher: %s", err))
			os.Exit(1)
		}
		defer watcher.Close()
        
        // 我们必须监视整个目录，以便跨平台捕捉重命名/原子保存
		filename, err := v.getConfigFile()
		if err != nil {
			v.logger.Error(fmt.Sprintf("get config file: %s", err))
			initWG.Done()
			return
		}

		configFile := filepath.Clean(filename)
		configDir, _ := filepath.Split(configFile)
		realConfigFile, _ := filepath.EvalSymlinks(filename)

		eventsWG := sync.WaitGroup{}
		eventsWG.Add(1)
		go func() {
			for {
				select {
				case event, ok := <-watcher.Events:
					if !ok { // 'Events' 通道已关闭
						eventsWG.Done()
						return
					}
					currentConfigFile, _ := filepath.EvalSymlinks(filename)

                    // 我们只关心以下情况的配置文件：
					// 1 - 配置文件被修改或创建
					// 2 - 配置文件的真实路径发生变化（例如：k8s ConfigMap 替换）
					if (filepath.Clean(event.Name) == configFile &&
						(event.Has(fsnotify.Write) || event.Has(fsnotify.Create))) ||
						(currentConfigFile != "" && currentConfigFile != realConfigFile) {
						realConfigFile = currentConfigFile
						err := v.ReadInConfig()
						if err != nil {
							v.logger.Error(fmt.Sprintf("read config file: %s", err))
						}
						if v.onConfigChange != nil {
							v.onConfigChange(event)
						}
					} else if filepath.Clean(event.Name) == configFile && event.Has(fsnotify.Remove) {
						eventsWG.Done()
						return
					}

				case err, ok := <-watcher.Errors:
					if ok { // 'Errors' 通道未关闭
						v.logger.Error(fmt.Sprintf("watcher error: %s", err))
					}
					eventsWG.Done()
					return
				}
			}
		}()
		watcher.Add(configDir)
		initWG.Done()   // 此 go 协程中的监视初始化完成，所以父协程可以继续执行...
		eventsWG.Wait() // 现在，等待此 go 协程中的事件循环结束...
	}()
	initWG.Wait() // 确保上述 go 协程完全结束后再返回
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

func WatchRemoteConfig() error {
    return v.WatchRemoteConfig() 
}
func (v *Viper) WatchRemoteConfig() error {
	return v.watchKeyValueConfig()
}

// 检索第一个找到的远程配置。
func (v *Viper) watchKeyValueConfig() error {
	if len(v.remoteProviders) == 0 {
		return RemoteConfigError("No Remote Providers")
	}

	for _, rp := range v.remoteProviders {
		val, err := v.watchRemoteConfig(rp)
		if err != nil {
			v.logger.Error(fmt.Errorf("watch remote config: %w", err).Error())

			continue
		}
		v.kvstore = val
		return nil
	}
	return RemoteConfigError("No Files Found")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func WriteConfig() error { 
    return v.WriteConfig() 
}

func (v *Viper) WriteConfig() error {
	filename, err := v.getConfigFile()
	if err != nil {
		return err
	}
	return v.writeConfig(filename, true)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

func WriteConfigAs(filename string) error { 
    return v.WriteConfigAs(filename) 
}

func (v *Viper) WriteConfigAs(filename string) error {
	return v.writeConfig(filename, true)
}

func (v *Viper) writeConfig(filename string, force bool) error {
	v.logger.Info("attempting to write configuration to file")

	var configType string

	ext := filepath.Ext(filename)
	if ext != "" && ext != filepath.Base(filename) {
		configType = ext[1:]
	} else {
		configType = v.configType
	}
	if configType == "" {
		return fmt.Errorf("config type could not be determined for %s", filename)
	}

	if !stringInSlice(configType, SupportedExts) {
		return UnsupportedConfigError(configType)
	}
	if v.config == nil {
		v.config = make(map[string]interface{})
	}
	flags := os.O_CREATE | os.O_TRUNC | os.O_WRONLY
	if !force {
		flags |= os.O_EXCL
	}
	f, err := v.fs.OpenFile(filename, flags, v.configPermissions)
	if err != nil {
		return err
	}
	defer f.Close()

	if err := v.marshalWriter(f, configType); err != nil {
		return err
	}

	return f.Sync()
}

1

type ConfigFileAlreadyExistsError string

1
2
3

func (faee ConfigFileAlreadyExistsError) Error() string {
	return fmt.Sprintf("Config File %q Already Exists", string(faee))
}

1
2
3

type ConfigFileNotFoundError struct {
	name, locations string
}

1
2
3

func (fnfe ConfigFileNotFoundError) Error() string {
	return fmt.Sprintf("Config File %q Not Found in %q", fnfe.name, fnfe.locations)
}

1
2
3

type ConfigMarshalError struct {
	err error
}

1
2
3

func (e ConfigMarshalError) Error() string {
	return fmt.Sprintf("While marshaling config: %s", e.err.Error())
}

1
2
3

type ConfigParseError struct {
	err error
}

1
2
3

func (pe ConfigParseError) Error() string {
	return fmt.Sprintf("While parsing config: %s", pe.err.Error())
}

1
2
3

func (pe ConfigParseError) Unwrap() error {
	return pe.err
}

1

type DecoderConfigOption func(*mapstructure.DecoderConfig)

1

func DecodeHook(hook mapstructure.DecodeHookFunc) DecoderConfigOption

1
2
3
4

 mapstructure.ComposeDecodeHookFunc(
		mapstructure.StringToTimeDurationHookFunc(),
		mapstructure.StringToSliceHookFunc(","),
	)

1
2
3
4
5
6

type FlagValue interface {
	HasChanged() bool
	Name() string
	ValueString() string
	ValueType() string
}

1
2
3

type FlagValueSet interface {
	VisitAll(fn func(FlagValue))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

type Logger interface {
    // Trace方法记录Trace事件。
	//
	// 比Debug事件提供更细粒度的信息。
	// 不支持此级别的日志记录器应该回退到Debug。
	Trace(msg string, keyvals ...interface{})
	
    // Debug方法记录Debug事件。
	//
	// 一系列详细信息事件。
	// 在调试系统时很有用。
	Debug(msg string, keyvals ...interface{})
	
    // Info方法记录Info事件。
	//
	// 关于系统内部发生的一般信息。
	Info(msg string, keyvals ...interface{})

    // Warn方法记录Warn(ing)事件。
	//
    // 应该查看的非致命（non-critical）事件。
	Warn(msg string, keyvals ...interface{})

    // Error方法记录Error事件。
	//
    // 需要立即注意的致命事件（critical events）。
	// 日志记录器通常在Error级别以上提供Fatal和Panic级别，
	// 但退出和恐慌超出了日志记录库的范围。
	Error(msg string, keyvals ...interface{})
}

1
2
3

type Option interface {
	apply(v *Viper)
}

1
2
3
4
5
6
7

func EnvKeyReplacer(r StringReplacer) Option {
	return optionFunc(func(v *Viper) {
		v.envKeyReplacer = r
	})
}

type optionFunc func(v *Viper)