Session存储

我们在上篇文章中介绍了一个简单的Session管理器的工作原理，除此之外，我们还定义了一个Session存储接口。在本次分享中，我将展示一个实现此接口的基于内存的会话存储引擎的示例。您也可以将其定制为其他形式的Session存储。

package memory

import (
	"container/list"
	"sync"
	"time"

	"github.com/durban89/wiki/session"
)

// Store 存储
type Store struct {
	sid      string                      // unique session is
	lastTime time.Time                   // last save time
	value    map[interface{}]interface{} // session value save inside
}

// Provider 寄存器
type Provider struct {
	lock     sync.RWMutex             // locker
	sessions map[string]*list.Element // map in memory
	list     *list.List               // for gc
}

var memoryProvider = &Provider{list: list.New(), sessions: make(map[string]*list.Element)}

// Set Session
func (s *Store) Set(key, value interface{}) error {
	s.value[key] = value
	memoryProvider.SessionUpdate(s.sid)
	return nil
}

// Get Session
func (s *Store) Get(key interface{}) interface{} {
	memoryProvider.SessionUpdate(s.sid)
	if v, ok := s.value[key]; ok {
		return v
	}

	return nil

}

// Del Session
func (s *Store) Del(key interface{}) error {
	delete(s.value, key)
	memoryProvider.SessionUpdate(s.sid)
	return nil
}

// SID Session ID
func (s *Store) SID() string {
	return s.sid
}

// SessionInit 一个Session
func (p *Provider) SessionInit(sid string) (session.Session, error) {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()
	v := make(map[interface{}]interface{}, 0)
	store := &Store{
		sid:      sid,
		lastTime: time.Now(),
		value:    v,
	}

	res := memoryProvider.list.PushBack(store)
	memoryProvider.sessions[sid] = res

	return store, nil
}

// SessionRead 一个Session
func (p *Provider) SessionRead(sid string) (session.Session, error) {
	if v, ok := memoryProvider.sessions[sid]; ok {
		return v.Value.(*Store), nil
	}

	store, err := memoryProvider.SessionInit(sid)
	return store, err

}

// SessionDestroy 一个Session
func (p *Provider) SessionDestroy(sid string) error {
	if v, ok := memoryProvider.sessions[sid]; ok {
		delete(memoryProvider.sessions, sid)
		memoryProvider.list.Remove(v)
		return nil
	}

	return nil
}

// SessionGC 一个Session
func (p *Provider) SessionGC(maxLifeTime int64) {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()

	for {
		v := memoryProvider.list.Back()
		if v == nil {
			break
		}

		if v.Value.(*Store).lastTime.Unix()+maxLifeTime < time.Now().Unix() {
			memoryProvider.list.Remove(v)
			delete(memoryProvider.sessions, v.Value.(*Store).sid)
		} else {
			break
		}
	}
}

// SessionUpdate 一个Session
func (p *Provider) SessionUpdate(sid string) error {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()

	if v, ok := memoryProvider.sessions[sid]; ok {
		v.Value.(*Store).lastTime = time.Now()
		memoryProvider.list.MoveToFront(v)
	}

	return nil
}

func init() {
	memoryProvider.sessions = make(map[string]*list.Element, 0)
	session.RegisterProvider("memory", memoryProvider)
}

上面的示例实现了基于内存的Session存储机制。它使用其init()函数将此存储引擎注册到Session管理器。那么我们如何从主程序注册这个引擎呢？

import (
	"github.com/durban89/wiki/session"

	// memory session provider
	_ "github.com/durban89/wiki/session/providers/memory"
)

我们使用空白导入机制（它将自动调用包的init()函数）将此引擎注册到Session管理器。然后，我们使用以下代码初始化Session管理器：

var appSession *session.Manager

func init() {
	appSession, _ := session.GetManager("memory", "sessionid", 3600)

	go appSession.SessionGC()
}