實戰,通過複寫shiro的SessionDAO來實現將session保存到redis集群中

作者：zifangsky

https://www.zifangsky.cn/889.html

如題所示，在分布式系統架構中需要解決的一個很重要的問題就是——如何保證各個應用節點之間的Session共享。現在通用的做法就是使用redis、memcached等組件獨立存儲所有應用節點的Session，以達到各個應用節點之間的Session共享的目的

在Java Web項目中實現session共享的一個很好的解決方案是：Spring Session+Spring Data Redis。關於這方面的內容可以參考我之前寫的這篇文章：https://www.zifangsky.cn/862.html

但是，如果在項目中使用到了shiro框架，並且不想使用Spring Session的話，那麼我們可以通過複寫shiro的SessionDAO同樣達到將shiro管理的session保存到redis集群的目的，以此解決分布式系統架構中的session共享問題

下面，我將詳細說明具體該如何來實現：

（1）配置Spring Data Redis環境：

關於Spring Data Redis環境的配置可以參考這篇文章：

https://www.zifangsky.cn/861.html

在這裡，我測試使用的是redis集群模式，當然使用redis單節點也可以

（2）複寫shiro的SessionDAO：

import java.io.Serializable;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

@Repository("customShiroSessionDao")
public class CustomShiroSessionDao extends EnterpriseCacheSessionDAO {

    @Resource(name="redisTemplate")
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 創建session，保存到redis集群中
     */
    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = super.doCreate(session);
        System.out.println("sessionId: " + sessionId);

        BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps("shiro_session_" + sessionId.toString());
        sessionValueOperations.set(session);
        sessionValueOperations.expire(30, TimeUnit.MINUTES);

        return sessionId;
    }

    /**
     * 獲取session
     * @param sessionId
     * @return
     */
    @Override
    protected Session doReadSession(Serializable sessionId) {
        Session session = super.doReadSession(sessionId);

        if(session == null){
            BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps("shiro_session_" + sessionId.toString());
            session = (Session) sessionValueOperations.get();
        }

        return session;
    }

    /**
     * 更新session
     * @param session
     */
    @Override
    protected void doUpdate(Session session) {
        super.doUpdate(session);

        BoundValueOperations<String, Object> sessionValueOperations = redisTemplate.boundValueOps("shiro_session_" + session.getId().toString());
        sessionValueOperations.set(session);
        sessionValueOperations.expire(30, TimeUnit.MINUTES);
    }

    /**
     * 刪除失效session
     */
    @Override
    protected void doDelete(Session session) {
        redisTemplate.delete("shiro_session_" + session.getId().toString());
        super.doDelete(session);
    }

}

具體含義可以參考注釋，這裡就不多做解釋了

（3）在shiro的配置文件中添加sessionManager：

    <!-- 使用redis存儲管理session -->
    <bean id="sessionManager"  
        class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager"> 
        <!-- 刪除失效session -->
        <property name="sessionValidationSchedulerEnabled" value="true" />  
        <!-- session失效時間（毫秒） --> 
        <property name="globalSessionTimeout" value="1800000" />
        <property name="sessionDAO" ref="customShiroSessionDao" />  
    </bean>

然後在securityManager中使用該sessionManager：

    <!-- Shiro安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="customRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="cacheManager" />
    </bean>

註：完整的shiro的配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/jee 
            http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop">
    <description>Shiro 配置</description>

    <context:component-scan base-package="cn.zifangsky.manager.impl" />
    <context:component-scan base-package="cn.zifangsky.shiro" />

    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManager" ref="cacheManagerFactory" />
        <property name="cacheManagerConfigFile" value="classpath:ehcache.xml" />
    </bean>

    <!-- 使用redis存儲管理session -->
    <bean id="sessionManager"  
        class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager"> 
        <!-- 刪除失效session -->
        <property name="sessionValidationSchedulerEnabled" value="true" />  
        <!-- session失效時間（毫秒） --> 
        <property name="globalSessionTimeout" value="1800000" />
        <property name="sessionDAO" ref="customShiroSessionDao" />  
    </bean>

    <!-- Shiro安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="customRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="cacheManager" />
    </bean>

    <!-- 自定義Realm -->
    <bean id="customRealm" class="cn.zifangsky.shiro.CustomRealm" />

    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="/user/user/login.html" />
        <!-- <property name="successUrl" value="/login/loginSuccessFull" /> -->
        <property name="unauthorizedUrl" value="/error/403.jsp" />
        <!-- <property name="filters">
            <map>
                <entry key="auth" value-ref="userFilter"/>
            </map>  
        </property> -->
        <property name="filterChainDefinitions">
            <value>
                /error/* = anon
                /scripts/* = anon
                /user/user/check.html = anon
                /user/user/verify.html = anon
                /user/user/checkVerifyCode.html = anon
                /user/user/logout.html = logout
                /**/*.htm* = authc
        /**/*.json* = authc
            </value>
        </property>
    </bean>

    <!-- <bean id="cleanFilter" class="cn.zifangsky.shiro.CleanFilter"/> -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

</beans>

（4）測試：i）本地簡單測試：

將同一項目部署到本地兩個不同埠的Tomcat中，然後在其中一個Tomcat登錄，接著直接在另一個Tomcat上訪問登錄後的URL，觀察是否可以直接訪問還是跳轉到登錄頁面

ii）完整分布式環境測試：

首先將測試項目部署到兩個伺服器上的Tomcat中，我這裡的訪問路徑分別是：

192.168.1.30:9080
192.168.1.31:9080

接著配置nginx訪問（PS：nginx所在IP是：192.168.1.31）：

server {
    server_name  localhost;
    listen 7888;

    location /WebSocketDemo
        {       
              proxy_redirect off;
              proxy_set_header        Host $host:7888;
              proxy_set_header        X-Real-IP $remote_addr;
              proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
              proxy_pass http://demo/WebSocketDemo;
              proxy_set_header   Cookie $http_cookie;
        }

    #access_log  on;
    limit_conn perip 1000;  #同一ip並發數為50,超過會返回503
    access_log logs/access_test.log zifangsky_log;
 }

對應的upstream是：

upstream demo {
  server 192.168.1.30:9080;
  server 192.168.1.31:9080;
}

從上面可以看出，這裡設置的nginx的負載均衡策略是默認策略——輪詢

最後在瀏覽器中訪問：http://192.168.1.31:7888/WebSocketDemo/user/user/login.html

登錄之後，不斷刷新頁面並觀察nginx的日誌：

可以發現，經過nginx的反向代理之後，雖然每次訪問的實際服務地址都不一樣，但是我們的登錄狀態並沒有丟失——並沒有跳轉到登錄頁面。這就證明了這個測試小集群的session的確實現了共享，也就是說session保存到了redis集群中，並不受具體的業務伺服器的更改而發生改變

當然，我們也可以登錄到redis集群，查詢一下該sessionId對應的session值：

參考：

http://www.cnblogs.com/sunshine-2015/p/5686750.html

Java面試題專欄

歡迎長按下圖關注公眾號後端技術精選