go json数据转发

案例

例如，有个 GET 接口，可以批量获取用户信息👇

> curl 'http://localhost:8080/user/1,2'
[
    {
        "user_id":1,
        "other_suff":...
    },
    {
        "user_id":2,
        "other_suff":...
    }
]

同时，我们要将用户信息和他们的某些订单信息放在一起，组装成为👇的接口，满足其他业务需求。

[
    {
        "user_info":{
            "user_id":1,
            "other_suff":...
        },
        "order_info":{
            "order_id":1,
            "user_id":1,
            "other_suff":...
        }
    },
    {
        "user_info":{
            "user_id":2,
            "other_suff":...
        },
        "order_info":{
            "order_id":2,
            "user_id":2,
            "other_suff":...
        }
    }
]

分析

解决这个问题很简单：把user信息和order信息的json用工具解析得到结构体，然后调用他们的接口得到数据，根据id关联和拼装，最后返回。

这样的做法存在的一个问题是，代码解析了user和order的完整结构。如果user接口返回的用户信息增加了字段，我们这里的结构体要同步更新，否则我们给出的数据就是不完整的。（这可能是很痛苦的，你要求别的团队加字段，得排期...）

其实我们作为数据的“中间商”，只关心user接口json里的 user_id ，我们使用这个字段关联order数据。对于user信息里的 other_suff 或者其他数据，我们并不关心，只要保证完整传出去就好了。

根据 https://golang.org/pkg/encodi... ，可以知道直接丢一个 map[string]interface{} 给 json.Unmarshal 也可以正常解析的，于是我们可以写出比较通用的透传代码。

type Content []map[string]interface{}

func (c Content) GetByFieldName(name string, defaultVal interface{}) infterface{} {
    for _, item := range c {
        val, ok := item[name]
        if !ok {
            continue
        }
        if val == nil {
            return defaultVal
        }
        return val
    }
    return defaultVal
}

func getUserContentByIDs(ids []int) Content {
    ...
    var c Content
    err := json.Unmarshal(jsonData, &c) 
    ...
    return c
}

func getOrderContentByUserIDs(ids []int) Content {.../*同上*/}

func Handler(userIDs []int) []Combine {

    users := getUserContentByIDs(userIDs)
    orders := getOrderContentByUserIDs(userIDs)

    // 这里假设用户和订单是一对一的关系
    ret := make([]Combine, 0, len(users))
    for _, u := range users {
        userID := u.GetByFieldName("user_id", 0)
        if userID == 0 {
            continue
        }
        for _, o := range orders {
            orderUserID := o.GetByFieldName("user_id", 0)
            if userID == orderUserID {
                ret = append(ret, Combine{
                    UserInfo:  u,
                    OrderInfo: o,
                })
                break
            }
        }
    }
    return ret
}

更进一步

• 在上面的例子中，每次查询Content都要遍历数组。如果数据量大或者查询频繁，可以在初始化Content的时候，根据item的唯一标标识，再给Content根据封装一个map，提高查询效率。
• 从json包的文档可以看到，对于嵌套的结构，用 interface{} 解析以后就是嵌套的 map[string]interface{} , 例如

{
    "foo": "a",
    "bar": {
        "hello": "world",
        "good": "morning"
    }
}

如果用 map[string]interface{} 解析，得到的是map是

map[string]interface{} {
    "foo": "a",
    "bar": map[string]interface{} {
        "hello": "world",
        "good":  "morning"
    }
}

性能测试

Mackbook Pro 2015 Mid
2.2 GHz Intel Core i7
16 GB 1600 MHz DDR3

package main

import (
    "encoding/json"
    "github.com/tidwall/gjson"
    "math/rand"
    "strconv"
    "testing"
    "time"
)

type UserInfo struct {
    ID         int64     `json:"id"`
    FirstName  string    `json:"first_name"`
    LastName   string    `json:"last_name"`
    Age        int64     `json:"age"`
    Sex        string    `json:"sex"`
    CreateTime time.Time `json:"create_time"`
    UpdateTime time.Time `json:"update_time"`
    Department string    `json:"department"`
    Salary     string    `json:"salary"`
    Comment    string    `json:"comment"`
}

const testAmount = 1000

var testByte []byte

func TestMain(m *testing.M) {

    users := make([]UserInfo, testAmount)
    for i := 0; i < testAmount; i++ {
        users[i] = UserInfo{
            ID:         int64(i),
            FirstName:  "firstName",
            LastName:   "lastName",
            Age:        int64(i),
            Sex:        "sex",
            CreateTime: time.Now(),
            UpdateTime: time.Now(),
            Department: "departure",
            Salary:     "salary",
            Comment:    "comment",
        }
    }
    var err error
    testByte, err = json.Marshal(&users)
    if err != nil {
        return
    }

    m.Run()
}

func BenchmarkStdParseAllQueryMap(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var users []UserInfo
        _ = json.Unmarshal(testByte, &users)
        valMap := make(map[int64]UserInfo, len(users))
        for i := range users {
            valMap[users[i].ID] = users[i]
        }
        for i := 0; i < testAmount; i++ {
            _ = valMap[rand.Int63n(testAmount)]
        }
    }
}

func BenchmarkStdParseAllQueryFor(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var users []UserInfo
        _ = json.Unmarshal(testByte, &users)
        for i := 0; i < testAmount; i++ {
            query := rand.Int63n(testAmount)
            for i := range users {
                if users[i].ID == query {
                    break
                }
            }
        }
    }
}

func BenchmarkStdParseMapQueryMap(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var users []map[string]interface{}
        _ = json.Unmarshal(testByte, &users)
        valMap := make(map[string]interface{}, len(users))
        for i := range users {
            valMap[strconv.Itoa(int(users[i]["id"].(float64)))] = users[i]
        }
        for i := 0; i < testAmount; i++ {
            _ = valMap[strconv.Itoa(rand.Intn(testAmount))]
        }
    }
}

func BenchmarkStdParseMapQueryFor(b *testing.B) {
    for n := 0; n < b.N; n++ {
        var users []map[string]interface{}
        _ = json.Unmarshal(testByte, &users)
        for i := 0; i < testAmount; i++ {
            query:= rand.Int63n(testAmount)
            for i := range users {
                id := int64(users[i]["id"].(float64))
                if query == id {
                    break
                }
            }
        }
    }
}

func BenchmarkGJson(b *testing.B) {
    for n := 0; n < b.N; n++ {
        j := gjson.ParseBytes(testByte)
        for i := 0; i < testAmount; i++ {
            query := strconv.Itoa(rand.Intn(testAmount))
             _ = j.Get("#(id=" + query + ")").String()
        }
    }
}

结果

const testAmount = 10


const testAmount = 100

const testAmount = 1000

结论：使用map解析的性能，比完全解析的性能会差一些，大概慢了50%，内存多了100%以上。
另外，使用github.com/tidwall/gjson的通用json查询包，在数据量少的时候性能优异，但随着数据量变大，速度急剧下降，内存占用上升不多。