1、概述
配置文件（Configuration File，CF）是一种文本文档，为计算机系统或程序配置参数和初始设置。传统的配置文件就是文本行，在 Unix 系统中随处可见，通常使用 .conf,.config,.cfg 作为后缀，并逐步形成了 key = value 的配置习惯。在 Windows 系统中添加了对 section 支持，通常用 .ini 作为后缀。面向对象语言的兴起，程序员需要直接将文本反序列化成内存对象作为配置，逐步提出了一些新的配置文件格式，包括 JSON，YAML，TOML 等。
关于配置文件读写
现代配置文件的读写，官方网站一般会提供各种语言的配置读写包，而且大部分是开源的。
2、课程任务
任务目标
- 熟悉程序包的编写习惯（idioms）和风格（convetions）
- 熟悉 io 库操作
- 使用测试驱动的方法
- 简单 Go 程使用
- 事件通知
任务内容
在 Gitee 或 GitHub 上发布一个读配置文件程序包，第一版仅需要读 ini 配置，配置文件格式案例：
# possible values : production, development
app_mode = development
[paths]
# Path to where grafana can store temp files, sessions, and the sqlite3 db (if that is used)
data = /home/git/grafana
[server]
# Protocol (http or https)
protocol = http
# The http port to use
http_port = 9999
# Redirect to correct domain if host header does not match domain
# Prevents DNS rebinding attacks
enforce_domain = true
|
任务要求
- 核心任务：包必须提供一个函数
Watch(filename,listener) (configuration, error)- 输入 filename 是配置文件名
- 输入 listener 一个特殊的接口，用来监听配置文件是否被修改，让开发者自己决定如何处理配置变化
type ListenFunc func(string)type inteface Listener { listen(inifile string) }-
ListenFunc实现接口方法listen直接调用函数 - 优点
- 所有满足签名的函数、方法都可以作为参数
- 所有实现 Listener 接口的数据类型都可作为参数
- 输出 configuration 数据类型，可根据 key 读对应的 value。 key 和 value 都是字符串
- 输出 error 是错误数据，如配置文件不存在，无法打开等
- 可选的函数
WatchWithOption(filename,listener,...) (configuration, error)
- 包必须包括以下内容：
- 生成的中文 api 文档
- 有较好的 Readme 文件，包括一个简单的使用案例
- 每个go文件必须有对应的测试文件
- 必须提供自定义错误
- 使有 init 函数，使得 Unix 系统默认采用
#作为注释行，Windows 系统默认采用;作为注释行。
- 不能使用第三方包，但可以参考、甚至复制它们的代码。例如：
- ini 读写包。 Github，中文支持
- Viper 读配置集成解决方案包。Github
live watching and re-reading of config files (optional)
- fsnotify 文件系统通知包。 Github
- 你可以参考这些代码，但不能在你的包中 import
下面是实现的代码，具体细节见注释部分
我在注释部分说明的很详细，就不再过多说明函数的作用
数据结构
type config struct {
sectionList []string //存key
sections map[string]*section //实际存储数据的地方（形成key和value的映射）
}
type section struct {
keyValue map[string]string
}
watch函数
func Watch(filename string, listener Listener) (*config, error) {
var cfg *config
listener.Listen(filename)
var e error = nil
cfg, e = load(filename)
return cfg, e
}
加载文件
func load(filename string) (*config, error) {
f, err := os.Open(filename) //打开文件
if err != nil { //如果打开失败--遇到错误
return nil, err
}
defer f.Close() //在函数执行结束后关闭文件
buf := bufio.NewReader(f) //从文件里读取数据
cfg, err := parse(buf) //执行parse函数，详情见parse.go
return cfg, err
}
初始化函数
func (cfg *config) init() {
cfg.sections = make(map[string]*section) //初始化map
}
建立新的section
func (cfg *config) newSection(name string) error {
if len(name) == 0 { //如果名字长度为0
return errors.New("section name is empty")
}
if cfg.sections[name] != nil { //如果sections中某一项已经有数据
return errors.New("already has same section name")
}
cfg.sectionList = append(cfg.sectionList, name) //扩展
cfg.sections[name] = §ion{
keyValue: make(map[string]string),
}
return nil
}
根据系统来确定注释行符号
func init() { //根据系统来确定注释行符号
switch runtime.GOOS {
case "windows": //如果是windows系统
notes = ";"
lineBreaker = "\r\n"
case "linux": //如果是linux系统
notes = "#"
lineBreaker = "\n"
}
}
获取一行的数据
func getLine(buf *bufio.Reader, isEOF *bool) ([]byte, error) {
line, err := buf.ReadBytes('\n') //按行读取数据
if err == io.EOF {
*isEOF = true
err = nil
} else if err != nil { //如果读取失败返回错误
return nil, err
}
line = bytes.TrimLeftFunc(line, unicode.IsSpace)
return line, err
}
解析section的名字
//解析section的名字
func parseSecName(line []byte, cfg *config) (string, error) {
close := bytes.LastIndexByte(line, ']') //获得最后‘]’的下标
if close == -1 { //如果缺少‘]’，报错
return "", fmt.Errorf("unclosed section: %s", line)
}
secName := string(line[1:close]) //获取section的名字
err := cfg.newSection(secName) //开辟新空间并获得错误信息
if err != nil { //如果存在错误，返回错误信息
return "", err
}
return secName, nil
}
解析key的名字
//解析key的名字
func parseKeyName(line string) (string, int, error) {
end := strings.IndexAny(line, keyValueDelim) //确定key-alue的分割符的下标
if end < 0 { //如果下表<0，即存在错误
return "", -1, fmt.Errorf("delimiter(%s) not found", keyValueDelim)
}
return strings.TrimSpace(line[0:end]), end + 1, nil //这里返回的下标为分割符下标+1
}
解析value
//解析value
func parseValue(line string) (string, error) {
line = strings.TrimSpace(line) //去空格
if len(line) == 0 { //如果长度为0
return "", nil
}
i := strings.IndexAny(line, "#;") //处理一种情况‘key = value # this is comment’也就是注释在语句后方
if i > -1 {
line = strings.TrimSpace(line[:i])
}
return line, nil //由于之前直接返回的是key-value分割符下标+1，就是value开始的地方
}
解析函数
func parse(reader *bufio.Reader) (*config, error) {
var cfg config
cfg.init() //初始化
isEOF := false //文件是否关闭
secName := defaultSection
for !isEOF { //如果文件没有关闭则执行循环
line, err := getLine(reader, &isEOF)
if err != nil {
return nil, err
}
if len(line) == 0 { //跳过空行
continue
}
if line[0] == notes[0] { //跳过注释
continue
}
if line[0] == '[' { //如果第0位是‘[’，即secname的前面一位
secName, err = parseSecName(line, &cfg) //解析secname
if err != nil { //如果解析错误返回错误
return nil, err
}
continue
}
if len(cfg.sectionList) == 0 { //没有空间则开辟新空间
err = cfg.newSection(secName)
if err != nil {
return nil, err
}
}
keyName, offset, err := parseKeyName(string(line)) //解析keyname
if err != nil {
return nil, err
}
value, err := parseValue(string(line[offset:])) //解析value
if err != nil {
return nil, err
}
err = cfg.sections[secName].newKeyValue(keyName, value) //存key和value
if err != nil {
return nil, err
}
}
return &cfg, nil
}
func (sec *section) newKeyValue(keyName string, value string) error {
if _, ok := sec.keyValue[keyName]; ok {
return fmt.Errorf("key(%v) already exists", keyName)
}
sec.keyValue[keyName] = value
return nil
}
接下来是单元测试文件：
下面是对于几个核心函数的测试
测试parseSecName函数：
func TestParseSecName(t *testing.T) {
var cfg Config
var e error
cfg.init()
secName := defaultSection
var line []byte
line = []byte("[paths]")
secName, e = parseSecName(line, &cfg)
ex1 := "paths"
var ex2 error
if secName != ex1 {
t.Errorf("ex1 wrong, '%s'", secName)
}
if e != ex2 {
t.Errorf("ex2 wrong, '%s'", e)
}
}
测试parseKeyName函数：
func TestParsekey(t *testing.T) {
line := "app_mode = development"
keyName, offset, err := parseKeyName(string(line))
ex1, ex2 := "app_mode", 10
var ex3 error
if keyName != ex1 {
t.Errorf("ex1 wrong")
}
if offset != ex2 {
t.Errorf("ex2 wrong")
}
if err != ex3 {
t.Errorf("ex3 wrong")
}
}
测试parseValue函数：
func TestParseValue(t *testing.T) {
line := "app_mode = development"
value, err := parseValue(string(line[10:]))
ex1 := "development"
var ex2 error
if value != ex1 {
t.Errorf("ex1 wrong")
}
if err != ex2 {
t.Errorf("ex2 wrong")
}
}
测试parse函数：
func TestParse(t *testing.T) {
var e error
f, err := os.Open("./testdata/test.ini")
if e != err {
t.Errorf("open file filed")
}
defer f.Close()
buf := bufio.NewReader(f)
_, erro := parse(buf)
if erro != e {
t.Errorf("parse filed")
}
}
测试结果：
生成API文档
先通过指令go get golang.org/x/tools/cmd/godoc来安装godoc。
然后执行godoc
在浏览器打开https://localhost:6060/pkg/
之后保存
实验测试：
需要先安装fsnotify
测试所用代码：
main函数：
func main() {
cfg, err := configuration.Load("test.ini")
if err != nil {
fmt.Println(err)
return
}
printCfg(cfg)
var lis configuration.ListenFunc = func(filename string) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
done := make(chan bool)
go func() {
for {
select {
case event, ok := <-watcher.Events:
if !ok {
return
}
if event.Op&fsnotify.Write == fsnotify.Write {
return
}
done <- true
return
case err, ok := <-watcher.Errors:
if !ok {
return
}
log.Println("error:", err)
}
}
}()
watcher.Add(filename)
<-done
}
cfg, err = configuration.Watch("test.ini", lis)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("")
fmt.Println("after change:")
printCfg(cfg)
}
打印函数：
func printCfg(cfg *configuration.Config) {
for _, secName := range cfg.SectionList {
sec := cfg.Sections[secName]
fmt.Printf("[%s]\n", secName)
for _, key := range sec.KeyList {
fmt.Printf("%s = %s\n", key, sec.KeyValue[key])
}
}
}
更改文件前：
更改文件后：
输出：
测试成功！