Redis實現分散式session功能的共享

阿新 • • 發佈：2018-12-25

最近專案設計叢集，實現了一下session的共享功能，其原理是將session儲存到分散式快取資料庫中如：redis， memcache等，然後多個伺服器tomcat
每次請求都通過NoSql資料庫查詢，如果存在，則獲取值；反之存放值。
我是通過redis來實現session的共享，其主要有一下兩種方法：
1、通過tomcat伺服器的拓展功能實現
    這種方式比較簡單，主要是通過繼承session的ManagerBase類，實現重寫session相關的方法，這種比較簡單，
    參考原始碼連結（http://download.csdn.net/detail/fengshizty/9417242）。
2、通過filter攔截request請求實現
    下面主要介紹這樣實現方式：
    （1）寫HttpSessionWrapper實現HttpSession介面，實現裡面session相關的方法。
    （2）寫HttpServletRequestWrapper繼承javax.servlet.http.HttpServletRequestWrapper類，重寫對於session  相關的方法。
    （3）寫SessionFilter攔截配置的請求url，過去cookie中
    的sessionId，如果為空，對此次請求重寫生成一個新的sessionId，在sessionId構造新的HttpServletRequestWrapper物件。
    （4）寫SessionService實現session到redis的儲存和過去，其key為sessionId，value為session對於的Map。
3、程式碼實現
    （1）HttpSessionWrapper

/**
 * 建立時間：2016年1月21日 下午7:55:41
 * 
 * @author andy
 * @version 2.2
 */

public class HttpSessionWrapper implements HttpSession {

    private String sid = "";

    private HttpSession session;

    private HttpServletRequest request;

    private HttpServletResponse response;

    private Map<String, Object> map = null 
;

    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;
    }

    private Map<String, Object> getSessionMap() {
        if (this.map == null) {
            this.map = sessionService.getSession(this.sid);
        }
        return this.map;
    }

    @Override
    public Object getAttribute(String name) {
        if (this.getSessionMap() != null) {
            Object value = this.getSessionMap().get(name);
            return value;
        }
        return null;
    }

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

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

    @Override
    public void removeAttribute(String name) {
        this.getSessionMap().remove(name);
        sessionService.saveSession(this.sid, this.getSessionMap()); 
    }

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

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

    @Override
    public String[] getValueNames() {
        return this.session.getValueNames();
    }

    @Override
    public void putValue(String name, Object value) {
        this.session.putValue(name, value);
    }

    @Override
    public void removeValue(String name) {
        this.session.removeValue(name);
    }

    @Override
    public long getCreationTime() {
        return this.session.getCreationTime();
    }

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

    @Override
    public long getLastAccessedTime() {
        return this.session.getLastAccessedTime();
    }

    @Override
    public ServletContext getServletContext() {
        return this.session.getServletContext();
    }

    @Override
    public void setMaxInactiveInterval(int interval) {
        this.session.setMaxInactiveInterval(interval);
    }

    @Override
    public int getMaxInactiveInterval() {
        return this.session.getMaxInactiveInterval();
    }

    @Override
    public HttpSessionContext getSessionContext() {
        return this.session.getSessionContext();
    }

    @Override
    public boolean isNew() {
        return this.session.isNew();
    }

}

（2）HttpServletRequestWrapper實現

/**
 * 建立時間：2016年1月22日 下午7:52:29
 * 
 * @author andy
 * @version 2.2
 */

public class 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;
    }

}

（3）SessionFilter攔截器的實現

public class SessionFilter extends OncePerRequestFilter implements Filter {

    private static final Logger LOG = Logger.getLogger(SessionFilter.class);

    @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 = StringUtil.getUuid();
            CookieUtil.setCookie(request, response, GlobalConstant.JSESSIONID, sid, 60 * 60); 
        }

        //交給自定義的HttpServletRequestWrapper處理
        filterChain.doFilter(new HttpServletRequestWrapper(sid, request, response), response);
    }

}

（4）SessionService實現session從redis的讀寫儲存

public class SessionService {

    private final static Logger LOG = Logger.getLogger(SessionService.class);

    private JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();

    @Autowired
    private RedisTemplate<Serializable, Serializable> redisTemplate;


    @SuppressWarnings("unchecked")
    public Map<String, Object> getSession(String sid) {
        Map<String, Object> session = new HashMap<String, Object>();
        try {
            Object obj = redisTemplate.opsForValue()
                    .get(RedisKeyUtil.SESSION_DISTRIBUTED_SESSIONID + sid);
            if(obj != null){
                obj = jdkSerializer.deserialize((byte[])obj);
                session = (Map<String, Object>) obj;
            }
        } catch (Exception e) {
            LOG.error("Redis獲取session異常" + e.getMessage(), e.getCause());
        }

        return session;
    }

    public void saveSession(String sid, Map<String, Object> session) {
        try {
            redisTemplates.opsForValue()
                    .set(RedisKeyUtil.SESSION_DISTRIBUTED_SESSIONID + sid,
                            jdkSerializer.serialize(session), RedisKeyUtil.SESSION_TIMEOUT,
                            TimeUnit.MINUTES);
        } catch (Exception e) {
            LOG.error("Redis儲存session異常" + e.getMessage(), e.getCause());
        }
    }

    public void removeSession(String sid) {
        try {
            redisTemplates.delete(
                    RedisKeyUtil.SESSION_DISTRIBUTED_SESSIONID + sid);
        } catch (Exception e) {
            LOG.error("Redis刪除session異常" + e.getMessage(), e.getCause());
        }
    }
}

（5）Session的攔截配置，一般的我們只需要攔截我們定義的攔截請求攔截，而不需要所有的都需要攔截。在web.xml中配置SessionFilter。

<filter>
        <filter-name>sessionFilter</filter-name>
        <filter-class>org.andy.shop.session.SessionFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>sessionFilter</filter-name>
        <url-pattern>*.do</url-pattern>
    </filter-mapping>

附：設計到的工具類

1、StringUtil工具類

/**
 * String工具類
 * 
 * @author andy
 * @date 2015-5-16 下午4:04:22
 * 
 */
public class StringUtil {

    private StringUtil() {
        super();
    }

    /**
     * 出去null和""
     * @param src
     * @return
     */
    public static String formatNull(String src) {
        return (src == null || "null".equals(src)) ? "" : src;
    }

    /**
     * 判斷字串是否為空的正則表示式，空白字元對應的unicode編碼
     */
    private static final String EMPTY_REGEX = "[\\s\\u00a0\\u2007\\u202f\\u0009-\\u000d\\u001c-\\u001f]+";

    /**
     * 驗證字串是否為空
     * 
     * @param input
     * @return
     */
    public static boolean isEmpty(String input) {
        return input == null || input.equals("") || input.matches(EMPTY_REGEX);
    }

    public static boolean isNotEmpty(String input){
        return !isEmpty(input);
    }

    public static String getUuid() {
        return UUID.randomUUID().toString();
    }
}

2、Cookie管理CookieUtil工具類

/**
 * 建立時間：2016年1月22日 下午8:33:56
 * 
 * @author andy
 * @version 2.2
 */

public class CookieUtil {
    private static final String KEY = "jkdflsffff()kldkjapfdY=::$B+DUOWAN";

    private HttpServletRequest request;

    private HttpServletResponse response;

    private static String domain = "andy.com";

    public CookieUtil(HttpServletRequest request, HttpServletResponse response) {
        this.request = request;
        this.response = response;
    }

    /**
     * 儲存cookie
     * @param request
     * @param response
     * @param name cookie名稱
     * @param value cookie值
     * @param seconds 過期時間(單位秒) -1代表關閉瀏覽器時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);
    }

    /**
     * 過去cookie中儲存的值
     * @param name
     * @return
     * @throws UnsupportedEncodingException
     */
    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 "";
    }

    /**
     * 設定加密的cookie
     * @param name cookie名稱
     * @param value cookie值
     * @param seconds 過期時間 -1代表關閉瀏覽器時cookie即過期
     */
    public void setCheckCodeCookie(String name, String value, int seconds) {
        if (StringUtils.isEmpty(name) || StringUtils.isEmpty(value)) {
            return;
        }
        String md5Value = MD5Utils.getMD5(KEY + value);
        Cookie cookie = new Cookie(name, md5Value);
        //cookie.setDomain(domain);
        cookie.setMaxAge(seconds);
        cookie.setPath("/");
        response.addCookie(cookie);
    }

    /**
     * 校驗加密的cookie
     * @param name
     * @param value
     * @return
     */
    public boolean checkCodeCookie(String name, String value) {
        if (StringUtils.isEmpty(name) || StringUtils.isEmpty(value)) {
            return false;
        }
        boolean result = false;
        String cookieValue = getCookieValue(request, name);
        if (MD5Utils.getMD5(KEY + value).equalsIgnoreCase(
                cookieValue)) {
            result = true;
        }
        return result;
    }

    /**
     * 獲取cookie值
     * @param request
     * @param name
     * @return
     */
    public static String getCookieValue(HttpServletRequest request, String name) {
        try {
            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();
                    }
                }
            }
        } catch (Exception e) {
        }
        return "";
    }

    /**
     * 移除客戶端的cookie
     * @param request
     * @param response
     * @param name
     */
    public static void removeCookieValue(HttpServletRequest request,
            HttpServletResponse response, String name) {
        try {
            Cookie cookies[] = request.getCookies();
            if (cookies != null && cookies.length > 0) {
                for (Cookie cookie : cookies) {
                    if (name.equalsIgnoreCase(cookie.getName())) {
                        cookie = new Cookie(name, null);
                        cookie.setMaxAge(0);
                        cookie.setPath("/");
                        //cookie.setDomain(domain);
                        response.addCookie(cookie);
                        break;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3、redis鍵key設定類RedisKeyUtil

/**
 * 建立時間：2015年9月22日 下午4:51:11
 * 
 * @author andy
 * @version 2.2
 */

public class RedisKeyUtil {

    public static final String SESSION_DISTRIBUTED_SESSIONID = "session:distributed:"; //分散式session sessionid -- sessionvalue

    public static final Integer SESSION_TIMEOUT = 2; //session 失效時間2小時

}

4、分散式session常量設定類GlobalConstant

/**
 * 建立時間：2016年1月23日 上午11:16:56
 * 
 * 分散式session常量
 * 
 * @author andy
 * @version 2.2
 */

public class GlobalConstant {

    public static final String USER_SESSION_KEY = "user_session_key";//使用者session資訊

    public static final String JSESSIONID = "YHMJSESSIONID"; //jsessionid
}

分散式session在redis執行結果：
redis中session儲存結果

Redis實現分散式session功能的共享

最近專案設計叢集，實現了一下session的共享功能，其原理是將session儲存到分散式快取資料庫中如：redis， memcache等，然後多個伺服器tomcat 每次請求都通過NoSql資料庫查詢，如果存在，則獲取值；反之存放值。我是通過redis來實現

springboot+redis實現分散式session共享

官方文件，它是spring session專案的redis相關的一個子文件：https://docs.spring.io/spring-session/docs/2.0.0.BUILD-SNAPSHOT/reference/html5/guides/boot

Spring Session + Redis實現分散式Session共享

通常情況下，Tomcat、Jetty等Servlet容器，會預設將Session儲存在記憶體中。如果是單個伺服器例項的應用，將Session儲存在伺服器記憶體中是一個非常好的方案。但是這種方案有一個缺點，就是不利於擴充套件。目前越來越多的應用採用分散式部署，

SpringBoot整合Shiro，許可權的動態載入、更新，Shiro-Redis實現分散式Session共享

本文章是介紹SpringBoot整合Apache Shiro，並實現在專案啟動時從資料庫中讀取許可權列表，在對角色進行增刪改時，動態更新許可權以及在分散式環境下的Session共享，Session共享使用的是shiro-redis框架，是根據真實專案寫的一個Demo。網上有很

redis實現分散式session共享

在講解redis分散式session共享之前，我們先聊聊tomcat中session管理機制，包括：請求過程中session操作，sessionid解析過程，servlet獲取session流程，以及tomca中session的管理機制。 Tomcat session管理機制請求過程中的session操

Redis學習筆記~StackExchange.Redis實現分散式Session

回到目錄對於多WEB的環境現在已經是必須的了，很難想像一臺WEB伺服器面對百萬併發的響應，所以，我們需要多臺WEB伺服器叢集合作，來緩解這種高併發，高吞吐的場景，而對於多WEB的場景又會有個問題出現，即session儲存的問題，如一個使用者登陸後，把一個狀態資訊儲存到當前WEB伺服器的session裡，而

shiro整合redis實現分散式session和單點登入

shiro是一款出色的許可權框架，能夠實現諸如登入校驗、許可權校驗等功能，預設情況下,shir將session儲存到記憶體中，這在應用分散式部署的情況下會出現session不一致的問題，所以我們要將session儲存到第三方，應用始終從第三方獲取session，從而保證分散式

shiro（四）整合redis實現分散式session

一、前言前面的文章中，shiro使用的是ehcache做快取，這樣在單機服務中，沒有任何問題，但是如果是在叢集環境下，就無法實現session共享了。分散式session有多種實現方式： 1. Session Replication 方式管理 (即session複製)

C# 基於StackExchange.Redis.dll利用Redis實現分散式Session

最近在研發一款O2O產品，考慮到分散式架構的需要，以前那一套.NET的Session管理方式已經不合用了。遂研究了一下Redis，發現基於這種Key-Value的記憶體資料庫很適合來做分散式Session。本示例將基於StackExchange.Redis.dll進行實現，

Spring Boot 整合Spring Session 通過Redis實現分散式共享Session

一、首先我們要引入依賴，修改pom.xml新增： //引入spring session <dependency> <groupId>org.springframework.session</groupId> <artifactId>

asp.net mvc 用Redis實現分散式叢集共享Session

1、這兩天研究Redis搞分散式session問題，網上找的資料都是用ServiceStack.Redis來實現的，但是在做效能測試的時候發現最新的v4版本有限制每小時候最多請求6000次，因為官網開始商業化要收費了，好坑爹的說，還好我前期弄了個性能測試列子，不然上線以後

Shiro許可權管理框架（二）：Shiro結合Redis實現分散式環境下的Session共享

首發地址：https://www.guitu18.com/post/2019/07/28/44.html 本篇是Shiro系列第二篇，使用Shiro基於Redis實現分散式環境下的Session共享。在講Session共享之前先說一下為什麼要做Session共享。為什麼要做Session共享什麼是Ses

spring+redis自主實現分散式session（非spring-session方式）

背景：最近對一個老專案進行改造，使其支援多機部署，其中最關鍵的一點就是實現多機session共享。專案有多老呢，jdk版本是1.6，spring版本是3.2，jedis版本是2.2。 1.方案的確定接到這專案任務後，理所當然地google了，一搜索，發現結果分為兩大類： tomcat的session管

shiro+redis實現叢集session共享

1.加入依賴 <dependency> <groupId>org.crazycake</groupId> <artifactId>shiro-redis</artifactId> <version>2.4.

Java秒殺系統方案優化 2 --第2章實現使用者登入以及分散式session功能

第2章實現使用者登入以及分散式session功能 1. 明文密碼兩次md5入庫分別使用簽名如1a2b3c4d，分別用簽名和密碼使用MD5加密兩次後（一次是最原始密碼加密，一次是加密後再使用MD5和簽名加密）才存入資料庫，每個使用者對應都有一個欄位，例如本案例中的sa

Redis實現分散式儲存Session

前言: 在單個專案時,一般都是用HttpSession介面儲存當前登入使用者的資訊。但是在分散式專案的情況下，session是不會共享的，那怎麼實現session共享呢？往下看。。。。一、準備工作（基於centos7）　　1.linux版本的redis 下載地址：http://download.re

spring session redis 實現叢集session共享,SessionListener監聽生效

pom主要配置 <properties> <spring.version>5.0.3.RELEASE</spring.version> <commons-lang.version

【redis學習之六】基於Redis的分散式session實現

在web應用中，我們經常會用session來儲存已登入使用者的相關資訊，在單機應用中，由於所有的使用者都訪問同一個應用，而session都儲存在此單機應用中所以並無不妥。但是隨著使用者併發量的上升，分散式系統勢在必行，這就導致一個使用者的訪問請求可能會分發到不同的叢集部署

詳解基於Spring Boot/Spring Session/Redis的分散式Session共享解決方案

分散式Web網站一般都會碰到叢集session共享問題，之前也做過一些Spring3的專案，當時解決這個問題做過兩種方案，一是利用nginx，session交給nginx控制，但是這個需要額外工作較多；還有一種是利用一些tomcat上的外掛，修改tomcat配置檔案，讓tom

spring-session實現分散式session共享及自定義sessionid

public class MyHttpSessionStrategy implements HttpSessionStrategy { private final Logger logger = LoggerFactory.getLogger(WlwHttpSessionStrategy.class

Redis實現分散式session功能的共享

相關推薦