实际项目中，读取相关的系统配置文件是很常见的事情。今天就来说一说，Golang 是如何读取YAML,JSON,INI等配置文件的。

 

JSON 应该比较熟悉，它是一种轻量级的数据交换格式。层次结构简洁清晰 ，易于阅读和编写，同时也易于机器解析和生成。

　　1. 创建 conf.json：

  1. {
  2. "enabled": true,
  3. "path": "/usr/local"
  4. }

 

　　2. 新建config_json.go：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "os"
  7. )
  9. type configuration struct {
  10.     Enabled bool
  11.     Path    string
  12. }
  14. func main() {
  15.     // 打开文件
  16.     file, _ := os.Open("conf.json")
  18.     // 关闭文件
  19.     defer file.Close()
  21.     //NewDecoder创建一个从file读取并解码json对象的*Decoder，解码器有自己的缓冲，并可能超前读取部分json数据。
  22.     decoder := json.NewDecoder(file)
  24.     conf := configuration{}
  25.     //Decode从输入流读取下一个json编码值并保存在v指向的值里
  26.     err := decoder.Decode(&conf)
  27.     if err != nil {
  28.         fmt.Println("Error:", err)
  29.     }
  30.     fmt.Println("path:" + conf.Path)
  31. }

 

　　启动运行后，输出如下：

  1. D:\Go_Path\go\src\configmgr>go run config_json.go
  2. path:/usr/local

 

INI文件格式是某些平台或软件上的配置文件的非正式标准，由节(section)和键(key)构成，比较常用于微软Windows操作系统中。这种配置文件的文件扩展名为INI。

　　1. 创建 conf.ini：

  1. [Section]
  2. enabled = true
  3. path = /usr/local # another comment

　　2.下载第三方库：go get gopkg.in/gcfg.v1

　　3. 新建 config_ini.go：

  1. package main
  3. import (
  4.     "fmt"
  5.     gcfg "gopkg.in/gcfg.v1"
  6. )
  8. func main() {
  9.     config := struct {
  10.         Section struct {
  11.             Enabled bool
  12.             Path    string
  13.         }
  14.     }{}
  16.     err := gcfg.ReadFileInto(&config, "conf.ini")
  18.     if err != nil {
  19.         fmt.Println("Failed to parse config file: %s", err)
  20.     }
  21.     fmt.Println(config.Section.Enabled)
  22.     fmt.Println(config.Section.Path)
  23. }

 

　　启动运行后，输出如下：

  1. D:\Go_Path\go\src\configmgr>go run config_ini.go
  2. true
  3. /usr/local

 

yaml 可能比较陌生一点，但是最近却越来越流行。也就是一种标记语言。层次结构也特别简洁清晰 ，易于阅读和编写，同时也易于机器解析和生成。

golang的标准库中暂时没有给我们提供操作yaml的标准库，但是github上有很多优秀的第三方库开源给我们使用。

　　1. 创建 conf.yaml：

  1. enabled: true
  2. path: /usr/local

　　2. 下载第三方库：go get  gopkg.in/yaml.v2

　　3. 创建 config_yaml.go：

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "log"
  7.  
  8.     "gopkg.in/yaml.v2"
  9. )
  11. type conf struct {
  12.     Enabled bool   `yaml:"enabled"` //yaml：yaml格式 enabled：属性的为enabled
  13.     Path    string `yaml:"path"`
  14. }
  16. func (c *conf) getConf() *conf {
  17.     yamlFile, err := ioutil.ReadFile("conf.yaml")
  18.     if err != nil {
  19.         log.Printf("yamlFile.Get err   #%v ", err)
  20.     }
  22.     err = yaml.Unmarshal(yamlFile, c)
  23.     if err != nil {
  24.         log.Fatalf("Unmarshal: %v", err)
  25.     }
  26.     return c
  27. }
  29. func main() {
  30.     var c conf
  31.     c.getConf()
  32.     fmt.Println("path:" + c.Path)
  33. }

 

　　启动运行后，输出如下：

  1. D:\Go_Path\go\src\configmgr>go run config_yaml.go
  2. path:/usr/local

 

以上，就把golang 读取配置文件的方法，都介绍完了。大家可以拿着代码运行起来看看。

 

版权声明：本文为zhangweizhong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zhangweizhong/p/10505158.html