用户和session模块以及登录功能，大概思路是这样的
1)用户密码登录时，在后台的req中记住session.
2)如果用户保存登录密码，则记住cookie，否则把当前用户的cookie设置为空;
3)每次用户需要向后台进行请求时，进行状态检验：
1.判断session是否存在？
2.若session存在，则继续进行请求操作，并将session的有效时间重新设置一次；
3.若session不存在，则判断cookie是否存在?
4.若cookie存在，使用该cookie完成自动登录;

一、中间件(拦截器)

对于C#玩家来说，go的拦截器真是苦恼了我半天，因为搜了半天也没有一个能实现拦截器的框架，后来才恍然大悟的发现原来中间件可以实现类似的功能。
先在router中添加一个全局中间件

//router.go
package main

import (
    "net/http"

    "./MiddleWare"

    "./FPList"
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
)

func RouterInit(router *gin.Engine) {
    router.Use(cors.Default())
    router.Use(MiddleWare.IsLogin(c * gin.Context))
    router.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "It works On 8081")
    })
    router.GET("/Login", FPList.GetList)
    router.GET("/FPList", FPList.GetList)
}

简述Gorilla/session

首先有个问题，golang本身并没有封装session的操作，Gorilla的session包是个不错的选择。

import ("github.com/gorilla/sessions")

点开源码看了一下，interface只暴露了Get，New，Save三个方法，而在上面逻辑中我们需要重新设计session的时间，可是session包中并没有暴露该方法，只是在new的时候设置了默认值。

//store.go
func NewCookieStore(keyPairs ...[]byte) *CookieStore {
    cs := &CookieStore{
        Codecs: securecookie.CodecsFromPairs(keyPairs...),
        Options: &Options{
            Path:   "/",
            MaxAge: 86400 * 30,
        },
    }

    cs.MaxAge(cs.Options.MaxAge)
    return cs
}

如果我们想修改时间的话就需要一个修改时间的方法，在源码122行惊喜的看到了MaxAge方法，直接在接口里添加就好了。

//store.go
// Store is an interface for custom session stores.
//
// See CookieStore and FilesystemStore for examples.
type Store interface {
    // Get should return a cached session.
    Get(r *http.Request, name string) (*Session, error)

    // New should create and return a new session.
    //
    // Note that New should never return a nil session, even in the case of
    // an error if using the Registry infrastructure to cache the session.
    New(r *http.Request, name string) (*Session, error)

    // Save should persist session to the underlying store implementation.
    Save(r *http.Request, w http.ResponseWriter, s *Session) error

    //暴露MaxAge方法，默认时长为86400 * 30
    MaxAge(age int)
}

另一种思路是直接添加一个Delete方法，删除以后重新添加一遍session，效果是一样的。
话题转回来，以学习的态度还是希望尽可能了解一下Session具体怎么实现的。
下面是sessionManager的实现思路及代码：
（链接：http://wiki.jikexueyuan.com/project/go-web-programming/06.2.html）

session管理器

//sessionManager.go
type Manager struct {
    cookieName  string     //private cookiename
    lock        sync.Mutex // protects session
    provider    Provider
    maxlifetime int64
}

func NewManager(provideName, cookieName string, maxlifetime int64) (*Manager, error) {
    provider, ok := provides[provideName]
    if !ok {
        return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", provideName)
    }
    return &Manager{provider: provider, cookieName: cookieName, maxlifetime: maxlifetime}, nil
}

定义了一个全局管理器以后，在main函数中实例化一下

//main.go
var globalSessions *session.Manager
//然后在init函数中初始化
func init() {
    globalSessions, _ = NewManager("memory","gosessionid",3600)
}

我们知道session是保存在服务器端的数据，它可以以任何的方式存储，比如存储在内存、数据库或者文件中。因此我们抽象出一个Provider接口，用以表征session管理器底层存储结构。

//sessionManager.go
type Provider interface {
    //SessionInit函数实现Session的初始化，操作成功则返回此新的Session变量
    SessionInit(sid string) (Session, error)
    //SessionRead函数返回sid所代表的Session变量，
    //如果不存在，那么将以sid为参数调用SessionInit函数创建并返回一个新的Session变量
    SessionRead(sid string) (Session, error)
    //SessionDestroy函数用来销毁sid对应的Session变量
    SessionDestroy(sid string) error
    //SessionGC根据maxLifeTime来删除过期的数据
    SessionGC(maxLifeTime int64)
}

那么Session接口需要实现什么样的功能呢？有过Web开发经验的读者知道，对Session的处理基本就 设置值、读取值、删除值以及获取当前sessionID这四个操作，所以我们的Session接口也就实现这四个操作。

//sessionManager.go
type Session interface {
    Set(key, value interface{}) error //set session value
    Get(key interface{}) interface{}  //get session value
    Delete(key interface{}) error     //delete session value
    SessionID() string                //back current sessionID
}

先定义好接口，然后具体的存储session的结构实现相应的接口并注册后，相应功能这样就可以使用了，以下是用来随需注册存储session的结构的Register函数的实现。

//sessionManager.go
var provides = make(map[string]Provider)

// Register makes a session provide available by the provided name.
// If Register is called twice with the same name or if driver is nil,
// it panics.
func Register(name string, provider Provider) {
    if provider == nil {
        panic("session: Register provide is nil")
    }
    if _, dup := provides[name]; dup {
        panic("session: Register called twice for provide " + name)
    }
    provides[name] = provider
}

全局唯一的Session ID

Session ID是用来识别访问Web应用的每一个用户，因此必须保证它是全局唯一的（GUID），下面代码展示了如何满足这一需求：

func (manager *Manager) sessionId() string {
    b := make([]byte, 32)
    if _, err := io.ReadFull(rand.Reader, b); err != nil {
        return ""
    }
    return base64.URLEncoding.EncodeToString(b)
}

//IsLogin.go
package MiddleWare

import (
    "github.com/gin-gonic/gin"
    "github.com/gorilla/sessions"
)

var store *sessions.CookieStore

func init() {
    // cookie加密秘钥
    store = sessions.NewCookieStore([]byte("something-very-secret"))

}

func IsLogin(c *gin.Context) string {

    //2.若session存在，则继续进行请求操作，并将session的有效时间重新设置一次；
    //3.若session不存在，则判断cookie是否存在?
    //4.若cookie存在，使用该cookie完成自动登录;
    session, err := store.Get(c.Request, "session-name")
    // if err != nil {
    //  http.Error(w, err.Error(), http.StatusInternalServerError)
    //  return
    // }
    // if session != nil {

    // } else {

    // }
    return ""
}