gorilla/sessions 阅读

// Flashes returns a slice of flash messages from the session.
//
// A single variadic argument is accepted, and it is optional: it defines
// the flash key. If not defined "_flash" is used by default.
func (s *Session) Flashes(vars ...string) []interface{} {
    var flashes []interface{}
    key := flashesKey
    if len(vars) > 0 {
        key = vars[0]
    }
    if v, ok := s.Values[key]; ok {
        // Drop the flashes and return it.
        delete(s.Values, key)
        flashes = v.([]interface{})
    }
    return flashes
}

// AddFlash adds a flash message to the session.
//
// A single variadic argument is accepted, and it is optional: it defines
// the flash key. If not defined "_flash" is used by default.
func (s *Session) AddFlash(value interface{}, vars ...string) {
    key := flashesKey
    if len(vars) > 0 {
        key = vars[0]
    }
    var flashes []interface{}
    if v, ok := s.Values[key]; ok {
        flashes = v.([]interface{})
    }
    s.Values[key] = append(flashes, value)
}

可以用var...的方法实现一个含有可选参数的函数。

如果有flash的话就把flash拿出来，再通过append加上去，如果没有的话就直接添加上。

 下面是我把beego里的sess_mem的接口实现加上了flash支持，另外在session里面给接口加上两个方法。

package session

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

const flash = "___Flash"

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

type MemSessionStore struct {
    sid          string                      //session id唯一标示
    timeAccessed time.Time                   //最后访问时间
    value        map[interface{}]interface{} //session里面存储的值
    //传说中的读写全球锁
    lock sync.RWMutex
}

//设置flash
func (st *MemSessionStore) FlashSet(value interface{}) error {
    st.lock.Lock()
    defer st.lock.Unlock()
    var flashes []interface{}
    if v, ok := st.value[flash]; ok {
        flashes = v.([]interface{})
    }
    st.value[flash] = append(flashes, value)
    return nil
}

//返回flash
func (st *MemSessionStore) FlashGet() []interface{} {
    st.lock.Lock()
    defer st.lock.Unlock()
    if v, ok := st.value[flash]; ok {
        temp := v
        delete(st.value, flash)
        return temp.([]interface{})
    } else {
        return nil
    }
    return nil
}

//map不是线程安全的
func (st *MemSessionStore) Set(key, value interface{}) error {
    //所有想要Lock的都会阻塞，直到解锁
    st.lock.Lock()
    defer st.lock.Unlock()
    //fmt.Println("set")
    st.value[key] = value
    return nil
}

func (st *MemSessionStore) Get(key interface{}) interface{} {
    //所有想要读的都会阻塞，直到解锁
    st.lock.RLock()
    //这里是为了拿到读锁，也就是说，占用这个资源给这个资源上锁
    //之所以要上锁就是因为，比如写的时候已经上锁了，那么不用锁机制的话
    //get就会拿到写之后的呢？还是写之前的呢?所以要有锁机制，用Rlock阻塞
    defer st.lock.RUnlock()

    if v, ok := st.value[key]; ok {
        return v
    } else {
        return nil
    }
    return nil
}

func (st *MemSessionStore) Delete(key interface{}) error {
    st.lock.Lock()
    defer st.lock.Unlock()
    delete(st.value, key)
    return nil
}

func (st *MemSessionStore) Flush() error {
    st.lock.Lock()
    defer st.lock.Unlock()
    //删除的方法，只有把这个map赋个空值了
    st.value = make(map[interface{}]interface{})
    return nil
}

func (st *MemSessionStore) SessionID() string {
    return st.sid
}

func (st *MemSessionStore) SessionRelease() {

    //这里怎么没实现？写个空函数在这里

}

type MemProvider struct {
    lock        sync.RWMutex             //用来锁
    sessions    map[string]*list.Element //用来存储在内存
    list        *list.List               //用来做gc
    maxlifetime int64
    savePath    string
}

func (pder *MemProvider) SessionInit(maxlifetime int64, savePath string) error {
    pder.maxlifetime = maxlifetime
    pder.savePath = savePath
    return nil
}

func (pder *MemProvider) SessionRead(sid string) (SessionStore, error) {
    pder.lock.RLock()
    if element, ok := pder.sessions[sid]; ok {
        go pder.SessionUpdate(sid)
        pder.lock.RUnlock()
        return element.Value.(*MemSessionStore), nil
    } else {
        pder.lock.RUnlock()
        pder.lock.Lock()
        newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
        element := pder.list.PushBack(newsess)
        pder.sessions[sid] = element
        pder.lock.Unlock()
        return newsess, nil
    }
    return nil, nil
}

func (pder *MemProvider) SessionExist(sid string) bool {
    pder.lock.RLock()
    defer pder.lock.RUnlock()
    if _, ok := pder.sessions[sid]; ok {
        return true
    } else {
        return false
    }
}

func (pder *MemProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
    pder.lock.RLock()
    if element, ok := pder.sessions[oldsid]; ok {
        go pder.SessionUpdate(oldsid)
        pder.lock.RUnlock()
        pder.lock.Lock()
        //list的节点是Element，有一个Value是一个借口
        element.Value.(*MemSessionStore).sid = sid
        pder.sessions[sid] = element
        delete(pder.sessions, oldsid)
        pder.lock.Unlock()
        return element.Value.(*MemSessionStore), nil
    } else {
        pder.lock.RUnlock()
        pder.lock.Lock()
        newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
        element := pder.list.PushBack(newsess)
        pder.sessions[sid] = element
        pder.lock.Unlock()
        return newsess, nil
    }
    return nil, nil
}

func (pder *MemProvider) SessionDestroy(sid string) error {
    pder.lock.Lock()
    defer pder.lock.Unlock()
    if element, ok := pder.sessions[sid]; ok {
        delete(pder.sessions, sid)
        pder.list.Remove(element)
        return nil
    }
    return nil
}

func (pder *MemProvider) SessionGC() {
    pder.lock.RLock()
    for {
        element := pder.list.Back()
        if element == nil {
            break
        }
        if (element.Value.(*MemSessionStore).timeAccessed.Unix() + pder.maxlifetime) < time.Now().Unix() {
            pder.lock.RUnlock()
            pder.lock.Lock()
            pder.list.Remove(element)
            delete(pder.sessions, element.Value.(*MemSessionStore).sid)
            pder.lock.Unlock()
            pder.lock.RLock()
        } else {
            break
        }
    }
    pder.lock.RUnlock()
}

//这个命名不是太好的感觉

func (pder *MemProvider) SessionAll() int {
    return pder.list.Len()
}

func (pder *MemProvider) SessionUpdate(sid string) error {
    pder.lock.Lock()
    defer pder.lock.Unlock()
    if element, ok := pder.sessions[sid]; ok {
        element.Value.(*MemSessionStore).timeAccessed = time.Now()
        pder.list.MoveToFront(element)
        return nil
    }
    return nil
}

func init() {
    //注册使用这个接口，会话提供者
    Register("memory", mempder)
}