一种获取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 的方法了:

  1. 定义一个自己的 valueCtx 内部数据结构与 context 包中一致
  2. 通过 unsafe.Pointer() 绕过类型检测,强制将 context.valueCtx 转换成我们的 valueCtx
  3. 获取内部的值保存在 map 中

实践

首先自定义一个我们自己的 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 上找到,谢谢你的阅读。

发表评论

评论已关闭。

相关文章