gin-session使用以及源码分析

Posted 一只小蜗牛

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了gin-session使用以及源码分析相关的知识,希望对你有一定的参考价值。

gin-session使用以及源码分析

概述

一般PC 端网站开发都会谈到Session,服务端开启Session机制,客户端在第一次访问服务端时,服务端会生成sessionId通过cookie 机制回传到客户端保存,之后每次客户端访问服务端时都会通过cookie机制带sessionId到服务端,服务端通过解析SessionID找到请求的Session会话信息;

Session信息都是保存在服务器中的,类似:SessionID =》 session信息;至于session信息具体内容是什么,这个要根据具体的业务逻辑来确定,但是普遍是用户信息;

服务端保存Session的方式很多:文件,缓存,数据库等,所以衍生出来的session的载体也有很多:redis,文件,mysql,memcached 等等;其中每一种载体都有着自己的优劣,根据不同的业务场景可以选取合适的载体;

下面我们主要介绍 redis 作为载体:

Gin中的 Session

gin中Session的实现主要依赖于Gin-session中间件实现 (https://github.com/gin-contri... 通过注入不同的 store 从而实现不同的载体保存Session信息 :

主要包括:

  • cookie-based
  • Redis
  • memcached
  • MongoDB
  • memstore

简单调用:

创建一个新的store并将中间件注入到gin的路由器中。需要使用的时候在HandlerFunc内部用 sessions.Default(c)即可获取到session
// 创建载体方式对象(cookie-based)
store := cookie.NewStore([]byte("secret"))
r.Use(sessions.Sessions("sessionId", store))
r.GET("/hello", func(c *gin.Context) {
    
    // session中间使用
    session := sessions.Default(c)
    if session.Get("hello") != "world" {
        session.Set("hello", "world")
        session.Save()
    }
    
    ....
})

Gin-session 源码流程

下面我们以使用频率较高的 redis 作为 store 来看看 Gin-session 主要工作流程

简单调用


router := gin.Default()
// @Todo 创建store对象
store, err := sessions.NewRedisStore(10, "tcp", "localhost:6379", "", []byte("secret"))
    if err != nil {log.Fatal(" sessions.NewRedisStore err is :%v", err)}

router.GET("/admin", func(c *gin.Context) {
        session := sessions.Default(c)
        var count int
        v := session.Get("count")
        if v == nil {
            count = 0
        } else {
            count = v.(int)
            count++
        }
        session.Set("count", count)
        session.Save()
        c.JSON(200, gin.H{"count": count})
    })

创建 store 对象

底层的 store 创建

func NewRediStore(size int, network, address, password string, keyPairs ...[]byte) (*RediStore, error) {
    return NewRediStoreWithPool(&redis.Pool{
        MaxIdle:     size,
        IdleTimeout: 240 * time.Second,
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
        Dial: func() (redis.Conn, error) {
            return dial(network, address, password)
        },
    }, keyPairs...)
}

// NewRediStoreWithPool instantiates a RediStore with a *redis.Pool passed in.
func NewRediStoreWithPool(pool *redis.Pool, keyPairs ...[]byte) (*RediStore, error) {
    rs := &RediStore{
        // http://godoc.org/github.com/gomodule/redigo/redis#Pool
        Pool:   pool,
        Codecs: securecookie.CodecsFromPairs(keyPairs...),
        Options: &sessions.Options{
            Path:   "/", // 客户端的 Path
            MaxAge: sessionExpire, // 客户端的Expires/MaxAge
        },
        DefaultMaxAge: 60 * 20, // 过期时间是20分钟
        maxLength:     4096, // 最大长度
        keyPrefix:     "session_", // key 前缀
        serializer:    GobSerializer{}, // 内部序列化采用了Gob库
    }
    // @Todo 尝试创建连接
    _, err := rs.ping()
    return rs, err
}

根据函数可以看到,根据传入参数(size:连接数, network:连接协议,address:服务地址,password:密码)初始化一个 redis.Pool 对象,通过传入 redis.Pool 对象 和 一些默认的参数初始化 RediStore 对象

作为中间件在 gin router层调用

作为 gin 中间件使用并不复杂,就是把HandlerFunc放到group.Handlers数组后面;
// Use adds middleware to the group, see example code in GitHub.
func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
    group.Handlers = append(group.Handlers, middleware...)
    return group.returnObj()
}
下面看看这个中间件的方法实现了什么: sessions.Sessions("sessionId", store),

const (
    DefaultKey  = "github.com/gin-gonic/contrib/sessions"
    errorFormat = "[sessions] ERROR! %s\\n"
)


func Sessions(name string, store Store) gin.HandlerFunc {
    return func(c *gin.Context) {
        s := &session{name, c.Request, store, nil, false, c.Writer}
        c.Set(DefaultKey, s)
        defer context.Clear(c.Request)
        c.Next()
    }
}

type session struct {
    name    string
    request *http.Request
    store   Store
    session *sessions.Session
    written bool
    writer  http.ResponseWriter
}

我们可以看到他 HandlerFunc 的实现:

  1. 创建一个session对象(包括:request信息,Store 存储载体redis RediStore 对象...)
  2. 把创建的的session对象 set 到 *gin.Context 键值对中;key 为一个定值:DefaultKey(github.com/gin-gonic/contrib/sessions)
  3. 路由层只会在初始化的时候执行一次,而且 store 是捆绑在 Session 中,因此每一个 session 都会指向同一个store

获取session实现

我们可以到在 router 中间件中已经创建好 session 对象并且 set 到对应的 gin.Context 中,那么我们只需要调用 sessions.Default(c) 出来即可;

// shortcut to get session
func Default(c *gin.Context) Session {
    return c.MustGet(DefaultKey).(Session)
}

注意:返回的类型是Session的接口定义,gin.Context 中 set 的是session具体实现;

读取session值

通过简单的代码获取session的值
// @Todo SessionKey 中获取用户信息
session := sessions.Default(c)
sessionInfo := session.Get(public.AdminSessionInfoKey)
上面已经有提到过了,sessions.Default 返回的 Session 的接口定义类,其定义了Get()这个方法接口,实际的方法实现还在session中。

type session struct {
    name    string
    request *http.Request
    store   Store
    session *sessions.Session // 实际内部数据交换
    written bool
    writer  http.ResponseWriter
}

func (s *session) Get(key interface{}) interface{} {
    // 通过s.Session() 获取具体的session;具体的值保存在 Values 这个map 中
    return s.Session().Values[key]
}

func (s *session) Session() *sessions.Session {
    if s.session == nil {
        var err error
        s.session, err = s.store.Get(s.request, s.name)
        if err != nil {
            log.Printf(errorFormat, err)
        }
    }
    return s.session
}

通过观察 session 的结构体, 里面包含着 session sessions.Session 对象,这个要跟 之前的 Session 接口定义区分开;这里的 sessions.Session 是真正保存的session 对象;其结构体如下:(gorilla/sessions库)


// Session stores the values and optional configuration for a session.
type Session struct {
    // The ID of the session, generated by stores. It should not be used for
    // user data.
    ID string
    // Values contains the user-data for the session.
    Values  map[interface{}]interface{}
    Options *Options
    IsNew   bool
    store   Store
    name    string
}

OK! 知道 s.session 是什么后,那么 s.Session().Values[key] 也变得非常好理解了,其实 Values 这个属性其实是个map,其中保存的就是我们 set 在session中的具体值;我们继续往下走。。。

当 s.session 是空的时候,我们就通过 s.store.Get(s.request, s.name) 获取;

// s.request 请求
// s.name session名
s.session, err = s.store.Get(s.request, s.name)

注意:s.request: 请求 和 s.name: session名 什么时候注入的呢? 其实我们这里可以回顾下上面:

// @Todo 在路由层注入session的时候 Seesions 方法其实就初始化了这个session的name 和其他值,只是保存的session是 nil
sessions.Sessions("sessionId", store)

言归正传,我们继续往下走,上面通过 store.Get 来获取 session;因为这里的我们分析的是redis载体,所以 store 是 RediStore 我们看下他的GET方法:


// Get returns a session for the given name after adding it to the registry.
//
// See gorilla/sessions FilesystemStore.Get().
func (s *RediStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    return sessions.GetRegistry(r).Get(s, name)
}

我们可以看到:通过 sessions.GetRegistry(r) 获取到一个 Registry ;然后通过 Registry 的 GET方法获取一个session;

我们来看看他的实现:

// GetRegistry 本质就是返回一个 Registry 的一个结构体
func GetRegistry(r *http.Request) *Registry {
    registry := context.Get(r, registryKey)
    if registry != nil {
        return registry.(*Registry)
    }
    newRegistry := &Registry{
        request:  r,
        sessions: make(map[string]sessionInfo),
    }
    context.Set(r, registryKey, newRegistry)
    return newRegistry
}

// Registry stores sessions used during a request.
type Registry struct {
    request  *http.Request
    sessions map[string]sessionInfo
}


// Get registers and returns a session for the given name and session store.
//
// It returns a new session if there are no sessions registered for the name.
func (s *Registry) Get(store Store, name string) (session *Session, err error) {
    if !isCookieNameValid(name) {
        return nil, fmt.Errorf("sessions: invalid character in cookie name: %s", name)
    }
    if info, ok := s.sessions[name]; ok {
        session, err = info.s, info.e
    } else {
        session, err = store.New(s.request, name)
        session.name = name
        s.sessions[name] = sessionInfo{s: session, e: err}
    }
    session.store = store
    return
}

其实不难看出 GetRegistry 本质上就是返回了一个 Registry 结构体;然后结合 Get 方法我们可以看出其实 Registry 结构体本质上是维护着一个 key -》 value 的映射关系; 而其中的 key 就是我们 开始在路由注入的 session name , value 就是我们保存的 sessionInfo;

所以我们也可以理解:Registry 的作用就是维护一个业务session名到对应session的映射,隔离了session。当session不存在时,需要调用 store.New(s.request, name) 来新建一个session:


// New returns a session for the given name without adding it to the registry.
//
// See gorilla/sessions FilesystemStore.New().
func (s *RediStore) New(r *http.Request, name string) (*sessions.Session, error) {
    var (
        err error
        ok  bool
    )
    
    // @Todo 初始化一个业务的session 
    session := sessions.NewSession(s, name)
    // make a copy
    options := *s.Options
    session.Options = &options
    session.IsNew = true
    // @Todo 根据session_name读取cookie中的sessionID
    if c, errCookie := r.Cookie(name); errCookie == nil {
        // @Todo 编解码器对cookie值进行解码
        err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
        if err == nil {
            // @Todo redis中根据sessionID 获取具体的 sessionInfo
            ok, err = s.load(session)
            session.IsNew = !(err == nil && ok) // not new if no error and data available
        }
    }
    return session, err
}

跑了这么久。。终于看到从 cookie 中读取 sessionID,然后 根据SessionID 从 redis 中把我们的session加载出来;

写入 session 值

其实 写入 和 读取 差别不是很大:


// @Todo 写值入口 (其实就是session map 中赋值一下)
func (s *session) Set(key interface{}, val interface{}) {
    s.Session().Values[key] = val
    s.written = true
}


func (s *session) Save() error {
    if s.Written() {
        e := s.Session().Save(s.request, s.writer)
        if e == nil {
            s.written = false
        }
        return e
    }
    return nil
}

// Save is a convenience method to save this session. It is the same as calling
// store.Save(request, response, session). You should call Save before writing to
// the response or returning from the handler.
func (s *Session) Save(r *http.Request, w http.ResponseWriter) error {
    return s.store.Save(r, w, s)
}

// Save adds a single session to the response.
func (s *RediStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
    // @Todo 删除session并把cookie中也强制过期
    if session.Options.MaxAge <= 0 {
        if err := s.delete(session); err != nil {
            return err
        }
        http.SetCookie(w, sessions.NewCookie(session.Name(), "", session.Options))
    } else {
        // @Todo 如果没SessionID 就随机生成一个sessionID (并发来的时候是否会生成相同SessionID)
        if session.ID == "" {
            session.ID = strings.TrimRight(base32.StdEncoding.EncodeToString(securecookie.GenerateRandomKey(32)), "=")
        }
        // @Todo 将session的值写入redis
        if err := s.save(session); err != nil {
            return err
        }
        // @Todo cookie编码一下
        encoded, err := securecookie.EncodeMulti(session.Name(), session.ID, s.Codecs...)
        if err != nil {
            return err
        }
        // @Todo 根据session的属性,写入 cookie (SessionID, path, maxAge等)
        http.SetCookie(w, sessions.NewCookie(session.Name(), encoded, session.Options))
    }
    return nil
}

其实我们可以看到最后执行 save 的最终实现还是放在了 RediStore 对象中;也是上面的最后一个方法,所以我们重点看看最后一个方法:

  1. 如果没SessionID 就随机生成一个sessionID (并发来的时候是否会生成相同SessionID)
  2. 将session的值写入redis
  3. cookie编码一下
  4. 根据session的属性,写入 cookie (SessionID, path, maxAge等)

基本完成:留一个简单问题,当请求并发的时候生成 SessionID 是否存在相同?

建议:联合gin-session中间件,跟着看。。

如果发现什么问题 请指出。。

以上是关于gin-session使用以及源码分析的主要内容,如果未能解决你的问题,请参考以下文章

Android 逆向整体加固脱壳 ( DEX 优化流程分析 | DexPrepare.cpp 中 dvmOptimizeDexFile() 方法分析 | /bin/dexopt 源码分析 )(代码片段

Android 事件分发事件分发源码分析 ( Activity 中各层级的事件传递 | Activity -> PhoneWindow -> DecorView -> ViewGroup )(代码片段

mysql jdbc源码分析片段 和 Tomcat's JDBC Pool

《Docker 源码分析》全球首发啦!

Retrofit源码分析以及MVP框架封装使用

Android 逆向ART 脱壳 ( DexClassLoader 脱壳 | DexClassLoader 构造函数 | 参考 Dalvik 的 DexClassLoader 类加载流程 )(代码片段