/
encoder.go
273 lines (207 loc) · 5.18 KB
/
encoder.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
package data
import (
"encoding/json"
"fmt"
"reflect"
)
// Encoder 用来将数据转化成 Data。
type Encoder struct {
TagName string // 在解析 struct 时候使用的 field tag,默认是 data。
OmitEmpty bool // 如果为 true,则默认所有字段都会忽略空值。
}
// Encode 将任意的 Go 类型转化成 Data。
//
// 需要注意,只有以下类型可以成功转化成 Data,如果 v 不是这些类型,Encode 会返回 nil。
// - Go struct 和 struct 指针;
// - 任意的 map[string]T 类型,T 可以是任意的类型。
func (enc *Encoder) Encode(v interface{}) Data {
if v == nil {
return emptyData
}
val := reflect.ValueOf(v)
t := val.Type()
for kind := t.Kind(); kind == reflect.Ptr || kind == reflect.Interface; kind = t.Kind() {
t = t.Elem()
val = val.Elem()
}
d := enc.encodeValue(val)
return Data{
data: d,
}
}
func (enc *Encoder) encodeValue(val reflect.Value) RawData {
switch val.Kind() {
case reflect.Map:
return enc.encodeMap(val)
case reflect.Struct:
return enc.encodeStruct(val)
}
return nil
}
func (enc *Encoder) encodeMap(val reflect.Value) RawData {
t := val.Type()
if t.Key().Kind() != reflect.String {
return nil
}
d := RawData{}
if val.Len() == 0 {
return nil
}
iter := val.MapRange()
for iter.Next() {
k := iter.Key()
v := iter.Value()
d[k.String()] = enc.encodeMapValue(v)
}
return d
}
func (enc *Encoder) encodeStruct(val reflect.Value) RawData {
d := RawData{}
enc.encodeStructToData(val, d)
return d
}
func (enc *Encoder) encodeStructToData(val reflect.Value, d RawData) {
if val.Type().AssignableTo(typeOfData) {
merge(reflect.ValueOf(d), val.Convert(typeOfData).Interface().(Data).data)
return
}
t := val.Type()
l := t.NumField()
for i := 0; i < l; i++ {
f := t.Field(i)
tagName := enc.TagName
if tagName == "" {
tagName = defaultTagName
}
tag := f.Tag.Get(tagName)
ft := ParseFieldTag(tag)
if ft.Skipped {
continue
}
k := f.Name
if ft.Alias != "" {
k = ft.Alias
}
fv := val.Field(i)
v := enc.encodeMapValue(fv)
if (ft.OmitEmpty || enc.OmitEmpty) && isEmpty(v) {
continue
}
// 如果需要合并字段,且 v 是一个 Data,那么会将 v 内容浅拷贝到 d 里面。
if ft.Squash {
if data, ok := v.(RawData); ok {
for k, v := range data {
d[k] = v
}
continue
}
}
d[k] = v
}
}
func isEmpty(v interface{}) bool {
if v == nil {
return true
}
val := reflect.ValueOf(v)
if val.IsZero() {
return true
}
switch val.Kind() {
case reflect.Map, reflect.Slice:
return val.Len() == 0
}
return false
}
func (enc *Encoder) encodeMapValue(val reflect.Value) interface{} {
if !val.IsValid() {
return nil
}
switch val.Type() {
case typeOfTime:
return val.Interface()
case typeOfDuration:
if val.Int() == 0 {
return ""
}
return val.Interface().(fmt.Stringer).String()
}
switch val.Kind() {
// 由于需要保持 Data 结构在序列化和反序列化的时候内容稳定,所以将所有的基础类型都统一成最大的类型。
// 例如所有的 int* 都变成 int64。
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return val.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return val.Uint()
case reflect.Float32, reflect.Float64:
return val.Float()
case reflect.Complex64, reflect.Complex128:
return val.Complex()
case reflect.Invalid:
return nil
case reflect.String:
// 需要特别的支持 json.Number,将这种字符串变成数字。
if num, ok := val.Interface().(json.Number); ok {
i64, err := num.Int64()
if err == nil {
return i64
}
f64, err := num.Float64()
if err == nil {
return f64
}
// 如果不是合法的数字,将这个类型还原成普通的 string。
return string(num)
}
case reflect.Array, reflect.Slice:
l := val.Len()
sliceType := reflect.SliceOf(toLargestType(val.Type().Elem()))
values := reflect.MakeSlice(sliceType, l, l)
for i := 0; i < l; i++ {
v := enc.encodeMapValue(val.Index(i))
values.Index(i).Set(reflect.ValueOf(v))
}
return values.Interface()
case reflect.Interface, reflect.Ptr:
val = val.Elem()
return enc.encodeMapValue(val)
case reflect.Map:
t := val.Type()
kt := t.Key()
if k := kt.Kind(); k != reflect.String {
return val.Interface()
}
d := RawData{}
if val.Len() == 0 {
return d
}
iter := val.MapRange()
for iter.Next() {
k := iter.Key()
v := iter.Value()
d[k.String()] = enc.encodeMapValue(v)
}
return d
case reflect.Struct:
return enc.encodeStruct(val)
case reflect.Chan, reflect.Func, reflect.UnsafePointer:
// 这些类型不是数据。
return nil
}
return val.Interface()
}
func toLargestType(t reflect.Type) reflect.Type {
switch t.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return typeOfInt64
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return typeOfUint64
case reflect.Float32, reflect.Float64:
return typeOfFloat64
case reflect.Complex64, reflect.Complex128:
return typeOfComplex128
case reflect.Struct:
return typeOfObject
}
return t
}