## 操作TOML，YAML和JSON配置文件
使用配置文件的好處有很多，例如跨語言共享配置、部署修改方便等。Go對JSON實現了開箱即用的支持。本章主要關注以配置結構體tag標簽的形式映射至Go結構。
### 實踐
1. 我們需要安裝以下第三方庫：
```
go get github.com/BurntSushi/toml
go get github.com/go-yaml/yaml
```
2. 建立toml.go：
```
package confformat
import (
"bytes"
"github.com/BurntSushi/toml"
)
// TOMLData是我們使用TOML結構標記的通用數據結構
type TOMLData struct {
Name string `toml:"name"`
Age int `toml:"age"`
}
// ToTOML 將TOMLData結構轉儲為TOML格式bytes.Buffer
func (t *TOMLData) ToTOML() (*bytes.Buffer, error) {
b := &bytes.Buffer{}
encoder := toml.NewEncoder(b)
if err := encoder.Encode(t); err != nil {
return nil, err
}
return b, nil
}
// Decode 將數據解碼為TOMLData
func (t *TOMLData) Decode(data []byte) (toml.MetaData, error) {
return toml.Decode(string(data), t)
}
```
3. 建立yaml.go：
```
package confformat
import (
"bytes"
"github.com/go-yaml/yaml"
)
// YAMLData 是我們使用YAML結構標記的通用數據結構
type YAMLData struct {
Name string `yaml:"name"`
Age int `yaml:"age"`
}
// ToYAML 將YAMLData結構轉儲為YAML格式bytes.Buffer
func (t *YAMLData) ToYAML() (*bytes.Buffer, error) {
d, err := yaml.Marshal(t)
if err != nil {
return nil, err
}
b := bytes.NewBuffer(d)
return b, nil
}
// Decode 將數據解碼為 YAMLData
func (t *YAMLData) Decode(data []byte) error {
return yaml.Unmarshal(data, t)
}
```
4. 建立json.go：
```
package confformat
import (
"bytes"
"encoding/json"
"fmt"
)
// JSONData 是我們使用JSON結構標記的通用數據結構
type JSONData struct {
Name string `json:"name"`
Age int `json:"age"`
}
// ToJSON 將JSONData結構轉儲為JSON格式bytes.Buffer
func (t *JSONData) ToJSON() (*bytes.Buffer, error) {
d, err := json.Marshal(t)
if err != nil {
return nil, err
}
b := bytes.NewBuffer(d)
return b, nil
}
// Decode 將數據解碼為JSONData
func (t *JSONData) Decode(data []byte) error {
return json.Unmarshal(data, t)
}
// OtherJSONExamples 顯示對json解析至其他類型的操作
func OtherJSONExamples() error {
res := make(map[string]string)
err := json.Unmarshal([]byte(`{"key": "value"}`), &res)
if err != nil {
return err
}
fmt.Println("We can unmarshal into a map instead of a struct:", res)
b := bytes.NewReader([]byte(`{"key2": "value2"}`))
decoder := json.NewDecoder(b)
if err := decoder.Decode(&res); err != nil {
return err
}
fmt.Println("we can also use decoders/encoders to work with streams:", res)
return nil
}
```
5. 建立marshal.go：
```
package confformat
import "fmt"
// MarshalAll 建立了不同結構類型的數據并將它們轉換至對應的格式
func MarshalAll() error {
t := TOMLData{
Name: "Name1",
Age: 20,
}
j := JSONData{
Name: "Name2",
Age: 30,
}
y := YAMLData{
Name: "Name3",
Age: 40,
}
tomlRes, err := t.ToTOML()
if err != nil {
return err
}
fmt.Println("TOML Marshal =", tomlRes.String())
jsonRes, err := j.ToJSON()
if err != nil {
return err
}
fmt.Println("JSON Marshal=", jsonRes.String())
yamlRes, err := y.ToYAML()
if err != nil {
return err
}
fmt.Println("YAML Marshal =", yamlRes.String())
return nil
}
```
6. 建立 unmarshal.go：
```
package confformat
import "fmt"
const (
exampleTOML = `name="Example1"
age=99
`
exampleJSON = `{"name":"Example2","age":98}`
exampleYAML = `name: Example3
age: 97
`
)
// UnmarshalAll 將不同格式的數據轉換至對應結構
func UnmarshalAll() error {
t := TOMLData{}
j := JSONData{}
y := YAMLData{}
if _, err := t.Decode([]byte(exampleTOML)); err != nil {
return err
}
fmt.Println("TOML Unmarshal =", t)
if err := j.Decode([]byte(exampleJSON)); err != nil {
return err
}
fmt.Println("JSON Unmarshal =", j)
if err := y.Decode([]byte(exampleYAML)); err != nil {
return err
}
fmt.Println("Yaml Unmarshal =", y)
return nil
}
```
7. 建立main.go：
```
package main
import "github.com/agtorre/go-cookbook/chapter2/confformat"
func main() {
if err := confformat.MarshalAll(); err != nil {
panic(err)
}
if err := confformat.UnmarshalAll(); err != nil {
panic(err)
}
if err := confformat.OtherJSONExamples(); err != nil {
panic(err)
}
}
```
8. 這會輸出：
```
TOML Marshal = name = "Name1"
age = 20
JSON Marshal= {"name":"Name2","age":30}
YAML Marshal = name: Name3
age: 40
TOML Unmarshal = {Example1 99}
JSON Unmarshal = {Example2 98}
Yaml Unmarshal = {Example3 97}
We can unmarshal into a map instead of a struct: map[key:value]
we can also use decoders/encoders to work with streams:
map[key:value key2:value2]
```
### 說明
本節給出了使用TOML，YAML和JSON解析器將原始數據寫入go結構并從中讀取數據并使用相應格式的示例。 與第1章 I/O和文件系統中的示例一樣，我們看到在[]byte，string，bytes.Buffer和其他 I/O 接口之間快速切換是多么常見。
encoding/json包對JSON編碼提供了全面的支持。我們抽象出這些函數，可以看到快速轉換為對應的結構非常簡單。
本節還涉及了struct標簽及其用法。前一章也使用了這些，并且這是Go中的一種常見方式，用于向包和庫提供有關如何處理結構中所包含數據的提示。
此外，Go對xml也支持開箱即用。而配置文件格式還有ini、cfg、properties、plist、config等，大家可以自行查詢相應的第三方庫。
* * * *
學識淺薄，錯誤在所難免。歡迎在群中就本書提出修改意見，以饗后來者，長風拜謝。
Golang中國（211938256）
beego實戰（258969317）
Go實踐（386056972）
- 前言
- 第一章 I/O和文件系統
- 常見 I/O 接口
- 使用bytes和strings包
- 操作文件夾和文件
- 使用CSV格式化數據
- 操作臨時文件
- 使用 text/template和HTML/templates包
- 第二章 命令行工具
- 解析命令行flag標識
- 解析命令行參數
- 讀取和設置環境變量
- 操作TOML，YAML和JSON配置文件
- 操做Unix系統下的pipe管道
- 處理信號量
- ANSI命令行著色
- 第三章 數據類型轉換和解析
- 數據類型和接口轉換
- 使用math包和math/big包處理數字類型
- 貨幣轉換和float64注意事項
- 使用指針和SQL Null類型進行編碼和解碼
- 對Go數據編碼和解碼
- Go中的結構體標簽和反射
- 通過閉包實現集合操作
- 第四章 錯誤處理
- 錯誤接口
- 使用第三方errors包
- 使用log包記錄錯誤
- 結構化日志記錄
- 使用context包進行日志記錄
- 使用包級全局變量
- 處理恐慌
- 第五章 數據存儲
- 使用database/sql包操作MySQL
- 執行數據庫事務接口
- SQL的連接池速率限制和超時
- 操作Redis
- 操作MongoDB
- 創建存儲接口以實現數據可移植性
- 第六章 Web客戶端和APIs
- 使用http.Client
- 調用REST API
- 并發操作客戶端請求
- 使用OAuth2
- 實現OAuth2令牌存儲接口
- 封裝http請求客戶端
- 理解GRPC的使用
- 第七章 網絡服務
- 處理Web請求
- 使用閉包進行狀態處理
- 請求參數驗證
- 內容渲染
- 使用中間件
- 構建反向代理
- 將GRPC導出為JSON API
- 第八章 測試
- 使用標準庫進行模擬
- 使用Mockgen包
- 使用表驅動測試
- 使用第三方測試工具
- 模糊測試
- 行為驅動測試
- 第九章 并發和并行
- 第十章 分布式系統
- 第十一章 響應式編程和數據流
- 第十二章 無服務器編程
- 第十三章 性能改進