:::success

    • 任务：解析如下配置文件
      • 序列化：将结构体序列化为配置文件数据并保存到硬盘
      • 反序列化：将配置文件内容反序列化到程序的结构体
    • 配置文件有server和mysql相关配置

    :::

    1. #this is comment
    2. ;this a comment
    3. ;[]表示一个section
    4. [server]
    5. ip = 10.238.2.2
    6. port = 8080
    8. [mysql]
    9. username = root
    10. passwd = admin
    11. database = test
    12. host = 192.168.10.10
    13. port = 8000
    14. timeout = 1.2

    代码地址：https://github.com/lu569368/Practise_reflex.git

    1. #this is comment
    2. ;this a comment
    3. ;[]表示一个section
    4. [server]
    5. ip = 10.238.2.2
    6. port = 8080
    8. [mysql]
    9. username = root
    10. passwd = admin
    11. database = test
    12. host = 192.168.10.10
    13. port = 8000
    14. timeout = 1.2
    1. package main
    3. import (
    4.     "fmt"
    5.     "io/ioutil"
    6.     "reflect"
    7.     "strconv"
    8.     "strings"
    9. )
    11. // 序列化和反序列化
    12. // 序列化数据到指定的文件
    13. func MarshalFile(filename string, data interface{}) (err error) {
    14.     // 1.数据的序列化
    15.     result, err := Marshal(data)
    16.     if err != nil {
    17.         return
    18.     }
    19.     // 2.将序列化好的数据，写出到filename
    20.     return ioutil.WriteFile(filename, result, 0666)
    21. }
    23. // 序列化的方法
    24. // 传入的结构体 ——> []byte
    25. // 基本思路：反射解析出传入的数据，转字节切片
    26. func Marshal(data interface{}) (result []byte, err error) {
    27.     // 获取下类型
    28.     typeInfo := reflect.TypeOf(data)
    29.     valueInfo := reflect.ValueOf(data)
    30.     // 判断类型
    31.     if typeInfo.Kind() != reflect.Struct {
    32.         return
    33.     }
    34.     var conf [] string
    36.     // 获取所有字段去处理
    37.     for i := 0; i < typeInfo.NumField(); i++ {
    38.         // 取字段
    39.         labelField := typeInfo.Field(i)
    40.         // 取值
    41.         labelVal := valueInfo.Field(i)
    42.         fieldType := labelField.Type
    43.         // 判断字段类型
    44.         if fieldType.Kind() != reflect.Struct {
    45.             continue
    46.         }
    47.         // 拼的是[server]和[mysql]
    48.         // 获取个tag
    49.         tagVal := labelField.Tag.Get("ini")
    50.         if len(tagVal) == 0 {
    51.             tagVal = labelField.Name
    52.         }
    53.         label := fmt.Sprintf("\n[%s]\n", tagVal)
    54.         conf = append(conf, label)
    55.         // 拼 k-v
    56.         for j := 0; j < fieldType.NumField(); j++ {
    57.             // 这里取到的是大写
    58.             keyField := fieldType.Field(j)
    59.             // 取tag
    60.             fieldTagVal := keyField.Tag.Get("ini")
    61.             if len(fieldTagVal) == 0 {
    62.                 fieldTagVal = keyField.Name
    63.             }
    64.             // 取值
    65.             valField := labelVal.Field(j)
    66.             // Interface()取真正对应的值
    67.             item := fmt.Sprintf("%s=%v\n", fieldTagVal, valField.Interface())
    68.             conf = append(conf, item)
    69.         }
    70.     }
    71.     // 遍历切片转类型
    72.     for _, val := range conf {
    73.         byteVal := []byte(val)
    74.         result = append(result, byteVal...)
    75.     }
    76.     return
    77. }
    79. // 文件读取数据，做反序列化
    80. func UnMarshalFile(filename string, result interface{}) (err error) {
    81.     // 1.文件读取
    82.     data, err := ioutil.ReadFile(filename)
    83.     if err != nil {
    84.         return
    85.     }
    86.     // 2.进行反序列化
    87.     return UnMarshal(data, result)
    88. }
    90. // 反序列化
    91. // []byte  ---- >  结构体
    92. func UnMarshal(data []byte, result interface{}) (err error) {
    93.     // 先判断是否是指针
    94.     typeInfo := reflect.TypeOf(result)
    95.     if typeInfo.Kind() != reflect.Ptr {
    96.         return
    97.     }
    98.     // 判断是否是结构体
    99.     if typeInfo.Elem().Kind() != reflect.Struct {
    100.         return
    101.     }
    102.     // 转类型，按行切割
    103.     lineArr := strings.Split(string(data), "\n")
    104.     // 定义全局标签名   也就是server和mysql
    105.     var myFiledName string
    107.     for _, line := range lineArr {
    108.         // 各种严谨判断
    109.         line = strings.TrimSpace(line)
    110.         // 处理文档中有注释的情况
    111.         if len(line) == 0 || line[0] == ';' || line[0] == '#' {
    112.             continue
    113.         }
    114.         // 按照括号去判断
    115.         if line[0] == '[' {
    116.             // 按照大标签去处理
    117.             myFiledName, err = myLabel(line, typeInfo.Elem())
    118.             if err != nil {
    119.                 return
    120.             }
    121.             continue
    122.         }
    123.         // 按照正常数据处理
    124.         err = myField(myFiledName, line, result)
    125.         if err != nil {
    126.             return
    127.         }
    128.     }
    129.     return
    130. }
    132.   // 处理大标签
    133.   func myLabel(line string, typeInfo reflect.Type) (fieldName string, err error) {
    134.     // 去字符串头和尾
    135.     labelName := line[1 : len(line)-1]
    136.     // 循环去结构体找tag，对应上才能解析
    137.     for i := 0; i < typeInfo.NumField(); i++ {
    138.         field := typeInfo.Field(i)
    139.         tagValue := field.Tag.Get("ini")
    140.         // 判断tag
    141.         if labelName == tagValue {
    142.             fieldName = field.Name
    143.             break
    144.         }
    145.     }
    146.     return
    147. }
    149.   // 解析属性
    150.   // 参数：大标签名，行数据，对象
    151.   func myField(fieldName string, line string, result interface{}) (err error) {
    152.     fmt.Println(line)
    153.     key := strings.TrimSpace(line[0:strings.Index(line, "=")])
    154.     val := strings.TrimSpace(line[strings.Index(line, "=")+1:])
    155.     // 解析到结构体
    156.     //resultType := reflect.TypeOf(result)
    157.     resultValue := reflect.ValueOf(result)
    158.     // 拿到字段值，这里直接设置不知道类型
    159.     labelValue := resultValue.Elem().FieldByName(fieldName)
    160.     // 拿到该字段类型
    161.     fmt.Println(labelValue)
    162.     labelType := labelValue.Type()
    163.     // 第一次进来应该是server
    164.     // 存放取到的字段名
    165.     var keyName string
    166.     // 遍历server结构体的所有字段
    167.     for i := 0; i < labelType.NumField(); i++ {
    168.         // 获取结构体字段
    169.         field := labelType.Field(i)
    170.         tagVal := field.Tag.Get("ini")
    171.         if tagVal == key {
    172.             keyName = field.Name
    173.             break
    174.         }
    175.     }
    177.     // 给字段赋值
    178.     // 取字段值
    179.     filedValue := labelValue.FieldByName(keyName)
    180.     // 修改值
    181.     switch filedValue.Type().Kind() {
    182.         case reflect.String:
    183.         filedValue.SetString(val)
    184.         case reflect.Int:
    185.         i, err2 := strconv.ParseInt(val, 10, 64)
    186.         if err2 != nil {
    187.             fmt.Println(err2)
    188.             return
    189.         }
    190.         filedValue.SetInt(i)
    191.         case reflect.Uint:
    192.         i, err := strconv.ParseUint(val, 10, 64)
    193.         if err != nil {
    194.             fmt.Println(err)
    195.             return err
    196.         }
    197.         filedValue.SetUint(i)
    198.         case reflect.Float32:
    199.         f, _ := strconv.ParseFloat(val, 64)
    200.         //if err != nil {
    201.         //    fmt.Println(err)
    202.         //    return
    203.         //}
    204.         filedValue.SetFloat(f)
    205.     }
    206.     return
    207. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "io/ioutil"
    6. )
    8. // 解析文件
    9. func parseFile(filename string) {
    10.     data, err := ioutil.ReadFile(filename)
    11.     if err != nil {
    12.         return
    13.     }
    14.     var conf Config
    15.     err = UnMarshal(data, &conf)
    16.     if err != nil {
    17.         return
    18.     }
    19.     fmt.Printf("反序列化成功  conf: %#v\n  port: %#v\n", conf, conf.ServerConf.Port)
    21. }
    23. func parseFile2(filename string)  {
    24.     // 有一些假数据
    25.     var conf Config
    26.     conf.ServerConf.Ip="127.0.0.1"
    27.     conf.ServerConf.Port=8000
    28.     conf.MysqlConf.Port=9000
    29.     err := MarshalFile(filename,conf)
    30.     if err != nil{
    31.         return
    32.     }
    33. }
    35. func main() {
    36.     //parseFile("D:/config.ini")
    37.     parseFile2("D:/my2.ini")
    38. }
    1. package main
    3. type ServerConfig struct {
    4.     Ip   string `ini:"ip"`
    5.     Port int   `ini:"port"`
    6. }
    8. type MysqlConfig struct {
    9.     Username string  `ini:"username"`
    10.     Passwd   string  `ini:"passwd"`
    11.     Database string  `ini:"database"`
    12.     Host     string  `ini:"host"`
    13.     Port     int     `ini:"port"`
    14.     Timeout  float32 `ini:"timeout"`
    15. }
    17. // 总的
    18. type Config struct {
    19.     ServerConf ServerConfig `ini:"server"`
    20.     MysqlConf  MysqlConfig  `ini:"mysql"`
    21. }