iris-session梳理

kelly 等级 754 0 0

入口

api := iris.New()
api.Adapt(gm.NewSession())

session的构造

func NewSession() sessions.Sessions {
db := redis.New(rs.Config{Network: rs.DefaultRedisNetwork,
Addr: config.Instance().Redis.Address,
Password: config.Instance().Redis.Password,
Database: "",
MaxIdle: 0,
MaxActive: 0,
IdleTimeout: rs.DefaultRedisIdleTimeout,
Prefix: "",
MaxAgeSeconds: config.Instance().Redis.MaxAgeSeconds}) // optionally configure the bridge between your redis server

mySessions := sessions.New(sessions.Config{Cookie: configs.GetSessionConfig().Cookie, Expires: configs.GetSessionConfig().Expires})
mySessions.UseDatabase(db)
return mySessions
}

MaxAgeSeconds //指的是session在数据库存的有效期
Expires //指的是session的有效期

回到刚才的api.Adapt(gm.NewSession()),装饰器

func (s *sessions) Adapt(frame *iris.Policies) {
// for newcomers this maybe looks strange:
// Each policy is an adaptor too, so they all can contain an Adapt.
// If they contains an Adapt func then the policy is an adaptor too and this Adapt func is called
// by Iris on .Adapt(...)
policy := iris.SessionsPolicy{
Start: s.Start,
Destroy: s.Destroy,
}

policy.Adapt(frame)
func (s SessionsPolicy) Adapt(frame *Policies) {
   if s.Start != nil {
      frame.SessionsPolicy.Start = s.Start
   }
   if s.Destroy != nil {
      frame.SessionsPolicy.Destroy = s.Destroy
   }
}

使用

调用context.Session(),获取到session对象

func (ctx *Context) Session() Session {
   policy := ctx.framework.policies.SessionsPolicy
   if policy.Start == nil {
      ctx.framework.Log(DevMode,
         errSessionsPolicyIsMissing.Format(ctx.RemoteAddr(), ctx.framework.Config.VHost).Error())
      return nil
   }

   if ctx.session == nil {
      ctx.session = policy.Start(ctx.ResponseWriter, ctx.Request)
   }

   return ctx.session
}

如果session==nil,就会调用start

func (s *sessions) Start(res http.ResponseWriter, req *http.Request) iris.Session {
   var sess iris.Session

   cookieValue := GetCookie(s.config.Cookie, req)

   if cookieValue == "" { // cookie doesn't exists, let's generate a session and add set a cookie
      sid := SessionIDGenerator(s.config.CookieLength)

      sess = s.provider.Init(sid, s.config.Expires)
      cookie := &http.Cookie{}

      // The RFC makes no mention of encoding url value, so here I think to encode both sessionid key and the value using the safe(to put and to use as cookie) url-encoding
      cookie.Name = s.config.Cookie

      cookie.Value = sid
      cookie.Path = "/"
      if !s.config.DisableSubdomainPersistence {

         requestDomain := req.URL.Host
         if portIdx := strings.IndexByte(requestDomain, ':'); portIdx > 0 {
            requestDomain = requestDomain[0:portIdx]
         }
         if IsValidCookieDomain(requestDomain) {

            // RFC2109, we allow level 1 subdomains, but no further
            // if we have localhost.com , we want the localhost.cos.
            // so if we have something like: mysubdomain.localhost.com we want the localhost here
            // if we have mysubsubdomain.mysubdomain.localhost.com we want the .mysubdomain.localhost.com here
            // slow things here, especially the 'replace' but this is a good and understable( I hope) way to get the be able to set cookies from subdomains & domain with 1-level limit
            if dotIdx := strings.LastIndexByte(requestDomain, '.'); dotIdx > 0 {
               // is mysubdomain.localhost.com || mysubsubdomain.mysubdomain.localhost.com
               s := requestDomain[0:dotIdx] // set mysubdomain.localhost || mysubsubdomain.mysubdomain.localhost
               if secondDotIdx := strings.LastIndexByte(s, '.'); secondDotIdx > 0 {
                  //is mysubdomain.localhost ||  mysubsubdomain.mysubdomain.localhost
                  s = s[secondDotIdx+1:] // set to localhost || mysubdomain.localhost
               }
               // replace the s with the requestDomain before the domain's siffux
               subdomainSuff := strings.LastIndexByte(requestDomain, '.')
               if subdomainSuff > len(s) { // if it is actual exists as subdomain suffix
                  requestDomain = strings.Replace(requestDomain, requestDomain[0:subdomainSuff], s, 1) // set to localhost.com || mysubdomain.localhost.com
               }
            }
            // finally set the .localhost.com (for(1-level) || .mysubdomain.localhost.com (for 2-level subdomain allow)
            cookie.Domain = "." + requestDomain // . to allow persistence
         }

      }
      cookie.HttpOnly = true
      // MaxAge=0 means no 'Max-Age' attribute specified.
      // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
      // MaxAge>0 means Max-Age attribute present and given in seconds
      if s.config.Expires >= 0 {
         if s.config.Expires == 0 { // unlimited life
            cookie.Expires = CookieExpireUnlimited
         } else { // > 0
            cookie.Expires = time.Now().Add(s.config.Expires)
         }
         cookie.MaxAge = int(cookie.Expires.Sub(time.Now()).Seconds())
      }

      // encode the session id cookie client value right before send it.
      cookie.Value = s.encodeCookieValue(cookie.Value)

      AddCookie(cookie, res)
   } else {
      cookieValue = s.decodeCookieValue(cookieValue)

      sess = s.provider.Read(cookieValue, s.config.Expires)
   }
   return sess
}

再设置cookie.Domain的时候,req.URL作为服务端的时候,是没有Host信息的,所以cookie.Domain 会默认空串。

再看s.provider.Init

// Init creates the session and returns it
func (p *provider) Init(sid string, expires time.Duration) iris.Session {
newSession := p.newSession(sid, expires)
p.mu.Lock()
p.sessions[sid] = newSession
p.mu.Unlock()
return newSession
}

init的时候做了两件事:
1.newSession
2.将session存到p.sessions里面

// newSession returns a new session from sessionid
func (p *provider) newSession(sid string, expires time.Duration) *session {

   sess := &session{
      sid:      sid,
      provider: p,
      values:   p.loadSessionValues(sid),
      flashes:  make(map[string]*flashMessage),
   }

   if expires > 0 { // if not unlimited life duration and no -1 (cookie remove action is based on browser's session)
      time.AfterFunc(expires, func() {
         // the destroy makes the check if this session is exists then or not,
         // this is used to destroy the session from the server-side also
         // it's good to have here for security reasons, I didn't add it on the gc function to separate its action
         p.Destroy(sid)
      })
   }

   return sess
}

这里可以看到在配置文件中设置的expire 是用来起了一个定时任务,之后删掉这个session

func (p *provider) Destroy(sid string) {
   p.mu.Lock()
   if sess, found := p.sessions[sid]; found {
      sess.values = nil
      sess.flashes = nil
      delete(p.sessions, sid)
      p.updateDatabases(sid, nil)
   }
   p.mu.Unlock()
}

destory的时候:
如果没有删除:
1.从p.sessions里面删除
2.更新到数据库

收藏
评论区

相关推荐

go语言web开发框架_Iris框架讲解(六):Session的使用和控制
在实际的项目开发中,我们会经常有业务场景使用到Session功能。在iris框架中,也为我们提供了方便使用,功能齐全的Session模块。Session模块的源码目录为kataras/iris/sessions包。 Session与Cookie的区别 在学习web开发过程中,我们总会和session和cookie打交道。本节课我们学习sesion相关的
cookie和session的详解与区别
会话(Session)跟踪是Web程序中常用的技术,用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份,Session通过在服务器端记录信息确定用户身份。 本章将系统地讲述Cookie与Session机制,并比较说明什么时候不能用Cookie,什么时候不能用Session。 1.1  C
iris-session梳理
入口 api : iris.New() api.Adapt(gm.NewSession()) session的构造 go func NewSession() sessions.Sessions { db : redis.New(rs.Config{Network: rs.DefaultRedisNetwork, Ad
Java Web:session
### 会话: HttpSession session = request.getSession(); //判断是否为新会话 session.isNew(); //获取一个已经存在的会话 HttpSession session = request.getSession(false); if(session =
Java web.xml session
在Java Web开发中,Session为我们提供了很多方便,Session是由浏览器和服务器之间维护的。Session超时理解为:浏览器和服务器之间创建了一个Session,由于客户端长时间(休眠时间)没有与服务器交互,服务器将此Session销毁,客户端再一次与服务器交互时之前的Session就不存在了。 设置Session超时时间方式: 方式一:在
005 python接口 session
![](https://oscimg.oschina.net/oscnet/68f4adce5843bed6c8614e63961e5283ddf.jpg) /* 时间:2018/09/22 功能:session 目录:   一: session 1 概念 2
Django中的session的使用
一、Session 的概念 ============= * cookie 是在浏览器端保存键值对数据,而 session 是在服务器端保存键值对数据 * session 的使用依赖 cookie:在使用 Session 后,会在 Cookie 中存储一个 sessionid 的数据,每次请求时浏览器都会将这个数据发给服务器,服务器在接收到 sess
Fiddler4 命令行使用
#### 命令行使用 *高亮显示命令* > `clear` 清空session列表 > `select` 高亮显示响应匹配的请求session!如: > > `select json` 响应类型(content-type)为json的session都会高亮 > `allbut` 与`select`命令相反、显示匹配外的sessio
JSP内置对象之session
       在实际开发中session主要用以完成用户的登陆以及注销等常见功能,每一个session都表示不同的访问用户,session对象是javax.servlet.http.HttpSession接口的实例化对象,所以session只能应用于HTTP协议中。        **取得Session Id:**当一个用户连接到一个服务器后,服务器会自动
SESSION存储于redis(CI3)
> CI3的Session的重大改变就是默认使用了原生的Session,这符合Session类库本来的意思,似乎更加合理一些。总体来说,虽然设计理念不同,但为了保证向后兼容性,类库的使用方法与CI2.0的差别不是很大。 ###Session 驱动 CI3的Session 类自带了 4 种不同的驱动(或叫做存储引擎)可供使用: * files *
Spring Boot 应用使用spring session+redis启用分布式session后,如何在配置文件里设置应用的cookiename、session超时时间、redis存储的nam...
现状 == 项目在使用Spring Cloud搭建微服务框架,其中分布式session采用spring session+redis 模式 需求 == 希望可以在配置文件(application.yml)里设置应用的cookiename、session超时时间以及redis存储的namespace 目前已知可以通过下面的方式设置session超时时间和
SpringBoot实现分布式session
实现分布式session ------------ > 实现基于redis的分布式session * * * ### 原理 基于HttpRequestWapper,对request获取的Session实现类进行替换,即提供一个从redis获取数据的Session实现类 ### 依赖 引入**spring-boot-starter-data-red
SpringBoot实现分布式session
实现分布式session ------------ > 实现基于redis的分布式session * * * ### 原理 基于HttpRequestWapper,对request获取的Session实现类进行替换,即提供一个从redis获取数据的Session实现类 ### 依赖 引入**spring-boot-starter-data-red
Tomcat基于MSM+Memcached实现Session共享
**前言** 在Tomcat集群中,当一个节点出现故障,其他节点该如何接管故障节点的Session信息呢?本文带来的解决方案是基于MSM+Memcached实现Session共享。 **相关介绍** **MSM** MSM–Memcached Session Manager是一个高可用的Tomcat Session共享解决方案,除了可以从本机内存
threadlocal
private static final ThreadLocal threadSession = new ThreadLocal(); public static Session getSession() throws InfrastructureException { Session s =

热门文章

Ngnix入门教程消息队列之Kafka详解磁盘读写与数据库的关系

最新文章

磁盘读写与数据库的关系消息队列之Kafka详解Ngnix入门教程