纪念一下我这个菜鸡有史以来写过的最好的代码。

目的是写一个配置文件保存模块，保存工程中某些需要保存的配置。
由于需要保存的数据比较零散，分散在很多模块中。有想过建一个大结构体，然后把所有需要保存的数据放到这个结构体中，但是在保存和读取时，需要把其它模块的数据转到这个大结构体（模块多了，操作起来很不方便）。另外一种想法就是，直接把其它模块需要保存的数据定义在这个模块中，这样会破坏模块的完整性。

然后，我选择了第一种方法。写完发现package 循环导入的问题。包B是我的配置保存模块，里面有包A的数据结构，所以包B需要导入包A。但是包A需要使用包B的保存方法，包A就需要导入包B。然后就GG了。。。

这个时候如果考虑第二种方法，把数据结构定义到配置保存模块中，那么，就不会发生包循环导入的问题了。但是，我之前写的模块就被破坏了，我要把定义的结构体移到保存配置模块中。然后，程序员的执着不允许我这么做。

然后，使用面向对象的思想，我在保存配置的模块定义了一个结构，包含读配置和写配置。还定义了一个结构，用来保存所有的配置数据，来自不同模块的，为了不循环导入，因此使用空接口。这里，我之定义了两个空接口，因为只有两个包的配置数据需要保存。

type GetConfiger interface {
	GetConfig(*GlobalConfig) error
	SetConfig(*GlobalConfig, GetConfiger)
}

/* 使用空接口，解决package循环导入的问题 */
type GlobalConfig struct {
	LogConfig interface{} `json:"LogConfig"`
	ApnParam  interface{} `json:"ApnParam"`
}

结果一这样定义，我就感觉这个结构体可以储存任何配置了。
最后一通折腾，代码如下：

package file

import (
	"encoding/json"
	"errors"
	"os"

	log "github.com/sirupsen/logrus"
)

type GetConfiger interface {
	GetConfig(*GlobalConfig) error
	SetConfig(*GlobalConfig, GetConfiger)
}

/* 使用空接口，解决package循环导入的问题 */
type GlobalConfig struct {
	LogConfig interface{} `json:"LogConfig"`
	ApnParam  interface{} `json:"ApnParam"`
}

const (
	GLOBALCONFIG_FILE = "global.conf"
)

/* 全局配置 */
var gblConf = &GlobalConfig{}

func init() {
	ReadFile()
}

func Write(conf GetConfiger) {
	conf.SetConfig(gblConf, conf)
	data, err := json.MarshalIndent(gblConf, "", "\t")
	if err != nil {
		log.Error(err)
	}

	err = os.WriteFile(GLOBALCONFIG_FILE, data, 0666)
	if err != nil {
		log.Error(err)
	}
}

func Read(g GetConfiger) error {
	return g.GetConfig(gblConf)
}

func ReadFile() {
	data, err := os.ReadFile(GLOBALCONFIG_FILE)
	if err != nil {
		log.Warn(err)
		return
	}

	err = json.Unmarshal(data, gblConf)
	if err != nil {
		log.Warn(err)
		return
	}
}

func (gb *GlobalConfig) GetConfigToStruct(gi GetConfiger, gs interface{}) error {
	if gs == nil {
		err := errors.New("interface{} is nil for parse")
		log.Warn(err)
		return err
	}
	data, err := json.Marshal(gs)
	if err != nil {
		log.Error(err)
		return err
	}

	err = json.Unmarshal(data, gi)
	if err != nil {
		log.Error(err)
	}
	return err
}

然后我的日志模块，定义的数据类型如下。

type LogConfig struct {
	/* 日志文件句柄 */
	logFile *os.File `json:"-"`
	/* 日志格式采用 “text” 或 “json” */
	Format string `json:"Format"`
	/* 日志输出到文件 */
	ToFile bool `json:"ToFile"`
	/* 日志输出到终端 */
	ToStdout bool `json:"ToStdout"`
	/* 日志等级 */
	Level string `json:"Level"`
	/* 日志文件名称 */ 
	OutFile string `json:"OutFile"`
	/* 日志文件的大小限制 unit: Byte */
	MaxSize uint32 `json:"MaxSize"`
	/* 日志格式控制 */
	Formatter *MyFormatter `json:"Formatter"`
}

type MyFormatter struct {
	/* 打印调用信息，文件 行 */
	ReportCaller bool
	/* 显示等级信息 */
	ShowLevel bool
	/* 日志带颜色 */
	ColorEnable bool
	/* 显示时间戳 */
	Timestamp bool
	/* 时间戳格式 */
	TimestampFormat  string
	callerPrettyfier func(*runtime.Frame) (file string, function string, line string) `json:"-"`
}

这个时候要使用配置保存模块，只需要下面几行代码就可以了。

• 实现了GetConfiger接口的两个方法。这里的接口转结构体代码已经在我的模块中写好了通用的。直接调用就行了。SetConfig方法需要实现，将结构体保存到GlobalConfig结构体中的哪一个字段就行了，这决定了这个配置将使用哪一个字段来作为json的键。

func (lc *LogConfig) GetConfig(g *file.GlobalConfig) error {
	return g.GetConfigToStruct(lc, g.LogConfig)
}

func (lc *LogConfig) SetConfig(g *file.GlobalConfig, conf file.GetConfiger) {
	g.LogConfig = *lc
}

• 使用

func main() {
	lc := &LogConfig{}
	file.Read(lc)
	lc.ToStdout = false
	file.Write(lc)
}

需要添加配置在GlobalConfig结构体中添加字段，并实现GetConfiger接口的两个方法(只需要照着上面的实现复制粘贴就行了，就2行代码)，就可以愉快的使用Write和Read方法来保存和读取配置了。

两外一个模块使用保存配置模块的案例。

type APN_param struct {
	Apn     string
	User    string
	Passwd  string
	Dialnum string
}

func (a *APN_param) GetConfig(g *file.GlobalConfig) error {
	return g.GetConfigToStruct(a, g.ApnParam)
}

func (a *APN_param) SetConfig(g *file.GlobalConfig, conf file.GetConfiger) {
	g.ApnParam = *a
}

func main() {
	apn := APN_param{}
	file.Read(&apn)
	apn.Apn = "CMCC"
	file.Write(&apn)
}

完美解决所有问题。既不会循环导入，数据和操作也是模块分离的，还支持在不修改代码的情况下实现所有自定义类型的配置保存，使用起来也非常的方便。