go web编程——session管理机制设计与实现

原生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参数，即可实现不同存储方式的快速切换。

巴特西

go web编程——session管理机制设计与实现

最新文章

热门文章