集群環境下的Session共享

一、Cookie機制和Session機制回顧

1）定義：Session成為“會話”，具體是指一個終端用戶與交互系統進行通信的時間間隔，通常指從注冊進入系統到注銷退出系統之間所經過的時間。Session實際上是一個特定的時間概念。

 

2）HTTP協議與狀態保持：HTTP 協議本身是無狀態的，這與HTTP協議本來的目的是相符的，客戶端只需要簡單的向服務器請求下載某些文件，無論是客戶端還是服務器都沒有必要紀錄彼此過去的行為，每一次請求之間都是獨立的，好比一個顧客和一個自動售貨機或者一個普通的（非會員制）大賣場之間的關系一樣。

 

cookie的作用就是為了解決HTTP協議無狀態的缺陷。至於后來出現的session機制則是又一種在客戶端與服務器之間保持狀態的解決方案。

 

3）Cookie和Session機制的區別和聯系（幾個有趣的例子）：

1、該店的店員很厲害，能記住每位顧客的消費數量，只要顧客一走進咖啡店，店員就知道該怎么對待了。這種做法就是協議本身支持狀態。

 

2、發給顧客一張卡片，上面記錄着消費的數量，一般還有個有效期限。每次消費時，如果顧客出示這張卡片，則此次消費就會與以前或以后的消費相聯系起來。這種做法就是在客戶端保持狀態。（Cookie原理）

 

3、發給顧客一張會員卡，除了卡號之外什么信息也不紀錄，每次消費時，如果顧客出示該卡片，則店員在店里的紀錄本上找到這個卡號對應的紀錄添加一些消費信息。這種做法就是在服務器端保持狀態。(Session原理)

 

由於HTTP協議是無狀態的，cookie機制采用的是在客戶端保持狀態的方案，而session機制采用的是在服務器端保持狀態的方案。同時我們也看到，由於采用服務器端保持狀態的方案在客戶端也需要保存一個標識，所以session機制可能需要借助於cookie機制來達到保存標識的目的，但實際上它還有其他選擇。

 

二、集群下實現Session共享的幾種方案

 

1.請求精確定位：基於IP地址的Hash策略，將同一用戶的請求都集中在一台服務器上，這台服務器上保存了該用戶的Session信息。缺點：單點部署發生宕機時，Session丟失。

 

2.Session復制共享：比如可以用Tomcat自帶的插件進行Session同步，使得多台應用服務器之間自動同步Session，保持一致。如果一台發生故障，負載均衡會遍歷尋找可用節點，Session也不會丟失。缺點：必須是Tomcat和Tomcat之間，Session的復制也會消耗系統 的性能，使得同步給成員時容易造成內網流量瓶頸。

 

3.基於cache DB緩存的Session共享（推薦，Spring-Session也是同樣的原理，同自定義的JRedis一起配置可以實現目的）:使用Redis存取Session信息，應用服務器發生故障時，當Session不在內存中時就會去CacheDB中查找（要求Redis支持持久化），找到則復制到本機，實現Session共享和高可用。

 

分布式Session配置原理圖

 

 

 

其他方式：利用公共的NFS服務器做共享服務器、完全利用Cookie(將Session數據全放在Cookie中)等。

 

三、基於Redis的Session共享實現（核心代碼）

 

1）原理：寫一個Session過濾器攔截每一次請求，在這里檢查由Cookie生成的SessionID，進行創建或獲取。核心是實現使用裝飾類，實現Session在Redis中的存取操作。

2）此處存取方式為 sessionID+sessionKey作為Redis的key  ==== sessionValue作為Redis的value，這樣保存了每次存取都從Redis中操作，效率更高。

3）注意：序列化方式推薦使用Apache下Commons組件——SerializationUtils 或 org.springframework.util.SerializationUtils

 

 1 //定義請求經過的Session過濾器
public class SessionFilter extends OncePerRequestFilter implements Filter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        // 從cookie中獲取sessionId，如果此次請求沒有sessionId，重寫為這次請求設置一個sessionId
        String sid = CookieUtil.getCookieValue(request, GlobalConstant.JSESSIONID);
        if (StringUtils.isEmpty(sid) || sid.length() != 36) {
            sid = UUID.randomUUID().toString();
            CookieUtil.setCookie(request, response, GlobalConstant.JSESSIONID, sid, 60 * 60);
        }
        // 交給自定義的HttpServletRequestWrapper處理
        filterChain.doFilter(new HttpServletRequestWrapper(sid, request, response), response);
    }
}

    //Cookie
    public static void setCookie(HttpServletRequest request,
            HttpServletResponse response, String name, String value, int seconds) {
        if (StringUtils.isEmpty(name) || StringUtils.isEmpty(value))
            return;
        Cookie cookie = new Cookie(name, value);
        //cookie.setDomain(domain);
        cookie.setMaxAge(seconds); 
        cookie.setPath("/");
        response.setHeader("P3P",
                "CP='IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT'");
        response.addCookie(cookie);
    }

    public String getCookieValue(String name)
            throws UnsupportedEncodingException {
        Cookie cookies[] = request.getCookies();
        if (cookies != null) {
            for (int i = 0; i < cookies.length; i++) {
                if (name.equalsIgnoreCase(cookies[i].getName())) {
                    return cookies[i].getValue();
                }
            }
        }
        return "";
    }

    //SessionService實現   sidKey == sessionID+SessionKey
    public Object getSession(String sidKey) {
        Object realValue = null;
        try {
            String key = “SESSION_DISTRIBUTED_SESSIONID” + sidKey;
            realValue = SerializeUtil.unserialize(RedisUtils.getInstance().get(key.getBytes()));
        } catch (Exception e) {
            LOG.error("Redis獲取session異常" + e.getMessage(), e.getCause());
        }
        return realValue;
    }

    public void saveSession(String sidKey, Object value) {
        try {
            String key = “SESSION_DISTRIBUTED_SESSIONID” + sidKey;
            boolean isSetSuccess = RedisUtils.getInstance().set(key.getBytes(), SerializeUtil.serialize(value));
            if (!isSetSuccess) {
                LOG.error("Redis保存session異常");
            }
        } catch (Exception e) {
            LOG.error("Redis保存session異常" + e.getMessage(), e.getCause());
        }
    }

    public void removeSession(String sidKey) {
        try {
            String key =“SESSION_DISTRIBUTED_SESSIONID”+ sidKey;
            RedisUtils.getInstance().del(key.getBytes());
        } catch (Exception e) {
            LOG.error("Redis刪除session的attribute異常" + e.getMessage(), e.getCause());
        }
    }

    public void removeAllSession(String sid) {
        try {
            String keyPattern =“SESSION_DISTRIBUTED_SESSIONID” + sid + "*";
            Set<byte[]> keys = RedisUtils.getInstance().keys(keyPattern.getBytes());
            for (byte[] key : keys) {
                RedisUtils.getInstance().del(key);
            }
        } catch (Exception e) {
            LOG.error("Redis刪除session異常" + e.getMessage(), e.getCause());
        }
    }

    public Set<String> getAllKeys(String sid) {
        try {
            Set<String> keysResult = new HashSet<String>();
            String keyPattern =“SESSION_DISTRIBUTED_SESSIONID” + sid + "*";
            Set<byte[]> keys = RedisUtils.getInstance().keys(keyPattern.getBytes());

            for (byte[] key : keys) {
                keysResult.add(new String(key));
            }
            return keysResult;
        } catch (Exception e) {
            LOG.error("Redis刪除session異常" + e.getMessage(), e.getCause());
            return null;
        }
    }

HttpServletRequestWrapper extends javax.servlet.http.HttpServletRequestWrapper
    private HttpSession session;

    private HttpServletRequest request;

    private HttpServletResponse response;

    private String sid = "";

    public HttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    public HttpServletRequestWrapper(String sid, HttpServletRequest request) {
        super(request);
        this.sid = sid;
    }

    public HttpServletRequestWrapper(String sid, HttpServletRequest request, HttpServletResponse response) {
        super(request);
        this.request = request;
        this.response = response;
        this.sid = sid;
        if (this.session == null) {
            this.session = new HttpSessionWrapper(sid, super.getSession(false), request, response);
        }
    }

    @Override
    public HttpSession getSession(boolean create) {
        if (this.session == null) {
            if (create) {
                this.session = new HttpSessionWrapper(this.sid, super.getSession(create), this.request, this.response);
                return this.session;
            } else {
                return null;
            }
        }
        return this.session;
    }

    @Override
    public HttpSession getSession() {
        if (this.session == null) {
            this.session = new HttpSessionWrapper(this.sid, super.getSession(), this.request, this.response);
        }
        return this.session;
    }

    HttpSessionWrapper implements HttpSession{

    private String sid = "";

    private HttpSession session;

    private HttpServletRequest request;

    private HttpServletResponse response;

    private SessionService sessionService = (SessionService) SpringContextHolder.getBean("sessionService");

    public HttpSessionWrapper() {
    }

    public HttpSessionWrapper(HttpSession session) {
        this.session = session;
    }

    public HttpSessionWrapper(String sid, HttpSession session) {
        this(session);
        this.sid = sid;
    }

    public HttpSessionWrapper(String sid, HttpSession session,
            HttpServletRequest request, HttpServletResponse response) {
        this(sid, session);
        this.request = request;
        this.response = response;
    }


    @Override
    public Object getAttribute(String name) {
        return sessionService.getSession(this.sid+"#"+name);
    }

    @Override
    public void setAttribute(String name, Object value) {
        sessionService.saveSession(this.sid+"#"+name, value);
    }

    @Override
    public void invalidate() {
        sessionService.removeAllSession(this.sid);
        CookieUtil.removeCookieValue(this.request,this.response, GlobalConstant.JSESSIONID);
    }

    @Override
    public void removeAttribute(String name) {
        sessionService.removeSession(this.sid+"#"+name); 
    }

    @Override
    public Object getValue(String name) {
        return this.session.getValue(name);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Enumeration getAttributeNames() {
        return (new Enumerator(sessionService.getAllKeys(this.sid), true));
    }

    @Override
    public String getId() {
        return this.sid;
    }
69    }