Go基于反射实现任意结构json值的替换

最近面临一个应用场景，需要对一个倒手转发的json进行数据替换，查阅了众多的库，大部分都不支持这个功能，从历史项目里捞出了jsonpath这个库，但其只能根据jsonpath的schema进行Get操作，无法实现inplace回写，后来又找到sjson，这是个根据jsonpath回写的库，没有用反射，自己实现的parser，但是在数组、对象混合嵌套的结构中，没办法正确写入，因为在使用gjson提取值之后，已经丢失了原始路径信息。在经过一番折腾之后，还是决定自己写一个替换器，虽然反射效率会比较低，但是好歹能实现。

需求

先抛弃jsonpath的思路，第一版先从简单的开始，期望替换库具备以下功能

• 可以根据给定的key名，替换所有该key名下的value
• 可以根据给定的key值类型，替换所有该类型的value
• 以上三种方式的组合
• 可以控制替换的深度

举例来说，
case1：对于下面这个json，

{
    "name1": "Bob",
    "name2": "Alice"
}

可以通过指定key=name2，将Alice增加一个前缀

{
    "name1": "Bob",
    "name2": "hello Alice"
}

case2：对于下面的json，指定替换字符串类型，并控制替换深度为2

{
    "name1": "Bob",
    "tag1": {
        "name2": "Dave",
        "tag2": {
            "name3": "Alice"
        }
    }
}

替换后为

{
    "name1": "hello Bob",
    "tag1": {
        "name2": "hello Dave",
        "tag2": {
            "name3": "Alice"
        }
    }
}

思路

由于json结构未知，无法直接Unmarshal为确定的结构，所以将json文档Unmarshal为map[string]interface{}进行解析。
由于json的深度未知，遂通过递归的方式，逐级遍历完成替换。

实现

数据结构

声明一个结构replacer，用于表示替换过程，其结构如下：

type replacer struct {
	maxDepth int                           // 最大递归替换深度，如果为0，表示不限制递归深度
	kind     reflect.Kind                  // 匹配的字段类型，如果未reflect.Invalid，表示不关心类型
	keyword  []string                      // 匹配的Key名，如果未指定即为nil，则仅做类型匹配
	replacer func(interface{}) interface{} // 替换器

	currDepth int // 当前递归深度
}

前三个字段，对应了需求中的约束条件，如果kind和keyword都为默认值，则所有值都将被替换；replacer是自定义替换函数，符合约束条件的值将会通过replacer调用传递给使用者，由使用者完成自定替换过程。currDepth为递归深度控制变量。

预处理

func (r replacer) Replacing(content []byte) ([]byte, error) {
	// 校验是否合法json
	if !json.Valid(content) {
		return nil, errors.New("invalid json")
	}

	// 反序列化json，兼容root为对象或数组的场景
	var holder interface{}
	if content[0] == '{' {
		holder = map[string]interface{}(nil)
	} else if content[0] == '[' {
		holder = []interface{}(nil)
	}

	err := json.Unmarshal(content, &holder)
	if err != nil {
		return nil, err
	}

	// 遍历/替换过程
	return json.Marshal(r.replacingElements("", holder))
}

输入的json为未知结构，所以首先对json合法性进行判断，将json反序列化为interface based结构。
替换的关键逻辑由replacingElements方法实现，并将替换后的json内容序列化为字符串返回。

替换逻辑

先来看一下replacingElements的伪代码

func replacingElements(key string, value interface{})interface{}{
    // 1.判断深度，达到递归深度则结束递归

    // 2.获取value的类型信息

    // 3.如果是值类型（字符串、数字、布尔），判断是否为指定的kind，且key是否为期望的key，如果是，则替换并回写
    // 4.如果是数组类型，遍历数组成员，对成员进行replaceElements递归调用
    // 5.如果是对象类型，遍历对象下的成员，对成员进行replaceElements递归调用
    // 6.如果没有指定的kind，则默认将所有kv都进行替换

    // 7.返回替换后的文档
}

深度判断

func (r replacer) deepEnough() bool {
	// 如果maxDepth为0，表示不限制递归深度，总返回false
	// 如果maxDepth大于0，且当前深度没有达到maxDepth，则返回false
	// 否则返回true
	return r.maxDepth != 0 && r.currDepth > r.maxDepth
}

是否为待替换key的判定

func (r replacer) needReplace(key string) bool {
	// 如果使用者没有指定keyword，那么总是返回true，表示不需要区分key
	if r.keyword == nil || len(r.keyword) == 0 {
		return true
	}
	// 查看当前key是否是使用者指定的key集合中的一个
	for _, v := range r.keyword {
		if v == key {
			return true
		}
	}
	return false
}

Number类型值处理

json中Number可以表达所有的数字，包括整形、无符号数、浮点数等。而在go中，对Number类型的反射，总是解释为float64类型，如果需要匹配使用者期望的kind，则需要对类型进行转化，实现如下

func (r replacer) convertArbitraryNumber(n interface{}, expect reflect.Kind) interface{} {
	// 获取以float64表达的json Number类型值
	rn, ok := n.(float64)
	if !ok {
		return n
	}

	// 将以float64表达的Number转换为目标类型，目标类型由使用者指定
	switch expect {
	case reflect.Float32:
		return float32(rn) // precision lost, cut off
	case reflect.Int:
		return int(rn) // precision lost
	case reflect.Int8:
		return int8(rn) // cut off
	case reflect.Int16:
		return int16(rn) // cut off
	case reflect.Int32:
		return int32(rn) // cut off
	case reflect.Int64:
		return int64(rn) // precision lost
	case reflect.Uint:
		return uint(rn) // cut off, sign lost
	case reflect.Uint8:
		return uint8(rn) // cut off, sign lost
	case reflect.Uint16:
		return uint16(rn) // cut off, sign lost
	case reflect.Uint32:
		return uint32(rn) // cut off, sign lost
	case reflect.Uint64:
		return uint64(rn) // precision lost, sign lost
	}
	return rn
}

需要注意float64转换为指定类型时，可能会有精度丢失、符号丢失的问题，所以最好是对替换目标值的类型心里有数。

替换过程

这里是json替换的核心逻辑

func (r replacer) replacingElements(key string, value interface{}) interface{} {
	// 递归深度判断
	if r.deepEnough() {
		return value
	}

	// 反射获取value的类型信息
	vt := reflect.TypeOf(value)
	k := vt.Kind()

	// 根据kind分别处理
	switch k {
	case r.kind: // 是期望的值类型
		if r.needReplace(key) {
			// 当前key是目标key集合中的内容
			return r.replacer(value)
		}
	case reflect.Slice:
		// 获得slice的value
		val := reflect.ValueOf(value)
		r.currDepth++ // increace depth
		for i := 0; i < val.Len(); i++ {
			// 遍历slice
			elem := val.Index(i)
			if elem.CanInterface() {
				// 将成员递归处理
				relem := r.replacingElements(key, elem.Interface())
				if elem.CanSet() {
					elem.Set(reflect.ValueOf(relem))
				}
			}
		}
	case reflect.Map:
		val, ok := value.(map[string]interface{})
		if ok {
			r.currDepth++ // increace depth
			for mkey, mval := range val {
				// 将成员递归处理
				val[mkey] = r.replacingElements(mkey, mval)
			}
		}
	default:
		if k == reflect.Float64 && (r.kind >= reflect.Int && r.kind <= reflect.Float32) {
			// for arbitrary numberic types, adjust underlying type to expected
			if r.needReplace(key) {
				// 这里调用convertArbitraryNumber对float64进行了转换，确保使用者在对value进行断言时
				// 可以获得自己在replacer.kind成员上指定的类型值
				return r.replacer(r.convertArbitraryNumber(value, r.kind))
			}
		} else if r.kind == reflect.Invalid {
			// 对于任意类型的值，不判断value的类型
			if r.needReplace(key) {
				return r.replacer(value)
			}
		}
	}
	return value
}

接口化

这里借鉴了我之前在《redis分布式锁与redsync库源码分析》中提到的可变参Option的技巧

func NewReplacer(replaceFunc func(interface{}) interface{}, options ...Option) IReplacer {
	r := new(replacer)
	for _, v := range options {
		v.Apply(r)
	}
	r.replacer = replaceFunc
	return r
}

type Option interface {
	Apply(*replacer)
}

type OptionFunc func(*replacer)

func (f OptionFunc) Apply(r *replacer) {
	f(r)
}

func WithMaxDepth(n int) Option {
	return OptionFunc(func(r *replacer) {
		r.maxDepth = n
	})
}

func WithKind(k reflect.Kind) Option {
	return OptionFunc(func(r *replacer) {
		r.kind = k
	})
}

func WithKeyword(k string) Option {
	return OptionFunc(func(r *replacer) {
		if r.keyword == nil {
			r.keyword = make([]string, 0, 1)
		}
		r.keyword = append(r.keyword, k)
	})

}

func WithKeywords(k []string) Option {
	return OptionFunc(func(r *replacer) {
		if r.keyword == nil {
			r.keyword = make([]string, 0, 1)
		}
		r.keyword = append(r.keyword, k...)
	})
}

type IReplacer interface {
	Replacing([]byte) ([]byte, error)
}

使用起来就很简单，示例如下：

replaceFunc := func(i interface{}) interface{} {
	val, ok := i.(string)
	if ok {
		return "hello " + val
	}
	return i
},
r := NewReplacer(replaceFunc, WithKind(reflect.String), WithKeyword("name"))
ret := r.Replacing([]byte(`{"name1":"Bob","name2":"Alice"}`))
fmt.Println(string(ret))	// {"name1":"hello Bob","name2":"hello Alice"}

这样，一个基于反射的json值替换器就实现完了。

结语

这个是一次对反射功能的实践，目的是加深对go反射的理解。从性能角度来讲，大概率是不如gjson/sjson这种基于文本parser的实现的。不过重点在于对反射原则的理解，能不能取用您自己看着办吧。