Go 处理yaml类型的配置文件

先说一下,这里用到了很多关于反射类型的功能,可能刚开始看代码,如果对反射不熟悉的可能会不是非常清晰,但是同时也是为了更好的理解golang中的反射,同时如果后面想在代码中可以直接从我的git地址get: go get github.com/pythonsite/config_yaml 直接上代码:

// 可以用于处理读yaml格式的配置文件,同时也可以用于理解golang中的反射
package config_yaml

import (
    "strings"
    "errors"
    "io/ioutil"
    "gopkg.in/yaml.v2"
    "reflect"
    "fmt"
    "strconv"
)

type ConfigEngine struct {
    data map[interface{}]interface{}
}


// 将ymal文件中的内容进行加载
func (c *ConfigEngine) Load (path string) error {
    ext := c.guessFileType(path)
    if ext == "" {
        return errors.New("cant not load" + path + " config")
    }
    return c.loadFromYaml(path)
}

//判断配置文件名是否为yaml格式
func (c *ConfigEngine) guessFileType(path string) string {
    s := strings.Split(path,".")
    ext := s[len(s) - 1]
    switch ext {
    case "yaml","yml":
        return "yaml"
    }
    return ""
}

// 将配置yaml文件中的进行加载
func (c *ConfigEngine) loadFromYaml(path string) error {
    yamlS,readErr := ioutil.ReadFile(path)
    if readErr != nil {
        return readErr
    }
    // yaml解析的时候c.data如果没有被初始化,会自动为你做初始化
    err := yaml.Unmarshal(yamlS, &c.data)
    if err != nil {
        return errors.New("can not parse "+ path + " config" )
    }
    return nil
}

// 从配置文件中获取值
func (c *ConfigEngine) Get(name string) interface{}{
    path := strings.Split(name,".")
    data := c.data
    for key, value := range path {
        v, ok := data[value]
        if !ok {
            break
        }
        if (key + 1) == len(path) {
            return v
        }
        if reflect.TypeOf(v).String() == "map[interface {}]interface {}"{
            data = v.(map[interface {}]interface {})
        }
    }
    return nil
}

// 从配置文件中获取string类型的值
func (c *ConfigEngine) GetString(name string) string {
    value := c.Get(name)
    switch value:=value.(type){
    case string:
        return value
    case bool,float64,int:
        return fmt.Sprint(value)
    default:
        return ""
    }
}

// 从配置文件中获取int类型的值
func (c *ConfigEngine) GetInt(name string) int {
    value := c.Get(name)
    switch value := value.(type){
    case string:
        i,_:= strconv.Atoi(value)
        return i
    case int:
        return value
    case bool:
        if value{
            return 1
        }
        return 0
    case float64:
        return int(value)
    default:
        return 0
    }
}

// 从配置文件中获取bool类型的值
func (c *ConfigEngine) GetBool(name string) bool {
    value := c.Get(name)
    switch value := value.(type){
    case string:
        str,_:= strconv.ParseBool(value)
        return str
    case int:
        if value != 0 {
            return true
        }
        return false
    case bool:
        return value
    case float64:
        if value != 0.0 {
            return true
        }
        return false
    default:
        return false
    }
}

// 从配置文件中获取Float64类型的值
func (c *ConfigEngine) GetFloat64(name string) float64 {
    value := c.Get(name)
    switch value := value.(type){
    case string:
        str,_ := strconv.ParseFloat(value,64)
        return str
    case int:
        return float64(value)
    case bool:
        if value {
            return float64(1)
        }
        return float64(0)
    case float64:
        return value
    default:
        return float64(0)
    }
}

// 从配置文件中获取Struct类型的值,这里的struct是你自己定义的根据配置文件
func (c *ConfigEngine) GetStruct(name string,s interface{}) interface{}{
    d := c.Get(name)
    switch d.(type){
    case string:
        c.setField(s,name,d)
    case map[interface{}]interface{}:
        c.mapToStruct(d.(map[interface{}]interface{}), s)
    }
    return s
}

func (c *ConfigEngine) mapToStruct(m map[interface{}]interface{},s interface{}) interface{}{
    for key, value := range m {
        switch key.(type) {
        case string:
            c.setField(s,key.(string),value)
        }
    }
    return s
}

// 这部分代码是重点,需要多看看
func (c *ConfigEngine) setField(obj interface{},name string,value interface{}) error {
    // reflect.Indirect 返回value对应的值
    structValue := reflect.Indirect(reflect.ValueOf(obj))
    structFieldValue := structValue.FieldByName(name)

    // isValid 显示的测试一个空指针
    if !structFieldValue.IsValid() {
        return fmt.Errorf("No such field: %s in obj",name)
    }

    // CanSet判断值是否可以被更改
    if !structFieldValue.CanSet() {
        return fmt.Errorf("Cannot set %s field value", name)
    }

    // 获取要更改值的类型
    structFieldType := structFieldValue.Type()
    val := reflect.ValueOf(value)

    if structFieldType.Kind() == reflect.Struct && val.Kind() == reflect.Map {
        vint := val.Interface()

        switch vint.(type) {
        case map[interface{}]interface{}:
            for key, value := range vint.(map[interface{}]interface{}) {
                c.setField(structFieldValue.Addr().Interface(), key.(string), value)
            }
        case map[string]interface{}:
            for key, value := range vint.(map[string]interface{}) {
                c.setField(structFieldValue.Addr().Interface(), key, value)
            }
        }

    } else {
        if structFieldType != val.Type() {
            return errors.New("Provided value type didn't match obj field type")
        }

        structFieldValue.Set(val)
    }

    return nil
}

先写一个对上面这个包的使用例子: 首先是yaml配置文件的内容,这里简单写了一些内容:

Site:
    HttpPort: 8080
    HttpsOn: false
    Domain: "pythonsite.com"
    HttpsPort: 443
Nginx:
    Port: 80
    LogPath:  "/opt/log/nginx.log"
    Path: "/opt/nginx/"
SiteName: "this is my web site"
SiteAddr: "BeiJing"

测试程序的代码为:

package main

import (
    "github.com/pythonsite/config_yaml"
    "fmt"

)

type SiteConfig struct {
    HttpPort    int
    HttpsOn     bool
    Domain      string
    HttpsPort   int
}

type NginxConfig struct {
    Port int
    LogPath string
    Path    string
}


func main() {
    c2 := config_yaml.ConfigEngine{}
    c2.Load("test.yaml")

    siteConf := SiteConfig{}
    res := c2.GetStruct("Site",&siteConf)
    fmt.Println(res)

    nginxConfig := NginxConfig{}
    res2 := c2.GetStruct("Nginx",&nginxConfig)
    fmt.Println(res2)

    siteName := c2.GetString("SiteName")
    siteAddr := c2.GetString("SiteAddr")
    fmt.Println(siteName,siteAddr)

}

效果如下:

感觉挺好用哈

补充一些知识点(参考go圣经)

接口值

接口值有两个部分组成:具体的类型和该类型的值,而这两个概念被称为接口的动态类型和动态值 Go语言中,变量总是被初始化之后我们才能使用,即使接口类型也不例外 对于接口值的零值就是类型的值和值的内容都是nil

对于接口值我们是可以通过==nil 或者!=nil 的方法来判断接口值是否为空 var w io.Writer w = os.Stdout 当通过w = os.Stdout 进行赋值的时候调用了一个具体类型到接口类型的隐式转换,这和显式的使用io.Writer(os.Stdout)是等价的。 当赋值之后w 这个接口值的动态类型被设置为*os.Stdout指针的类型描述符,它的动态值是os.Stdout的拷贝

通常在编译期,我们不知道接口值的动态类型是什么,所以一个接口上的调用必须使用动态分配。因为 不是直接进行调用,所以编译器必须把代码生成在类型描述符的方法Write上,然后间接调用那个地址。 这个调用的接收者是一个接口动态值的拷贝,os.Stdout。效果和下面这个直接调用一样: os.Stdout.Write([]byte("hello")) 等价于 w.Write([]byte("hello"))

反射

函数 reflect.TypeOf 接受任意的 interface{} 类型, 并返回对应动态类型的reflect.Type:

t := reflect.TypeOf(3)
fmt.Println(t.String())
fmt.Println(t)

我们可以查看一下reflect.TypeOf的详细方法:

// TypeOf returns the reflection Type that represents the dynamic type of i.
// If i is a nil interface value, TypeOf returns nil.
func TypeOf(i interface{}) Type {
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}

可以看到参数类型是一个interface{},就像上面在接口值中说的这里会将这个具体的值即我们传入的3进行一个隐式的转换 会创建一个包含两个信息的接口值:3这个变量的动态类型,这里是int; 3这个变量的动态值,这里是3

reflect.ValueOf 接受任意的 interface{} 类型, 并返回对应动态类型的reflect.Value. 和 reflect.TypeOf 类似, reflect.ValueOf 返回的结果也是对于具体的类型, 但是 reflect.Value 也可 以持有一个接口值

v := reflect.ValueOf(3)
fmt.Println(v)
fmt.Println(v.String())

v2 := reflect.ValueOf("abc")
fmt.Println(v2)
fmt.Println(v2.String())

这里需要注意除非 Value 持有的是字符串, 否则 String 只是返回具体的类型. Value 的 Type 方法将返回具体类型所对应的 reflect.Type:

t = v.Type()
fmt.Println(t)
fmt.Println(t.String())

当然我们也可以逆操作回去reflect.Value.Interface,然后通过断言的方式实现 一个 reflect.Value 和 interface{} 都能保存任意的值. 所不同的是, 一个空的接口隐藏了值对应的 表示方式和所有的公开的方法, 因此只有我们知道具体的动态类型才能使用类型断言来访问内部的值, 对于内部值并没有特别可做的事情. 相比之下, 一个 Value 则有很多方法来检查其内容, 无论它的具体类型是什么

使用 reflect.Value 的 Kind kinds类型却是有限的: Bool, String 和 所有数字类型的基础类型; Array 和 Struct 对应的聚合 类型; Chan, Func, Ptr, Slice, 和 Map 对应的引用类似; 接口类型; 还有表示空值的无效类型. (空 的 reflect.Value 对应 Invalid 无效类型.)

通过reflect.Value修改值

有一些reflect.Values是可取地址的;其它一些则不可以,例子如下:

package main

import (
    "reflect"
    "fmt"
)

func main() {
    x := 2
    a := reflect.ValueOf(2)
    b := reflect.ValueOf(x)
    c := reflect.ValueOf(&x)
    d := c.Elem()
    fmt.Println(a.CanAddr()) // false
    fmt.Println(b.CanAddr()) // false
    fmt.Println(c.CanAddr()) // false
    fmt.Println(d.CanAddr()) // true

}

所有通过reflect.ValueOf(x)返回的 reflect.Value都是不可取地址的。但是对于d,它是c的解引用方式生成的,指向另一个变量,因此是可 取地址的。我们可以通过调用reflect.ValueOf(&x).Elem(),来获取任意变量x对应的可取地址的 Value。

要从变量对应的可取地址的reflect.Value来访问变量需要三个步骤。第一步是调用Addr()方法,它返回 一个Value,里面保存了指向变量的指针。然后是在Value上调用Interface()方法,也就是返回一个 interface{},里面通用包含指向变量的指针。最后,如果我们知道变量的类型,我们可以使用类型的断 言机制将得到的interface{}类型的接口强制环为普通的类型指针。这样我们就可以通过这个普通指针来 更新变量了:

package main

import (
    "reflect"
    "fmt"
)

func main() {
    x := 2
    d := reflect.ValueOf(&x).Elem()
    px := d.Addr().Interface().(*int)
    *px = 3
    fmt.Print(x)
}

当然这里也可以通过另外一种方法更改:

package main

import (
    "reflect"
    "fmt"
)

func main() {
    x := 2
    d := reflect.ValueOf(&x).Elem()
    //px := d.Addr().Interface().(*int)
    //*px = 3
    d.Set(reflect.ValueOf(4))
    fmt.Print(x)
}

但是直接Set是会报错的,因为这里我们正好用的赋值也是int类型,如果我们用字符串的肯定就panic了

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Golang语言社区

go语言中的数组切片:特立独行的可变数组

初看go语言中的slice,觉得是可变数组的一种很不错的实现,直接在语言语法的层面支持,操作方面比起java中的ArrayList方便了许多。但是在使用了一段时...

36140
来自专栏debugeeker的专栏

《coredump问题原理探究》Linux x86版3.3节栈布局之局部变量

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xuzhina/article/detai...

10310
来自专栏数据结构与算法

洛谷P1435 回文字串(dp)

首先不难看出,这题跟LCS有关,而且是魔改版的LCS,具体来说,我们要求的是前缀$1 - i$的反串和后缀$i - n$的LCS。

10910
来自专栏盛国存的专栏

A Bite of GoLang(上)

A bite of GoLang(浅尝GoLang),本文只是Go语言的冰山一角,本文包含作者学习Go语言期间积累的一些小的经验,同时为了方便让读者了解到Go语...

565100
来自专栏从流域到海域

《笨办法学Python》 第39课手记

《笨办法学Python》 第39课手记 本节课讲列表的操作,用来做练习的代码中出现了之前用到过的几个函数,是一节复习课。你需要记住它们。 原代码如下: ten_...

21670
来自专栏技术之路

【转】Go Interface 源码剖析

源网址:http://legendtkl.com/2017/07/01/golang-interface-implement/

19820
来自专栏Golang语言社区

Go 语言简介(上)— 语法

Hello World package main //声明本文件的package名 import "fmt" //import语言的fmt库——用于输出 f...

40980
来自专栏Golang语言社区

厚土Go学习笔记 | 30. Stringers的一个练习

让 IPAddr 类型实现 fmt.Stringer 以便用点分格式输出地址。 例如,IPAddr{1, 2, 3, 4} 应当输出 "1.2.3.4"。 这个...

385110
来自专栏Golang语言社区

【Go 语言社区】Golang源码解读之map

golang的map实现并不是像c++一样使用红黑树,而是使用了hashmap,用数组来实现。 详细的实现后续补充,这里先做个备忘。 在iterate整个map...

32130
来自专栏Pythonista

Python3编程技巧

Microsoft Excel是Microsoft为使用Windows和Apple Macintosh操作系统的计算机编写的一款电子表格软件。直观的界面、出色的...

11820

扫码关注云+社区

领取腾讯云代金券