练习题1

加载ini配置文件
mian.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "reflect"
  7.     "strconv"
  8.     "strings"
  9. )
  11. // MySQL 结构体
  12. type MySQL struct {
  13.     Addr string `ini:"addr"`
  14.     Port int64  `ini:"port"`
  15.     Name string `ini:"name"`
  16.     Pwd  string `ini:"pwd"`
  17. }
  19. // Redis 结构体
  20. type Redis struct {
  21.     Username string `ini:"username"`
  22.     Password string `ini:"password"`
  23. }
  25. // Config 配置文件结构体
  26. type Config struct {
  27.     MySQL `ini:"mysql"`
  28.     Redis `ini:"redis"`
  29. }
  31. func loadConfig(fileName string, data interface{}) (err error) {
  32.     /*
  33.         1、判断传入的data是否是指针类型，只有指针类型才进行下面步骤
  34.         2、判断传入的指针类型参数是否为结构体指针
  35.         3、读取文件得到字节类型数据
  36.         4、逐行读取数据
  37.             4.1、如果有注释，则跳过处理
  38.             4.2、如果是[]包含的则表示节点
  39.             4.3、如果不是上述的则对其进行按'='切割
  40.             4.4、对切割的数据进行存储到结构体
  41.     */
  42.     t := reflect.TypeOf(data)
  43.     if t.Kind() != reflect.Ptr {
  44.         err = fmt.Errorf("data param must be a pointer")
  45.         return
  46.     }
  47.     if t.Elem().Kind() != reflect.Struct {
  48.         err = fmt.Errorf("data param must be a struct pointer")
  49.         return
  50.     }
  51.     // 读取文本文件
  52.     file, err := ioutil.ReadFile(fileName)
  53.     if err != nil {
  54.         return
  55.     }
  56.     // 对读取出来的文本文件进行切片
  57.     fileSlice := strings.Split(string(file), "\r\n")
  59.     // 记录反射获取的结构体名
  60.     var structName string
  61.     // var valueType
  62.     // 遍历切片
  63.     for idx, line := range fileSlice {
  64.         // 对line进行格式化
  65.         line = strings.TrimSpace(line)
  66.         // 如果是空行则跳过
  67.         if len(line) == 0 {
  68.             continue
  69.         }
  70.         // 如果为注释则跳过
  71.         if strings.HasPrefix(line, ";") || strings.HasPrefix(line, "#") {
  72.             continue
  73.         }
  74.         // 如果以[开头再进行进一步处理
  75.         if strings.HasPrefix(line, "[") {
  76.             // 如果结尾没有 ] ，则抛出错误
  77.             if !strings.HasSuffix(line, "]") {
  78.                 err = fmt.Errorf("synx error in line %d", idx+1)
  79.                 return
  80.             }
  81.             // 如果以[开头，以]结尾，但是没有内容，则抛出错误
  82.             selectName := strings.TrimSpace(line[1 : len(line)-1])
  83.             if len(selectName) == 0 {
  84.                 err = fmt.Errorf("synx error in line %d,the content con't be empty", idx+1)
  85.                 return
  86.             }
  87.             // 如果上述条件都满足，则根据节点名称找到对应结构体
  88.             // 读取data的value
  89.             for i := 0; i < t.Elem().NumField(); i++ {
  90.                 field := t.Elem().Field(i)
  91.                 // 获取tag，反射获取其内容
  92.                 // fmt.Println(field.Tag.Get("ini"))
  93.                 // fmt.Println(selectName)
  94.                 if field.Tag.Get("ini") == selectName {
  95.                     // 说明找到了对应的结构体，然后讲结构体记录下来
  96.                     structName = field.Name
  97.                     fmt.Printf("find %s struct from %s in data\n", structName, selectName)
  98.                     break
  99.                 } else {
  100.                     structName = ""
  101.                 }
  102.             }
  103.         } else {
  104.             // 上面通过反射找到structName，判断其是不是struct类型，如果不是抛出错误
  105.             if structName != "" {
  106.                 v := reflect.ValueOf(data)
  107.                 sValue := v.Elem().FieldByName(structName)
  108.                 sType := sValue.Type()
  109.                 if sType.Kind() != reflect.Struct {
  110.                     err = fmt.Errorf("%s in data must be a struct type", structName)
  111.                     return
  112.                 }
  113.                 // 判断文本当前行是否有等号，并且等号左边是key，右边是value
  114.                 if strings.Contains(line, "=") {
  115.                     // 获取=所在的索引
  116.                     index := strings.Index(line, "=")
  117.                     key := strings.TrimSpace(line[:index])
  118.                     value := strings.TrimSpace(line[index+1:])
  119.                     if len(key) == 0 {
  120.                         err = fmt.Errorf("synx error. line: %d", idx)
  121.                         return
  122.                     }
  123.                     // fmt.Printf("key: %s value: %s\n", key, value)
  124.                     // 通过反射找到key对应的结构体中的变量名
  125.                     var fieldName string
  126.                     var filedType reflect.StructField
  127.                     for i := 0; i < sValue.NumField(); i++ {
  128.                         // fmt.Println(sValue.Field(i))
  129.                         field := sType.Field(i)
  130.                         filedType = field
  131.                         if field.Tag.Get("ini") == key {
  132.                             fieldName = field.Name
  133.                             break
  134.                         }
  135.                     }
  136.                     fileObj := sValue.FieldByName(fieldName)
  137.                     // fmt.Print(fieldName, filedType.Type.Kind())
  138.                     // 根据不同的类型进行写入操作
  139.                     switch filedType.Type.Kind() {
  140.                     case reflect.String:
  141.                         fileObj.SetString(value)
  142.                     case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int8:
  143.                         // 对value进行转换，由string-->int
  144.                         var valueInt int64
  145.                         valueInt, err = strconv.ParseInt(value, 10, 64)
  146.                         if err != nil {
  147.                             err = fmt.Errorf("line: %d synx error", idx)
  148.                             return
  149.                         }
  150.                         fileObj.SetInt(valueInt)
  151.                     case reflect.Float32, reflect.Float64:
  152.                         // 对value进行转换，由string-->float
  153.                         var valueFloat float64
  154.                         valueFloat, err = strconv.ParseFloat(value, 64)
  155.                         if err != nil {
  156.                             err = fmt.Errorf("line: %d synx error", idx)
  157.                             return
  158.                         }
  159.                         fileObj.SetFloat(valueFloat)
  160.                     case reflect.Bool:
  161.                         var valueBool bool
  162.                         valueBool, err = strconv.ParseBool(value)
  163.                         if err != nil {
  164.                             err = fmt.Errorf("line: %d synx error", idx)
  165.                             return
  166.                         }
  167.                         fileObj.SetBool(valueBool)
  168.                     default:
  169.                         err = fmt.Errorf("line: %d value type error", idx)
  170.                         return
  171.                     }
  173.                 } else {
  174.                     err = fmt.Errorf("synx error. line: %d", idx)
  175.                     return
  176.                 }
  177.             }
  178.         }
  179.     }
  180.     return
  181. }
  183. func main() {
  184.     // 声明结构体
  185.     var cfg Config
  186.     // fmt.Printf("%T\n", &cfg)
  187.     err := loadConfig("./my.ini", &cfg)
  188.     if err != nil {
  189.         fmt.Println("conf load failed,err:", err)
  190.     }
  191.     fmt.Println(cfg)
  192. }

my.ini

  1. [mysql]
  2. addr = localhost
  3. port = 3306
  4. name = root
  5. pwd = root
  7. ; [
  8.     ; []
  9. [redis]
  10. username=root
  11. password=910416