golang实现输入json字符串生成struct

根据reflect包实现，解析json字符串，打印出结构体；

如json字符串：

{
  "DbSettings": [{
    "host": "127.0.0.1",
    "port": 3306,
    "password":"123456",
    "dbname":"Demo"
  }],
  "AesKey": "Here store a aes key",
  "tlist":["a", "b","c"]
}

打印出所有结构体：

结果：

type A struct {
DbSettings    []ADbSettings    `json:"DbSettings"`
AesKey    string    `json:"AesKey"`
Tlist    []string    `json:"tlist"`
}

type ADbSettings struct {
Password    string    `json:"password"`
Dbname    string    `json:"dbname"`
Host    string    `json:"host"`
Port    float64    `json:"port"`
}

// 大写首字母
func FirstToUpper(s string) string {
   runes := []rune(s)
   return strings.ToUpper(string(runes[0])) + string(runes[1:])
}
// 驼峰转下划线
func humpToUnderline(s string) string {
   data := make([]byte, 0, len(s)*2)
   j := false
   num := len(s)
   for i := 0; i < num; i++ {
      d := s[i]
      // or通过ASCII码进行大小写的转化
      // 65-90（A-Z），97-122（a-z）
      //判断如果字母为大写的A-Z就在前面拼接一个_
      if i > 0 && d >= 'A' && d <= 'Z' && j {
         data = append(data, '_')
      }
      if d != '_' {
         j = true
      }
      data = append(data, d)
   }
   return strings.ToLower(string(data[:]))
}

// 打印结构体
func generateStruct(data interface{}, structName string) {
   structName = FirstToUpper(structName)
   v := reflect.ValueOf(data)
   var buffer bytes.Buffer
   buffer.WriteString("type ")
   buffer.WriteString(structName)
   buffer.WriteString(" struct {\n")
   switch v.Kind() {
   case reflect.Slice, reflect.Array:
      vslice := data.([]interface{})
      if len(vslice) > 0 {
         switch reflect.ValueOf(vslice[0]).Kind() {
         case reflect.Map, reflect.Slice, reflect.Array:
            sname := fmt.Sprintf("%s%s", structName, "List")
            generateStruct(vslice[0], sname)
            buffer.WriteString("[]" + sname)
         default:
            buffer.WriteString("[]" + reflect.ValueOf(vslice[0]).Kind().String())
         }

      }
   case reflect.Map:
      for k, m := range data.(map[string]interface{}) {
         buffer.WriteString(FirstToUpper(k))
         buffer.WriteString("\t")
         switch reflect.ValueOf(m).Kind() {
         case reflect.Array, reflect.Slice:
            vslice := m.([]interface{})
            if len(vslice) > 0 {
               switch reflect.ValueOf(vslice[0]).Kind() {
               case reflect.Map, reflect.Slice, reflect.Array:
                  sname := fmt.Sprintf("%s%s", structName, k)
                  generateStruct(vslice[0], sname)
                  buffer.WriteString("[]" + sname)
               default:
                  buffer.WriteString("[]" + reflect.ValueOf(vslice[0]).Kind().String())
               }
            }
         case reflect.Map:
            vtype := fmt.Sprintf("%s%s", structName, k)
            generateStruct(m, vtype)
            buffer.WriteString(vtype)
         default:
            buffer.WriteString(reflect.ValueOf(m).Kind().String())
         }
         buffer.WriteString("\t`json:\"")
         buffer.WriteString(humpToUnderline(k))
         buffer.WriteString("\"`")
         buffer.WriteString("\n")
      }
   }
   buffer.WriteString("}")
   buffer.WriteString("\n")
   fmt.Println(buffer.String())
   fmt.Println("\n")
}

func main(){

    s := `{
  "DbSettings": [{
    "host": "127.0.0.1",
    "port": 3306,
    "password":"123456",
    "dbname":"Demo"
  }],
  "AesKey": "Here store a aes key",
  "tlist":["a", "b","c"]
}
`

var rs interface{}
err := json.Unmarshal([]byte(s), &rs)
if err != nil{
   fmt.Println(err.Error())
}
generateStruct(rs, "a")

}