go语言简单实现加载ini文件

# 注释
; 注释
; 注释
\[redis\]
ip = 127.0.0.1
port = 8080
\[mysql\]
host = 127.0.0.1
port = 3300
database = test
user = root
password = 123456
timeout = 30

type RedisConfig struct {
   Ip   string \`ini:"ip"\`
   Port int    \`ini:"port"\`
}
type MysqlConfig struct {
   Host     string \`ini:"host"\`
   Port     int    \`ini:"port"\`
   Database string \`ini:"database"\`
   User     string \`ini:"user"\`
   Password string \`ini:"password"\`
   Timeout  int    \`ini:"timeout"\`
}
type Config struct {
   RedisConfig RedisConfig \`ini:"redis"\`
   MysqlConfig MysqlConfig \`ini:"mysql"\`
}

func unMarshalFile(fileName string, result interface{}) (err error) {
   data, err := ioutil.ReadFile(fileName)
   if err != nil {
      return err
   }
   err = UnMarshal(data, result)
   if err != nil {
      return err
   }
   return
}
func UnMarshal(data \[\]byte, result interface{}) (err error) {
   //传入的赋值变量必须为指针类型的结构体
   typeInfo := reflect.TypeOf(result)
   if typeInfo.Kind() != reflect.Ptr {
      return nil
   }
   if typeInfo.Elem().Kind() != reflect.Struct {
      return nil
   }
   lineArr := strings.Split(string(data), "\\n")
   var myFieldName string
   for _, line := range lineArr {
      //fmt.Printf("line:%s \\n",line)
      //注释判断
      //去掉2边的空格等
      line = strings.TrimSpace(line)
      //注释和无效字符
      if len(line) == 0 || line\[0\] == ';' || line\[0\] == '#' {
         continue
      }
      if line\[0\] == '\[' {
         //大标签处理
         myFieldName, err = myLabel(line, typeInfo.Elem())
         if err != nil {
            return
         }
         continue
      }
      err = myField(myFieldName, line, result)
      if err != nil {
         return
      }
   }
   return
}
func myLabel(line string, typeInfo reflect.Type) (fieldName string, err error) {
   //去掉字符串头尾
   labelName := line\[1 : len(line)-1\]
   //fmt.Printf("myLabel \\n")
   //循环去结构体找tag,对应上才能解析
   for i := 0; i < typeInfo.NumField(); i++ {
      field := typeInfo.Field(i)
      tagValue := field.Tag.Get("ini")
      //fmt.Printf("myLabel.filed:%s \\n",field)
      //fmt.Printf("myLabel.tagValue:%s \\n",tagValue)
      //判断tag
      if labelName == tagValue {
         fieldName = field.Name
         break
      }
   }
   return
}
func myField(fieldName string, line string, result interface{}) (err error) {
   key := strings.TrimSpace(line\[0:strings.Index(line, "=")\])
   value := strings.TrimSpace(line\[strings.Index(line, "=")+1:\])
   //解析到结构体(config)
   resultValue := reflect.ValueOf(result)
   //获取结构体的结构体数据
   labelValue := resultValue.Elem().FieldByName(fieldName)
   //获取到字段类型
   labelType := labelValue.Type()
   var keyName string
   for i := 0; i < labelType.NumField(); i++ {
      field := labelType.Field(i)
      tagVal := field.Tag.Get("ini")
      if tagVal == key {
         keyName = field.Name
         break
      }
   }
   //给字段赋值
   //取字段值
   fieldValue := labelValue.FieldByName(keyName)
   switch fieldValue.Type().Kind() {
   case reflect.String:
      fieldValue.SetString(value)
   case reflect.Int:
      i, err := strconv.ParseInt(value, 10, 64)
      if err != nil {
         fmt.Println(err)
         return err
      }
      fieldValue.SetInt(i)
   case reflect.Uint:
      i, err := strconv.ParseUint(value, 10, 64)
      if err != nil {
         fmt.Println(err)
         return err
      }
      fieldValue.SetUint(i)
   case reflect.Float32:
      f, err := strconv.ParseFloat(value, 64)
      if err != nil {
         fmt.Println(err)
         return err
      }
      fieldValue.SetFloat(f)
   }
   return err
}

func MarshalFile(filename string,data interface{}) (err error){
   result,_ := Marshal(data)
   err = ioutil.WriteFile(filename,result,0666)
   return err
}
//反序列思路
//传入结构体->\[\]byte
//反射获取数据,转直接切片
func Marshal(data interface{}) (result \[\]byte, err error) {
   //获取类型
   typeInfo := reflect.TypeOf(data)
   valueInfo := reflect.ValueOf(data)
   if typeInfo.Kind() != reflect.Struct {
      return
   }
   var conf \[\]string
   for i := 0; i < typeInfo.NumField(); i++ {
      //取字段
      labelField := typeInfo.Field(i)
      //取值
      labelValue := valueInfo.Field(i)
      fieldType := labelField.Type
      //判断字段类型,如果不是struct,说明不对
      if fieldType.Kind() != reflect.Struct {
         continue
      }
      tagValue := labelField.Tag.Get("ini")
      if len(tagValue) == 0 {
         tagValue = labelField.Name
      }
      label := fmt.Sprintf("\\n\[%s\]\\n", tagValue)
      conf = append(conf, label)
      for j := 0; j < fieldType.NumField(); j++ {
         //这里的是大写的字段名
         keyField := fieldType.Field(j)
         //取tag
         fieldTagValue := keyField.Tag.Get("ini")
         if len(fieldTagValue) == 0 {
            fieldTagValue = keyField.Name
         }
         //取值
         valueField := labelValue.Field(j)
         item := fmt.Sprintf("%s = %v \\n", fieldTagValue, valueField.Interface())
         conf = append(conf, item)
      }
   }
   for _, val := range conf {
      byteVal := \[\]byte(val)
      result = append(result, byteVal...)
   }
   return
}

package main
import "fmt"
func main() {
   var conf Config
   _ = unMarshalFile("./config.ini", &conf)
   fmt.Printf("解析文件成功 config:%#v\\n port:%#v\\n", conf, conf.RedisConfig.Port)
   conf2 := Config{
      RedisConfig{Ip: "127.0.0.1", Port: 6379},
      MysqlConfig{Host: "127.0.0.1", User: "root", Password: "123456"},
   }
   _ = MarshalFile("1.ini", conf2)
   fmt.Printf("序列化文件成功\\n")
}