在現代軟件開發(fā)中，配置文件是不可或缺的一部分。在編寫 Go 項目時，不管是一個簡單的單文件腳本還是一個龐大的微服務項目，程序的靈活性和可擴展性都需要依賴于配置文件的加載。配置文件可以包含程序的各種設置，如端口號、數據庫連接信息、認證密鑰等，這些設置可能需要根據不同的環(huán)境和部署情況進行調整。因此，一個可靠的配置文件加載機制對于項目的成功實現至關重要。本文就來探究下在 Go 項目中如何更加方便的加載和管理配置。

在 Go 中，有很多方法可以加載和管理配置，例如使用命令行標志、環(huán)境變量或者讀取特定格式的文件。選擇哪種方法取決于項目的具體需求和開發(fā)人員的偏好。

需求

根據我的開發(fā)經驗，一個配置包通常需要支持如下功能：

• 支持從環(huán)境變量、命令行標志加載配置文件，然后將配置文件內容映射到 Go 結構體中，這個過程叫作反序列化。

• 支持將 Go 結構體中的配置信息寫入配置文件，這個過程叫作序列化。

• 起碼要支持 YAML、JSON 這兩種最常見的配置文件格式。

config 包實現

反序列化

反序列化操作是配置包最常用的功能，通過反序列化我們可以將配置文件內容映射到 Go 結構體中。所以我們先來實現如何進行配置文件的反序列化操作。

type FileType int

const (
	FileTypeYAML = iota
	FileTypeJSON
)

func LoadConfig(filename string, cfg interface{}, typ FileType) error {
	data, err := os.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("ReadFile: %v", err)
	}
	switch typ {
	case FileTypeYAML:
		return yaml.Unmarshal(data, cfg)
	case FileTypeJSON:
		return json.Unmarshal(data, cfg)
	}
	return errors.New("unsupported file type")
}

首先定義一個 FileType 類型，用來區(qū)分不同的配置文件格式，我們要實現的日志包能夠支持 YAML 和 JSON 兩種格式。

接下來實現了 LoadConfig 函數，用來加載配置，它接收三個參數：配置文件名稱、配置結構體、文件類型。

在函數內部，首先使用 os.ReadFile(filename) 讀取配置文件內容，然后根據文件類型，使用不同的方法來反序列化，最終將配置信息映射到 cfg 結構體中。

序列化

配置包還要支持序列化操作，也就是將配置信息從內存中寫入文件。有時候我們想保存一個 example-config.yaml 供項目使用者參考，這個功能就很實用。

func DumpConfig(filename string, cfg interface{}, typ FileType) error {
	var (
		data []byte
		err  error
	)
	switch typ {
	case FileTypeYAML:
		data, err = yaml.Marshal(cfg)
	case FileTypeJSON:
		data, err = json.Marshal(cfg)
	}
	if err != nil {
		return err
	}
	f, err := os.Create(filename)
	if err != nil {
		return err
	}
	_, err = f.Write(data)
	_ = f.Close()
	return err
}

我們實現了 DumpConfig 函數用來進行序列化操作，該函數同樣接收三個參數：配置文件名、配置結構體、文件類型。

在函數中，首先根據文件類型對配置對象 cfg 進行序列化操作得到 data，然后通過 os.Create(filename) 創(chuàng)建配置文件文件，最后使用 f.Write(data) 將序列化后的內容寫入文件。

現在配置包的核心功能已經實現了，并且兩個函數都被允許導出，如果其他項目想使用，其實是可以拿過去直接使用的。不過目前的配置包在易用性上還有可優(yōu)化的空間。

通過環(huán)境變量/命令行參數指定配置文件

以上序列化/反序列化函數的實現，配置文件名都是需要通過參數傳遞進來的，我們還可以通過環(huán)境變量或者命令行參數的形式來指定配置文件名。

var (
	cfgPath = flag.String("c", "config.yaml", "path to config file")
	dump    = flag.Bool("d", false, "dump config to file")
)

func init() {
	_ = flag.Set("c", os.Getenv("CONFIG_PATH"))
	_ = flag.Set("d", os.Getenv("DUMP_CONFIG"))
}

命令行參數解析可以使用 Go 內置的 flag 包來實現，我們在這里聲明了兩個標志，-c 用來傳遞配置文件名，-d 用來決定要進行序列化還是反序列化操作。

此外，在 init 函數中，我們實現了從環(huán)境變量中加載配置文件名和需要執(zhí)行的操作。當配置包被導入時，會優(yōu)先執(zhí)行 init 函數，所以這些信息會優(yōu)先從環(huán)境變量讀取。

封裝

現在我們可以通過環(huán)境變量或命令行參數的形式拿到配置文件名和需要執(zhí)行的操作兩個參數，并且分別賦值給 cfgPath、dump 兩個變量，接下來我們將對之前實現的序列化/反序列化函數進行封裝，讓其使用起來更加便捷。

反序列化

首先，我們可以將反序列化操作函數 LoadConfig 進一步封裝，將其包裝成兩個函數分別加載 YAML 配置和 JSON 配置，這樣調用方在使用時能夠少傳遞一個參數。實現如下：

func LoadYAMLConfig(filename string, cfg interface{}) error {
	return LoadConfig(filename, cfg, FileTypeYAML)
}

func LoadJSONConfig(filename string, cfg interface{}) error {
	return LoadConfig(filename, cfg, FileTypeJSON)
}

其次，我們拿到的 cfgPath 參數也能派上用場了，可以對 LoadYAMLConfig、LoadJSONConfig 進一步封裝：

func LoadYAMLConfigFromFlag(cfg interface{}) error {
	if !flag.Parsed() {
		flag.Parse()
	}
	return LoadYAMLConfig(*cfgPath, cfg)
}

func LoadJSONConfigFromFlag(cfg interface{}) error {
	if !flag.Parsed() {
		flag.Parse()
	}
	return LoadJSONConfig(*cfgPath, cfg)
}

因為 cfgPath 是通過環(huán)境變量或命令行參數形式傳入，所以調用反序列化函數的時候也就沒必要手動傳入了。

不過在使用 cfgPath 變量之前，我們調用了 flag.Parsed() 并對其返回值進行了判斷，如果 flag.Parsed() 返回 false 則調用 flag.Parse()。

這一步操作是因為，配置包的調用方可能也使用了 flag 包，那么如果調用方已經調用過 flag.Parse() 解析了命令行參數，調用 flag.Parsed() 就會返回 true，此時配置包內部沒必要再解析一遍命令行參數，可以直接使用。

序列化

封裝好了反序列化操作，對應的，也要封裝序列化操作。代碼實現上與反序列化操作如出一轍，我將代碼貼在這里，就不再進行講解了。

func DumpYAMLConfig(filename string, cfg interface{}) error {
	return DumpConfig(filename, cfg, FileTypeYAML)
}

func DumpJSONConfig(filename string, cfg interface{}) error {
	return DumpConfig(filename, cfg, FileTypeJSON)
}

func DumpYAMLConfigFromFlag(cfg interface{}) error {
	if !flag.Parsed() {
		flag.Parse()
	}
	return DumpYAMLConfig(*cfgPath, cfg)
}

func DumpJSONConfigFromFlag(cfg interface{}) error {
	if !flag.Parsed() {
		flag.Parse()
	}
	return DumpJSONConfig(*cfgPath, cfg)
}

統(tǒng)一出口函數

我們通過環(huán)境變量或命令行參數拿到的另外一個用戶指定的變量 dump 還沒有使用，dump 是一個 bool 值，代表用戶是否想要序列化配置，如果為 true 則進行序列化操作，否則進行反序列化操作。

由此，我們可以將序列化/反序列化操作封裝成一個函數，內部通過 dump 的值來決定執(zhí)行哪種操作。實現如下：

func LoadOrDumpYAMLConfigFromFlag(cfg interface{}) error {
	if !flag.Parsed() {
		flag.Parse()
	}
	if *dump {
		if err := DumpYAMLConfig(*cfgPath, cfg); err != nil {
			return err
		}
		os.Exit(0)
	}
	return LoadYAMLConfig(*cfgPath, cfg)
}

func LoadOrDumpJSONConfigFromFlag(cfg interface{}) error {
	if *dump {
		if err := DumpJSONConfigFromFlag(cfg); err != nil {
			return err
		}
		os.Exit(0)
	}
	return LoadJSONConfigFromFlag(cfg)
}

我們對 YAML 和 JSON 格式的配置分別實現了 LoadOrDumpYAMLConfigFromFlag 和 LoadOrDumpJSONConfigFromFlag 函數。顧名思義，這個函數既能加載（Load）配置，也能將配置寫入（Dump）文件。

兩個函數內部思路相同，如果 dump 為 true，就序列化配置信息到文件中，并且使用 os.Exit(0) 退出程序。此時，控制臺不會有任何輸出，這遵循了 Linux/Unix 系統(tǒng)的設計哲學，沒有消息就是最好的消息；如果 dump 為 false，則進行反序列化操作。

以上我們就實現了自定義配置包的全部功能，完整代碼可以點擊這里查看。

config 包使用

配置包的完整使用示例我寫在了項目 GitHub 倉庫的 README.md 文件中，你可以點進去查看。

總結

本文帶大家一起使用 Go 語言實現了一個簡潔的日志包，雖然功能不多，但足夠中小型項目使用。如果對加載配置文件有更多的要求，如更多格式的日志文件支持、熱加載等，則可以考慮使用更強大的 Go 第三方庫 Viper，或者使用 Nacos、Disconf 等配置中心。

在這個云原生的時代，其實多數情況下，配置包不需要實現多么復雜的功能，盡量保持簡潔。配置文件可以使用 K8s ConfigMap 來實現，配置包的高級特性也可以考慮通過 Sidecar 的形式來實現。

最新評論