当前位置 博文首页 > r1chard：一种获取context中keys和values的高效方法 | golang
我们知道，在 golang 中的 context 是一个非常重要的包，保存了代码活动的上下文。我们经常使用 WithValue() 这个方法，来往 context 中 传递一些 key value 数据。
如果我们想拿到 context 中所有的 key and value 或者在不知道 key 的情况想获得value 要怎么做呢？这里提供一个比较hacker的实现给大家参考。
首先，看看WithValue到底发生了什么：
package context
func WithValue(parent Context, key, val interface{}) Context {
return &valueCtx{parent, key, val}
}
// A valueCtx carries a key-value pair. It implements Value for that key and
// delegates all other calls to the embedded Context.
type valueCtx struct {
Context
key, val interface{}
}
WithValue 通过把 key value 塞到了 valueCtx 的 struct 中，将数据保存下来。
通过研究 context 包我们发现，不同的 功能的context有不同的实现
package context
// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
// implement Done and Err. It implements cancel by stopping its timer then
// delegating to cancelCtx.cancel.
type timerCtx struct {
cancelCtx
timer *time.Timer // Under cancelCtx.mu.
deadline time.Time
}
// A cancelCtx can be canceled. When canceled, it also cancels any children
// that implement canceler.
type cancelCtx struct {
Context
mu sync.Mutex // protects following fields
done chan struct{} // created lazily, closed by first cancel call
children map[canceler]struct{} // set to nil by the first cancel call
err error // set to non-nil by the first cancel call
}
但无一例外，全部是私有 struct ，同时是通过链表的形式将各个 context 串在一起的。
这种情况对与我们想要做的事情是比较不好的，我们无法将 context 接口转换成实现来获取其内部保存的 key and value，而且由于有多种实现，我们无法得知下一个 context 是不是 valueCtx，需不需要跳过。
既然这样，我们就只能用一些比较 hacker 的方法了：
首先自定义一个我们自己的 valueCtx ，直接照搬 context 的实现就行：
package main
type valueCtx struct {
context.Context
key, val interface{}
}
然后强转并打印：
package main
func main() {
ctx := context.Background()
ctx = context.WithValue(ctx, "key1", "value1")
valCtx := (*valueCtx)(unsafe.Pointer(&ctx))
fmt.Printf("key: %v, value: %v", valCtx.key, valCtx.val)
// panic: runtime error: invalid memory address or nil pointer dereference
}
事情并没有按我们预想的发生，这在编程的过程中再常见不过了，一定是有什么不对。在这种时候我们就应该去翻阅资料，去搞懂我们还模糊的部分，就会找到原因。不过，既然是文章，我就直接写我的结论了。
这个要从接口类型的实现说起，golang 的接口的概念和实现是比较具体和复杂的，如果想进一步深入，请参阅这篇Stefno的文章，其非常深入和详细的讲解了 golang 中接口的方方面面。好了，回到我们的问题，现在对于 golang 的接口，我们只需要知道：在 golang 的接口里保存两个东西，其一是接口所持有的动态类型，其二是动态类型的值。
结构如下：
type iface struct {
itab, data uintptr
}
也就是说，当我们在转换接口的时候，其实是再把上面的结构强转为 valueCtx ，但其实我们期望的数据应该是保存在接口的动态类型值里，因此我们应该强转的是 iface.data。
要做到这点，我们就需要将 context 先转换成 iface，再获取其中的 data：
package main
type iface struct {
itab, data uintptr
}
type valueCtx struct {
context.Context
key, val interface{}
}
func main() {
ctx := context.Background()
ctx = context.WithValue(ctx, "key1", "value1")
ictx := (*iface)(unsafe.Pointer(&ctx))
valCtx := (*valueCtx)(unsafe.Pointer(ictx.data))
fmt.Printf("key: %v, value: %v", valCtx.key, valCtx.val)
// output:
// key: key1, value: value1
}
这回，我们终于获得其中的数据了。
接下来，我们需要把 context 中的所有 key value 获取出来：
package main
func GetKeyValues(ctx context.Context) map[interface{}]interface{} {
m := make(map[interface{}]interface{})
getKeyValue(ctx, m)
return m
}
func getKeyValue(ctx context.Context, m map[interface{}]interface{}) {
ictx := *(*iface)(unsafe.Pointer(&ctx))
if ictx.data == 0 {
return
}
valCtx := (*valueCtx)(unsafe.Pointer(ictx.data))
if valCtx != nil && valCtx.key != nil && valCtx.val != nil {
m[valCtx.key] = valCtx.val
}
getKeyValue(valCtx.Context, m)
}
通过递归调用，我们可以很轻松的遍历所有 context，同时 golang 中的 nil 在底层其实就是一个int的0，这就是为什么我们把 nil 叫做 零值。所以，递归的退出条件也很简单，就是当 iface 中的 data 为0时，说明我们已经查找到 context 中的最后一个了。
好了，以上就是所有的内容了，如果你想获取文章的具体实现和 demo 示例，可以到我的 github 上找到，谢谢你的阅读。
