GoFrame 如何优雅的共享变量 | Context的使用

简介: 今天就为大家介绍一下Context的使用,告诉大家Context是什么?怎么用?为什么要用Context以及使用中的小技巧和注意问题。

Context是什么?


Context指的是标准库的context.Context,是一个接口对象,常用于异步IO控制以及上下文流程变量的传递。

本文将要介绍的是Context如何优雅的在业务流程中进行变量的传递,以及为什么需要要进行变量的传递。


为什么需要Context?


Go的执行流程中,特别是HTTP/RPC执行流程中,没有通过”全局变量”获取请求参数的方式,只能通过上下文Context变量,传递到后续执行流程的方法中。


如何使用?


Context上下文变量,即包含了所有需要传递的共享变量。

并且该Context中的共享变量是事先约定的,并且往往存储为对象指针形式。

通过Context上下文共享变量非常简单,下面通过示例带大家了解一下如何传递和使用通用的共享变量。


一、结构定义


上下文对象中往往存储一些需要共享的变量,这些变量通常使用结构化的对象来存储,以方便维护。

例如,我们在model定义一个上下文中的共享变量:


const (
  // 上下文变量存储键名,前后端系统共享
  ContextKey = "ContextKey"
)
// 请求上下文结构
type Context struct {
  Session *ghttp.Session // 当前Session管理对象
  User    *ContextUser   // 上下文用户信息
  Data    g.Map          // 自定KV变量,业务模块根据需要设置,不固定
}
// 请求上下文中的用户信息
type ContextUser struct {
  Id       uint   // 用户ID
  Passport string // 用户账号
  Nickname string // 用户名称
  Avatar   string // 用户头像
}


介绍


  1. model.ContextKey常量表示存储在context.Context上下文变量中的键名,该键名用于从传递的context.Context变量中存储/获取业务自定义的共享变量。
  2. model.Context结构体中的Session表示当前请求的Session对象,在GoFrame框架中每个HTTP请求对象中都会有一个空的Session对象,该对象采用了懒初始化设计,只有在真正执行读写操作时才会初始化。
  3. model.Context结构体中的User表示当前登录的用户基本信息,只有在用户登录后才有数据,否则是nil
  4. model.Context结构体中的Data属性用于存储自定义的KV变量,因此一般来说开发者无需再往context.Context上下文变量中增加自定义的键值对,而是直接使用model.``Context对象的这个Data属性即可。


二、逻辑封装


由于该上下文对象也是和业务逻辑相关的,因此我们需要通过service对象将上下文变量封装起来以方便其他模块使用。


// 上下文管理服务
var Context = new(contextService)
type contextService struct{}
// 初始化上下文对象指针到上下文对象中,以便后续的请求流程中可以修改。
func (s *contextService) Init(r *ghttp.Request, customCtx *model.Context) {
  r.SetCtxVar(model.ContextKey, customCtx)
}
// 获得上下文变量,如果没有设置,那么返回nil
func (s *contextService) Get(ctx context.Context) *model.Context {
  value := ctx.Value(model.ContextKey)
  if value == nil {
    return nil
  }
  if localCtx, ok := value.(*model.Context); ok {
    return localCtx
  }
  return nil
}
// 将上下文信息设置到上下文请求中,注意是完整覆盖
func (s *contextService) SetUser(ctx context.Context, ctxUser *model.ContextUser) {
  s.Get(ctx).User = ctxUser
}


Tips


在架构设计中,在哪个场景下设置Context是非常关键的。

上下文的变量必须在请求一开始便注入到请求流程中,以便于其他方法调用,所以在中间件中来实现是非常优雅的选择。

我们来看下面的介绍:


三、上下文变量注入


HTTP请求中我们可以使用GoFrame的中间件来实现。

GRPC请求中我们也可以使用拦截器来实现。

service层的middleware管理对象中,我们可以这样来定义:


// 自定义上下文对象
func (s *middlewareService) Ctx(r *ghttp.Request) {
  // 初始化,务必最开始执行
  customCtx := &model.Context{
    Session: r.Session,
    Data:    make(g.Map),
  }
  service.Context.Init(r, customCtx)
  if userEntity := Session.GetUser(r.Context()); userEntity != nil {
    customCtx.User = &model.ContextUser{
      Id:       userEntity.Id,
      Passport: userEntity.Passport,
      Nickname: userEntity.Nickname,
      Avatar:   userEntity.Avatar,
    }
  }
  // 将自定义的上下文对象传递到模板变量中使用
  r.Assigns(g.Map{
    "Context": customCtx,
  })
  // 执行下一步请求逻辑
  r.Middleware.Next()
}


这个中间件初始化了用户执行流程共享的对象,并且存储到context.Context变量中的对象是指针类型*model.Context

这样做的好处是:任何一个地方获取到这个指针,不仅可以获取到里面的数据,而且能够直接修改里面的数据。


TIPS


如果Session中存在用户登录后的存储信息,那么也会将需要共享的用户基本信息写入到*model.Context中。


四、上下文变量使用


方法定义

方法定义的第一个输入参数往往预留给context.Context类型参数使用,以便接受上下文变量,特别是service层的方法。

例如:


// 执行用户登录
func (s *userService) Login(ctx context.Context, loginReq *define.UserServiceLoginReq) error {
    ...
}
// 查询内容列表
func (s *contentService) GetList(ctx context.Context, r *define.ContentServiceGetListReq) (*define.ContentServiceGetListRes, error) {
    ...
}
// 创建回复内容
func (s *replyService) Create(ctx context.Context, r *define.ReplyServiceCreateReq) error {
    ...
}


TIPS


另外一个好习惯是:方法的最后一个返回参数往往是error类型。如果确定方法内部永不会产生error,那么可以忽略。


Context对象获取


通过service中封装的以下方法,将context.Context上下文变量传递进去即可。

context.Context上下文变量在GoFrame框架的HTTP请求中可以通过r.Context()方法获取。

GRPC请求中,编译生成的pb文件中执行方法的第一个参数即固定是context.Context


service.Context.Get(ctx)


自定义Key-Value


我们可以通过以下方式设置/获取自定义的key-value键值对。


// 设置自定义键值对
service.Context.Get(ctx).Data[key] = value
...go
// 获取自定义键值对
service.Context.Get(ctx).Data[key]


五、注意问题


  1. 上下文变量只传递必须的链路参数数据,不要什么参数都往里面塞。特别是一些方法参数、传参的数据,千万不能往上下文里面塞,而应当显示的传递方法参数。
  2. 上下文变量仅用作运行时临时使用,不可做持久化存储长期使用。


总结


这篇文章详细的为大家介绍了GoFrame上下文对象Context的知识点:

Context的作用:在业务流程中进行变量的共享。

Context的结构定义、逻辑封装、如何在中间件中注入、如何通过Context设置值和取值、Context如何自定义key-value、以及在项目开发中使用的注意问题。


公众号:程序员升级打怪之旅

微信号:wangzhongyang1993

相关文章
|
4月前
|
存储 SQL 安全
Golang底层原理剖析之上下文Context
Golang底层原理剖析之上下文Context
107 0
|
4月前
|
安全 Go
Golang深入浅出之-互斥锁(sync.Mutex)与读写锁(sync.RWMutex)
【4月更文挑战第23天】Go语言并发编程中,`sync.Mutex`和`sync.RWMutex`是保证线程安全的关键。互斥锁确保单个goroutine访问资源,而读写锁允许多个读者并发访问。常见问题包括忘记解锁、重复解锁以及混淆锁类型。使用`defer`可确保解锁,读写锁不支持直接升级或降级,需释放后再获取。根据读写模式选择合适锁以避免性能下降和竞态条件。理解并正确使用锁是编写并发安全程序的基础。
73 3
|
1月前
|
安全 Java 调度
解锁Java并发编程高阶技能:深入剖析无锁CAS机制、揭秘魔法类Unsafe、精通原子包Atomic,打造高效并发应用
【8月更文挑战第4天】在Java并发编程中,无锁编程以高性能和低延迟应对高并发挑战。核心在于无锁CAS(Compare-And-Swap)机制,它基于硬件支持,确保原子性更新;Unsafe类提供底层内存操作,实现CAS;原子包java.util.concurrent.atomic封装了CAS操作,简化并发编程。通过`AtomicInteger`示例,展现了线程安全的自增操作,突显了这些技术在构建高效并发程序中的关键作用。
56 1
|
2月前
|
安全 Oracle Java
(四)深入理解Java并发编程之无锁CAS机制、魔法类Unsafe、原子包Atomic
其实在我们上一篇文章阐述Java并发编程中synchronized关键字原理的时候我们曾多次谈到过CAS这个概念,那么它究竟是什么?
|
4月前
|
Go
动态并发控制:sync.WaitGroup的灵活运用
动态并发控制:sync.WaitGroup的灵活运用
93 0
动态并发控制:sync.WaitGroup的灵活运用
|
4月前
|
存储 安全 C++
《C++ Concurrencyin Action》第6章--基于锁的并发数据结构设计
《C++ Concurrencyin Action》第6章--基于锁的并发数据结构设计
《C++ Concurrencyin Action》第6章--基于锁的并发数据结构设计
|
安全 Go 数据安全/隐私保护
Go context 原理(channel广播机制 + mutex线程安全)
Go context 原理(channel广播机制 + mutex线程安全)
403 0
|
存储 安全 Go
Go语言,并发控制神器之Context
一个协程启动后,一般是代码执行完毕,自动退出,但是如果需要提前终止怎么办呢? 一个办法是定义一个全局变量,协程中通过检查这个变量的变化来决定是否退出。这种办法须要加锁来保证并发安全
77 0
Go语言,并发控制神器之Context
|
存储 缓存 数据库
Android ContentProvider支持跨进程数据共享与"互斥、同步"杂谈
Android ContentProvider支持跨进程数据共享与"互斥、同步"杂谈
537 0
Android ContentProvider支持跨进程数据共享与"互斥、同步"杂谈
|
Java Maven
java 优雅的实现多线程等待,可重用的同步屏障Phaser | Java工具类
java 优雅的实现多线程等待,可重用的同步屏障Phaser | Java工具类
java 优雅的实现多线程等待,可重用的同步屏障Phaser | Java工具类