玩转golang——JSON高性能自动字段名

type Student struct {
    Name      string `json:"name"`
    MathScore int    `json:"math_score"`
    StudentNO string `json:"student_no"`
}

func MyMarshal(obj interface{}) (b []byte, e error) {
    b, e = json.Marshal(obj)
    if e != nil {
        return 
    }
    var m map[string]interface{}
    e = json.Unmarshal(b, &m)
    if e != nil {
        return 
    }
    HandleMapStyle(m)
    return json.Marshal(m)
}

func HandleMapStyle(m map[string]interface{}) {
    for key, value := range m {
        switch v := value.(type) {
        case []interface{}:
            for i := range v {
                if elem, ok := v.(map[string]interface{}); ok {
                    HandleMapStyle(elem)
                }
            }
        case map[string]interface{}:
            HandleMapStyle(v)
        }
        delete(m, key)
        m[strings.ToLower(key)] = value        //此处简化处理, 全变小写
    }
}

import "github.com/fatih/structs"
func MyMarshal(obj interface{}) (b []byte, e error) {
    m := structs.Map(obj)
    HandleMapStyle(m)
    return json.Marshal(m)
}

func MyStruct(t reflect.Type) reflect.Type {
    if t.Kind() != reflect.Struct {
        panic("invalid type")
    }   
    fs := make([]reflect.StructField, t.NumField())
    for i := 0; i < t.NumField(); i++ {
        f := t.Field(i)
        fs[i] = f 
        // 目前不考虑其他tag
        if f.Tag.Get("json") == "" {
            fs[i].Tag = reflect.StructTag(`json:"` + strings.ToLower(f.Name) + `"`)
        }   
        var ftype reflect.Type
        switch f.Type.Kind() {
        case reflect.Struct:
            ftype = MyStruct(f.Type)
        case reflect.Slice:
            if f.Type.Elem().Kind() == reflect.Struct {
                ftype = reflect.SliceOf(MyStruct(f.Type.Elem()))
            } else if f.Type.Elem().Kind() == reflect.Slice {
                panic("multi-d slice not supported") //多维数组暂不考虑
            }   
        default: //样例暂中不考虑Ptr/Map/Array等场景, 处理方式类似
            ftype = f.Type
        }   
        fs[i].Type = ftype
    }   
    return reflect.StructOf(fs)
}

type Person struct {
    Name   string
    Age    int 
    Avatar struct {
        Url    string
        Height int 
        Width  int 
    }   
}

func main() {
    fmt.Println(MyStruct(reflect.TypeOf(Person{})))
}

struct { 
    Name string "json:\"name\""
    Age int "json:\"age\""
    Avatar struct { 
        Url string "json:\"url\""; 
        Height int "json:\"height\""; 
        Width int "json:\"width\"" 
    } "json:\"avatar\"" 
}

type Node struct {
    V int
    Next *Node
}

myStruct := MyStruct(Person{})
//然后咋写？

//一般而言要这么用
inst := reflect.New(myStruct)
inst.Elem().FieldByName("Name").SetString("大福加冰")
inst.Elem().FieldByName("Avatar").FieldByName("Height").SetInt(1080)
json.Marshal(inst.Interface())

p := Person{
    Name: "大福加冰",
    Age: 29,
}
myPerson := MyStruct(p)
dynP := reflect.NewAt(myPerson, unsafe.Pointer(&p))

// 入参src必须是对象指针，不然只能copy一遍对象内存
// 此处只考虑对象指针的情况(如非指针, sv.Pointer()会panic)
func TypeConvert(src interface{}, dstType reflect.Type) interface{} {
    sv := reflect.ValueOf(src)
    return reflect.NewAt(dstType, sv.Pointer()).Interface()
}

p := Person{}
json.Marshal(DynamicInstance(p, myStruct))

dp := reflect.New(myStruct)
json.Unmarshal(buffer, dp.Interface())
pIntf := TypeConvert(dp.Interface(), reflect.TypeOf(Person{}))
var p *Person
p = pIntf.(*Person)
//到这里 才能获得原始Person对象, 供代码使用

import (
    . "unsafe"
    . "reflect"
)
type emptyInterface struct {
    pt Pointer
    pv Pointer
}
func PointerOfType(t Type) Pointer {
    p := *(*emptyInterface)(Pointer(&t))
    return p.pv
}
func TypeCast(src interface{}, dstType Type) (dst interface{}) {
    srcType := TypeOf(src)
    eface := *(*emptyInterface)(Pointer(&src))
    if srcType.Kind() == Ptr {
        eface.pt = PointerOfType(PtrTo(dstType))
    } else {
        eface.pt = PointerOfType(dstType)
    }
    dst = *(*interface{})(Pointer(&eface))
    return
}

package main

import (
    "encoding/json"
    "fmt"
    . "github.com/dovejb/quicktag"
    "reflect"
)

type Person struct {
    Name       string
    Age        int 
    MyChildren []Person
}

func main() {
    p := Person{
        Name: "dovejb",
        Age:  6,  
        MyChildren: []Person{
            Person{
                Name: "baby",
                Age:  3,  
            },  
        },  
    }   

    var p2 Person

    buf, _ := json.Marshal(Q(p))
    fmt.Println(string(buf))
    // {"name":"dovejb","age":6,"my_children":[{"name":"baby","age":3,"my_children":null}]}

    json.Unmarshal(buf, Q(&p2))
    fmt.Println(reflect.DeepEqual(p, p2))
    // true
}

import "github.com/dovejb/quicktag"
import "time"

func init() {
    // 自定义转换风格, 默认quicktag.PascalToUnderline, 无omitempty
    quicktag.StyleConvert = MyStyleConvertFunc // func(string) string
    // 自定义受影响业务tag, 默认 []string{"json","bson"}
    quicktag.TagNames = []string{"json", "bson"}
    // 自定义自引用最大层级, 默认5
    quicktag.MaxSelfRefLevel = 3
    
    // 注意！！！
    // 如果某类型自己包含了MarshalJSON/UnmarshalJSON等方法，如time.Time，请在字段后手动添加quicktag:"-"来跳过
    // 如
    data := struct {
        ID string `bson:"_id"`
        CreatedTime time.Time `quicktag:"-"`
    }
    
    // struct中原有的tag, 均会保留
}

root@dev:/w/try# go test github.com/dovejb/quicktag -bench=.
goos: linux
goarch: amd64
pkg: github.com/dovejb/quicktag
BenchmarkQMarshal-4              1000000              1343 ns/op
BenchmarkJsonMarshal-4           1000000              1565 ns/op
PASS
ok      github.com/dovejb/quicktag      3.936s
root@dev:/w/try# go test github.com/dovejb/quicktag -bench=.
goos: linux
goarch: amd64
pkg: github.com/dovejb/quicktag
BenchmarkQMarshal-4              1000000              1635 ns/op
BenchmarkJsonMarshal-4           1000000              2024 ns/op
PASS
ok      github.com/dovejb/quicktag      3.714s