原生Go语言没有实现session管理机制，所以如果使用原生Go语言进行web编程，我们需要自己进行session管理机制的设计与实现，本文将就此进行详细介绍，并实现一个简单的session管理机制。
session信息可以使用内存、文件或数据库等方式进行存储，考虑到对不同存储方式的兼容，我们设计的session管理机制应该能很方便的在不同存储方式之间进行切换。所以，session管理机制可以分为两部分内容：session管理器和session存储器，session管理器主要负责多种存储方式的共同操作部分，例如，cookie的读取与设置、session ID的生成，以及一些共同需要的参数设置等等。session管理器结构可设置如下：
//session管理器
type SessionManager struct {
cookieName string //cookie名称
cookieExpire int //cookie有效期时间（单位：分钟，0表示会话cookie）
sessionExpire int64 //session有效期时间（单位：分钟）
gcDuration int //垃圾回收机制运行间隔时间（单位：分钟）
provider SessionProvider //session存储器
}
其创建方法为：
//创建session管理器
func NewManager(cookieName string, cookieExpire int, sessionExpire int64, gcDuration int, provider SessionProvider) *SessionManager {
return &SessionManager{
cookieName: cookieName,
cookieExpire: cookieExpire,
sessionExpire: sessionExpire,
gcDuration: gcDuration,
provider: provider,
}
}
而session存储器则对应具体的存储方式，只需负责根据session ID对session数据进行读写操作，这部分根据存储方式不同而不同，但方法签名是一致的，可以定义其接口类型为：
//session存储器
type SessionProvider interface {
create(sessionId string, data map[string]interface{}) error //创建session
get(sessionId, key string) (string, error) //读取session键值
getAll(sessionId string) (map[string]string, error) //读取session所有键值对
set(sessionId, key string, value interface{}) error //设置session键值
destroy(sessionId string) error //销毁session
gc(expire int64) error //垃圾回收：删除过期session
}
接下来定义session管理器生成session ID的方法，可根据请求头信息生成，这里只是举一个例子：
//生成session ID
func (sm *SessionManager) createSessionId(req *http.Request) string {
addr := req.RemoteAddr
userAgent := req.Header.Get("User-Agent")
rand.Seed(time.Now().UnixNano())
n := rand.Intn(10000)
str := addr + "_" + userAgent + "_" + strconv.Itoa(n)
h := md5.New()
h.Write([]byte(str))
cipherStr := h.Sum(nil)
return hex.EncodeToString(cipherStr)
}
session管理器的各个方法都需要读cookie，获取session ID：
//读cookie，获取session ID
func (sm *SessionManager) getSessionId(req *http.Request) (string, error) {
c, err := req.Cookie(sm.cookieName)
if err != nil {
return "", errors.New("Reading cookie failed: " + err.Error())
}
if len(c.Value) == 0 { //尚未设置cookie
return "", errors.New("Cookie does not exists: " + sm.cookieName)
}
return c.Value, nil
}
最后就是session管理器创建session、读取session、写入session、销毁session、session GC等方法的定义，这些方法比较简单，只是调用session存储器对应的方法即可：
//创建session
func (sm *SessionManager) Create(writer *http.ResponseWriter, req *http.Request, data map[string]interface{}) error {
sessionId, _ := sm.getSessionId(req)
if len(sessionId) > 0 {
data, _ := sm.provider.getAll(sessionId)
if data != nil { //已有session，无需创建
return nil
}
}
sessionId = sm.createSessionId(req)
if len(sessionId) == 0 {
return errors.New("Length of sessionId is 0")
}
err := sm.provider.create(sessionId, data)
if err != nil {
return err
}
if sm.cookieExpire == 0 { //会话cookie
http.SetCookie(*writer, &http.Cookie{
Name: sm.cookieName,
Value: sessionId,
Path: "/", //一定要设置为根目录，才能在所有页面生效
HttpOnly: true,
})
} else { //持久cookie
expire, _ := time.ParseDuration(strconv.Itoa(sm.cookieExpire) + "m")
http.SetCookie(*writer, &http.Cookie{
Name: sm.cookieName,
Value: sessionId,
Path: "/", //一定要设置为根目录，才能在所有页面生效
Expires: time.Now().Add(expire),
HttpOnly: true,
})
}
return nil
}
//获取session键值
func (sm *SessionManager) Get(writer *http.ResponseWriter, req *http.Request, key string) (string, error) {
sessionId, _ := sm.getSessionId(req)
if len(sessionId) == 0 {
return "", errors.New("Length of sessionId is 0")
}
return sm.provider.get(sessionId, key)
}
//读取session所有键值对
func (sm *SessionManager) GetAll(writer *http.ResponseWriter, req *http.Request) (map[string]string, error) {
sessionId, _ := sm.getSessionId(req)
if len(sessionId) == 0 {
return nil, errors.New("Length of sessionId is 0")
}
return sm.provider.getAll(sessionId)
}
//设置session键值
func (sm *SessionManager) Set(writer *http.ResponseWriter, req *http.Request, key string, value interface{}) error {
sessionId, _ := sm.getSessionId(req)
if len(sessionId) == 0 {
return errors.New("Length of sessionId is 0")
}
return sm.provider.set(sessionId, key, value)
}
//销毁session
func (sm *SessionManager) Destroy(req *http.Request) error {
sessionId, _ := sm.getSessionId(req)
if len(sessionId) == 0 {
return errors.New("Length of sessionId is 0")
}
return sm.provider.destroy(sessionId)
}
//垃圾回收：删除过期session
func (sm *SessionManager) Gc() error {
err := sm.provider.gc(sm.sessionExpire)
duration, _ := time.ParseDuration(strconv.Itoa(sm.gcDuration) + "m")
time.AfterFunc(duration, func() { sm.Gc() }) //设置下次运行时间
return err
}
至此，我们已经实现session管理器！
接下来，不管使用什么方式存储session信息，只要实现SessionProvider接口，关心session数据的读写操作即可。
这里，我们实现一个文件session存储器，除了session文件保存路径，为了并发安全，每个session文件还需要对应一个读写锁，所以其结构可设计为：
//文件session存储器
type FileProvider struct {
savePath string //session文件保存路径
muxMap map[string]*sync.RWMutex //session文件锁
}
对应的创建方法：
//创建文件session存储器对象
func NewFileProvider(savePath string) *FileProvider {
return &FileProvider{
savePath: savePath,
muxMap: make(map[string]*sync.RWMutex),
}
}
所有方法都需要根据session ID得到文件路径，可定义共用方法：
//返回session文件名称
func (fp FileProvider) filename(sessionId string) string {
return fp.savePath + "/" + sessionId
}
写入session文件时，数据只能是字符串，而存入session的却不一定是字符串，所以需要一个将其他数据类型转换为字符串的共用方法：
//将数据类型转换为字符串
func (fp FileProvider) toString(value interface{}) (string, error) {
var str string
vType := reflect.TypeOf(value)
switch vType.Name() {
case "int":
i, _ := value.(int)
str = strconv.Itoa(i)
case "string":
str, _ = value.(string)
case "int64":
i, _ := value.(int64)
str = strconv.FormatInt(i, 10)
default:
return "", errors.New("Unsupported type: " + vType.Name())
}
return str, nil
}
文件session存储器的create、get、getAll、set等四个方法，本质上都是对session文件进行读写操作，可以将读和写抽取出来成为两个共用方法：
//创建/重写session文件
func (fp FileProvider) write(sessionId string, data map[string]string, newFile bool) error {
_, exist := fp.muxMap[sessionId]
if !exist { //内存中没有锁，先建锁
fp.muxMap[sessionId] = new(sync.RWMutex)
}
fp.muxMap[sessionId].Lock()
defer func() {
fp.muxMap[sessionId].Unlock()
}()
fname := fp.filename(sessionId)
_, err := os.Stat(fname)
var f *os.File
if newFile {
if err == nil { //若session文件存在，则先删除
os.Remove(fname)
}
f, err = os.Create(fname)
if err != nil {
return errors.New("Creating session file failed: " + err.Error())
}
} else {
if err != nil { //session文件不存在
return errors.New("Session file does not exists: " + fname)
}
f, err = os.OpenFile(fname, os.O_RDWR|os.O_TRUNC, 0644)
if err != nil {
return errors.New("Opening session file failed: " + err.Error())
}
}
defer func() {
os.Chtimes(fname, time.Now(), time.Now()) //更新文件最后访问时间
f.Close()
}()
for key, value := range data {
_, err = fmt.Fprintln(f, key+":"+value)
if err != nil {
return errors.New("Setting session key value failed: " + err.Error())
}
}
return nil
}
//读取session文件
func (fp FileProvider) read(sessionId string) (map[string]string, error) {
fname := fp.filename(sessionId)
_, err := os.Stat(fname)
if err != nil { //session文件不存在
return nil, errors.New("Session file does not exists: " + fname)
}
_, exist := fp.muxMap[sessionId]
if !exist { //内存中没有锁，先建锁
fp.muxMap[sessionId] = new(sync.RWMutex)
}
fp.muxMap[sessionId].Lock()
defer func() {
fp.muxMap[sessionId].Unlock()
}()
f, err := os.Open(fname)
if err != nil {
return nil, errors.New("Opening session file failed: " + err.Error())
}
defer func() {
os.Chtimes(fname, time.Now(), time.Now()) //更新文件最后访问时间
f.Close()
}()
data := make(map[string]string)
scaner := bufio.NewScanner(f)
for scaner.Scan() {
kv := strings.Split(scaner.Text(), ":")
if len(kv) != 2 {
continue
}
data[kv[0]] = kv[1]
}
if len(data) == 0 {
return nil, errors.New("No data in session file")
}
return data, nil
}
最后，实现SessionProvider接口的6个方法：
//创建session
func (fp FileProvider) create(sessionId string, data map[string]interface{}) error {
strData := make(map[string]string)
for key, value := range data {
strValue, err := fp.toString(value)
if err != nil {
return err
}
strData[key] = strValue
}
return fp.write(sessionId, strData, true)
}
//读取session键值
func (fp FileProvider) get(sessionId, key string) (string, error) {
data, err := fp.read(sessionId)
if err != nil {
return "", err
}
value, ok := data[key]
if !ok {
return "", errors.New("Session key does not exists: " + key)
}
return value, nil
}
//读取session所有键值对
func (fp FileProvider) getAll(sessionId string) (map[string]string, error) {
return fp.read(sessionId)
}
//设置session键值
func (fp FileProvider) set(sessionId, key string, value interface{}) error {
data, err := fp.read(sessionId)
if data == nil {
return err
}
str, err := fp.toString(value)
if err != nil {
return err
}
data[key] = str
return fp.write(sessionId, data, false)
}
//销毁session：删除session文件
func (fp FileProvider) destroy(sessionId string) error {
fname := fp.filename(sessionId)
_, err := os.Stat(fname)
if err != nil { //session文件不存在
return errors.New("Session file does not exists: " + fname)
}
_, exist := fp.muxMap[sessionId]
if !exist { //内存中没有锁，先建锁
fp.muxMap[sessionId] = new(sync.RWMutex)
}
fp.muxMap[sessionId].Lock()
err = os.Remove(fname)
fp.muxMap[sessionId].Unlock()
if err != nil {
return errors.New("Removing session file failed: " + err.Error())
}
delete(fp.muxMap, sessionId)
return nil
}
//垃圾回收：删除过期session文件
func (fp FileProvider) gc(expire int64) error {
now := time.Now().Unix()
for sessionId, mux := range fp.muxMap {
fname := fp.filename(sessionId)
if len(fname) == 0 {
continue
}
mux.Lock()
info, err := os.Stat(fname)
if err != nil {
mux.Unlock()
continue
}
modTime := info.ModTime().Unix() //文件最后访问时间
if modTime+expire*60 < now { //已超出过期时间
err = os.Remove(fname)
mux.Unlock()
if err != nil {
delete(fp.muxMap, sessionId)
}
} else {
mux.Unlock()
}
}
return nil
}
这样就完成了文件session存储器的实现。
当然我们也可以使用内存或数据库等其他方式进行session数据的存储，只需实现SessionProvider接口，并将其实例化对象赋值给session管理器创建方法的provider参数，即可实现不同存储方式的快速切换。