Go实现Session

Go实现Session

//-------------session_implements-----------------
//Session操作接口，不同存储方式的Sesion操作不同，实现也不同
type Session interface {
Set(key, value interface{})
Get(key interface{}) interface{}
Remove(key interface{}) error
GetId() string
}

//session实现
type SessionFromMemory struct {
//唯一标示
sid              string
lock             sync.Mutex                  //一把互斥锁
lastAccessedTime time.Time                   //最后访问时间
maxAge           int64                       //超时时间
data             map[interface{}]interface{} //主数据
}

//实例化
func newSessionFromMemory() *SessionFromMemory {
return &SessionFromMemory{
data:   make(map[interface{}]interface{}),
maxAge: 60 * 30, //默认30分钟
}
}

//同一个会话均可调用，进行设置，改操作必须拥有排斥锁
func (si *SessionFromMemory) Set(key, value interface{}) {
si.lock.Lock()
defer si.lock.Unlock()
si.data[key] = value
}

func (si *SessionFromMemory) Get(key interface{}) interface{} {
if value := si.data[key]; value != nil {
return value
}
return nil
}
func (si *SessionFromMemory) Remove(key interface{}) error {
if value := si.data[key]; value != nil {
delete(si.data, key)
}
return nil
}
func (si *SessionFromMemory) GetId() string {
return si.sid
}

//--------------session_from---------------------------
//session存储方式接口，可以存储在内存，数据库或者文件
//分别实现该接口即可
//如存入数据库的CRUD操作
type Storage interface {
//初始化一个session，id根据需要生成后传入
InitSession(sid string, maxAge int64) (Session, error)
//根据sid，获得当前session
SetSession(session Session) error
//销毁session
DestroySession(sid string) error
//回收
GCSession()
}

//session来自内存
type FromMemory struct {
//由于session包含所有的请求
//并行时，保证数据独立、一致、安全
lock     sync.Mutex //互斥锁
sessions map[string]Session
}

//实例化一个内存实现
func newFromMemory() *FromMemory {
return &FromMemory{
sessions: make(map[string]Session, 0),
}
}

//初始换会话session，这个结构体操作实现Session接口
func (fm *FromMemory) InitSession(sid string, maxAge int64) (Session, error) {
fm.lock.Lock()
defer fm.lock.Unlock()

newSession := newSessionFromMemory()
newSession.sid = sid
if maxAge != 0 {
newSession.maxAge = maxAge
}
newSession.lastAccessedTime = time.Now()

fm.sessions[sid] = newSession //内存管理map
return newSession, nil
}

//设置
func (fm *FromMemory) SetSession(session Session) error {
fm.sessions[session.GetId()] = session
return nil
}

//销毁session
func (fm *FromMemory) DestroySession(sid string) error {
if _, ok := fm.sessions[sid]; ok {
delete(fm.sessions, sid)
return nil
}
return nil
}

//监判超时
func (fm *FromMemory) GCSession() {

sessions := fm.sessions

//fmt.Println("gc session")

if len(sessions) < 1 {
return
}

//fmt.Println("current active sessions ", sessions)

for k, v := range sessions {
t := (v.(*SessionFromMemory).lastAccessedTime.Unix()) + (v.(*SessionFromMemory).maxAge)

if t < time.Now().Unix() { //超时了

fmt.Println("timeout-------->", v)
delete(fm.sessions, k)
}
}

}

//--------------session_manager----------------------
//管理Session,实际操作cookie，Storage
//由于该结构体是整个应用级别的，写、修改都需要枷锁
type SessionManager struct {
//session数据最终需要在客户端（浏览器）和服务器各存一份
//客户端时，存放在cookie中
cookieName string
//存放方式，如内存，数据库，文件
storage Storage
//超时时间
maxAge int64
//由于session包含所有的请求
//并行时，保证数据独立、一致、安全
lock sync.Mutex
}

//实例化一个session管理器
func NewSessionManager() *SessionManager {
sessionManager := &SessionManager{
cookieName: "lzy-cookie",
storage:    newFromMemory(), //默认以内存实现
maxAge:     60 * 30,         //默认30分钟
}
go sessionManager.GC()

return sessionManager
}

func (m *SessionManager) GetCookieN() string {
return m.cookieName
}

//先判断当前请求的cookie中是否存在有效的session,存在返回，不存在创建
func (m *SessionManager) BeginSession(w http.ResponseWriter, r *http.Request) Session {
//防止处理时，进入另外的请求
m.lock.Lock()
defer m.lock.Unlock()

cookie, err := r.Cookie(m.cookieName)
if err != nil || cookie.Value == "" { //如果当前请求没有改cookie名字对应的cookie
fmt.Println("-----------> current session not exists")
//创建一个
sid := m.randomId()
//根据保存session方式，如内存，数据库中创建
session, _ := m.storage.InitSession(sid, m.maxAge) //该方法有自己的锁，多处调用到

maxAge := m.maxAge

if maxAge == 0 {
maxAge = session.(*SessionFromMemory).maxAge
}
//用session的ID于cookie关联
//cookie名字和失效时间由session管理器维护
cookie := http.Cookie{
Name: m.cookieName,
//这里是并发不安全的，但是这个方法已上锁
Value:    url.QueryEscape(sid), //转义特殊符号@#￥%+*-等
Path:     "/",
HttpOnly: true,
MaxAge:   int(maxAge),
Expires:  time.Now().Add(time.Duration(maxAge)),
}
http.SetCookie(w, &cookie) //设置到响应中
return session
} else { //如果存在

sid, _ := url.QueryUnescape(cookie.Value)        //反转义特殊符号
session := m.storage.(*FromMemory).sessions[sid] //从保存session介质中获取
fmt.Println("session --------->", session)
if session == nil {
fmt.Println("-----------> current session is nil")
//创建一个
//sid := m.randomId()
//根据保存session方式，如内存，数据库中创建
newSession, _ := m.storage.InitSession(sid, m.maxAge) //该方法有自己的锁，多处调用到

maxAge := m.maxAge

if maxAge == 0 {
maxAge = newSession.(*SessionFromMemory).maxAge
}
//用session的ID于cookie关联
//cookie名字和失效时间由session管理器维护
newCookie := http.Cookie{
Name: m.cookieName,
//这里是并发不安全的，但是这个方法已上锁
Value:    url.QueryEscape(sid), //转义特殊符号@#￥%+*-等
Path:     "/",
HttpOnly: true,
MaxAge:   int(maxAge),
Expires:  time.Now().Add(time.Duration(maxAge)),
}
http.SetCookie(w, &newCookie) //设置到响应中
return newSession
}
fmt.Println("-----------> current session exists")
return session
}

}

//更新超时
func (m *SessionManager) Update(w http.ResponseWriter, r *http.Request) {
m.lock.Lock()
defer m.lock.Unlock()

cookie, err := r.Cookie(m.cookieName)
if err != nil {
return
}
t := time.Now()
sid, _ := url.QueryUnescape(cookie.Value)

sessions := m.storage.(*FromMemory).sessions
session := sessions[sid].(*SessionFromMemory)
session.lastAccessedTime = t
sessions[sid] = session

if m.maxAge != 0 {
cookie.MaxAge = int(m.maxAge)
} else {
cookie.MaxAge = int(session.maxAge)
}
http.SetCookie(w, cookie)
}

//通过ID获取session
func (m *SessionManager) GetSessionById(sid string) Session {
session := m.storage.(*FromMemory).sessions[sid]
return session
}

//是否内存中存在
func (m *SessionManager) MemoryIsExists(sid string) bool {
_, ok := m.storage.(*FromMemory).sessions[sid]
if ok {
return true
}
return false
}

//手动销毁session，同时删除cookie
func (m *SessionManager) Destroy(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie(m.cookieName)
if err != nil || cookie.Value == "" {
return
} else {
m.lock.Lock()
defer m.lock.Unlock()

sid, _ := url.QueryUnescape(cookie.Value)
m.storage.DestroySession(sid)

cookie2 := http.Cookie{
MaxAge:  0,
Name:    m.cookieName,
Value:   "",
Path:    "/",
Expires: time.Now().Add(time.Duration(0)),
}

http.SetCookie(w, &cookie2)
}
}

func (m *SessionManager) CookieIsExists(r *http.Request) bool {
_, err := r.Cookie(m.cookieName)
if err != nil {
return false
}
return true
}

//开启每个会话，同时定时调用该方法
//到达session最大生命时，且超时时。回收它
func (m *SessionManager) GC() {
m.lock.Lock()
defer m.lock.Unlock()

m.storage.GCSession()
//在多长时间后执行匿名函数，这里指在某个时间后执行GC
time.AfterFunc(time.Duration(m.maxAge*10), func() {
m.GC()
})
}

//是否将session放入内存（操作内存）默认是操作内存
func (m *SessionManager) IsFromMemory() {
m.storage = newFromMemory()
}

//是否将session放入数据库（操作数据库）
func (m *SessionManager) IsFromDB() {
//TODO
//关于存数据库暂未实现
}

func (m *SessionManager) SetMaxAge(t int64) {
m.maxAge = t
}

//如果你自己实现保存session的方式，可以调该函数进行定义
func (m *SessionManager) SetSessionFrom(storage Storage) {
m.storage = storage
}

//生成一定长度的随机数
func (m *SessionManager) randomId() string {
b := make([]byte, 32)
if _, err := io.ReadFull(rand.Reader, b); err != nil {
return ""
}
//加密
return base64.URLEncoding.EncodeToString(b)
}