Go怎么实现一个配置包

这篇文章主要讲解了“Go怎么实现一个配置包”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Go怎么实现一个配置包”吧！

需求

根据我的开发经验，一个配置包通常需要支持如下功能：

• 支持从环境变量、命令行标志加载配置文件，然后将配置文件内容映射到 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

类型，用来区分不同的配置文件格式，我们要实现的日志包能够支持 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)

创建配置文件文件，最后使用

f.Write(data)

将序列化后的内容写入文件。

现在配置包的核心功能已经实现了，并且两个函数都被允许导出，如果其他项目想使用，其实是可以拿过去直接使用的。不过目前的配置包在易用性上还有可优化的空间。

通过环境变量/命令行参数指定配置文件

以上序列化/反序列化函数的实现，配置文件名都是需要通过参数传递进来的，我们还可以通过环境变量或者命令行参数的形式来指定配置文件名。

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

函数中，我们实现了从环境变量中加载配置文件名和需要执行的操作。当配置包被导入时，会优先执行

init

函数，所以这些信息会优先从环境变量读取。

封装

现在我们可以通过环境变量或命令行参数的形式拿到配置文件名和需要执行的操作两个参数，并且分别赋值给

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

是通过环境变量或命令行参数形式传入，所以调用反序列化函数的时候也就没必要手动传入了。

不过在使用

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

统一出口函数

我们通过环境变量或命令行参数拿到的另外一个用户指定的变量

dump

还没有使用，

dump

是一个

bool

值，代表用户是否想要序列化配置，如果为

true

则进行序列化操作，否则进行反序列化操作。

由此，我们可以将序列化/反序列化操作封装成一个函数，内部通过

dump

的值来决定执行哪种操作。实现如下：

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 系统的设计哲学，没有消息就是最好的消息；如果

dump

为

false

，则进行反序列化操作。

以上就是Go怎么实现一个配置包的详细内容，更多关于Go怎么实现一个配置包的资料请关注九品源码其它相关文章！