ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > IT综合 > 分布式集群系统下的高可用session解决方案---Session共享

分布式集群系统下的高可用session解决方案---Session共享

IT综合 作者：xz43 时间：2016-05-18 23:40:13 0 删除 编辑

 Apache Shiro集群要解决2个问题，一个是session的共享问题，一个是授权信息的cache共享问题，官网给的例子是Ehcache的实现，在配置说明上不算很详细，我这里用nosql（redis）替代了ehcache做了session和cache的存储。


shiro spring的默认配置（单机，非集群）



[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;"><bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">    
  2.     <property name="realm" ref="shiroDbRealm" />    
  3.     <property name="cacheManager" ref="memoryConstrainedCacheManager" />    
  4. </bean>    
  5.     
  6. <!-- 自定义Realm -->    
  7. <bean id="shiroDbRealm" class="com.xxx.security.shiro.custom.ShiroDbRealm">    
  8.     <property name="credentialsMatcher" ref="customCredentialsMather"></property>    
  9. </bean>     
  10. <!-- 用户授权信息Cache（本机内存实现） -->    
  11. <bean id="memoryConstrainedCacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager" />      
  12.     
  13. <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->    
  14. <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>    
  15.     
  16. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">    
  17.     <property name="securityManager" ref="securityManager" />    
  18.     <property name="loginUrl" value="/login" />    
  19.     <property name="successUrl" value="/project" />    
  20.     <property name="filterChainDefinitions">    
  21.         <value>    
  22.         /login = authc    
  23.         /logout = logout                
  24.     </value>    
  25.     </property>    
  26. </bean> </span></span>  

上面的配置是shiro非集群下的配置，DefaultWebSecurityManager类不需要注入sessionManager属性，它会使用默认的sessionManager类，请看源码




[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">    public DefaultWebSecurityManager() {    
  2.             super();    
  3.             ((DefaultSubjectDAO) this.subjectDAO).setSessionStorageEvaluator(new DefaultWebSessionStorageEvaluator());    
  4.             this.sessionMode = HTTP_SESSION_MODE;    
  5.             setSubjectFactory(new DefaultWebSubjectFactory());    
  6.             setRememberMeManager(new CookieRememberMeManager());    
  7.             setSessionManager(new ServletContainerSessionManager());    
  8.     }  </span></span>  

在最后一行，set了默认的servlet容器实现的sessionManager，sessionManager会管理session的创建、删除等等。如果我们需要让session在集群中共享，就需要替换这个默认的sessionManager。在其官网上原话是这样的：




[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">    Native Sessions    
  2.         
  3.     If you want your session configuration settings and clustering to be portable across servlet containers    
  4.     (e.g. Jetty in testing, but Tomcat or JBoss in production), or you want to control specific session/clustering     
  5.     features, you can enable Shiro's native session management.    
  6.         
  7.     The word 'Native' here means that Shiro's own enterprise session management implementation will be used to support     
  8.     all Subject and HttpServletRequest sessions and bypass the servlet container completely. But rest assured - Shiro     
  9.     implements the relevant parts of the Servlet specification directly so any existing web/http related code works as     
  10.     expected and never needs to 'know' that Shiro is transparently managing sessions.    
  11.         
  12.     DefaultWebSessionManager    
  13.         
  14.     To enable native session management for your web application, you will need to configure a native web-capable     
  15.     session manager to override the default servlet container-based one. You can do that by configuring an instance of     
  16.     DefaultWebSessionManager on Shiro's SecurityManager.   </span></span>  

我们可以看到如果要用集群，就需要用本地会话，这里shiro给我准备了一个默认的native session manager，DefaultWebSessionManager，所以我们要修改spring配置文件，注入DefaultWebSessionManager




[plain] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">    
  2.         <property name="sessionManager" ref="defaultWebSessionManager" />    
  3.         <property name="realm" ref="shiroDbRealm" />    
  4.         <property name="cacheManager" ref="memoryConstrainedCacheManager" />    
  5.     </bean>    
  6.     <bean id="defaultWebSessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">    
  7.         <property name="globalSessionTimeout" value="1200000" />    
  8.     </bean>    
我们继续看DefaultWebSessionManager的源码，发现其父类DefaultSessionManager中有sessionDAO属性，这个属性是真正实现了session储存的类，这个就是我们自己实现的redis session的储存类。




[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">    protected SessionDAO sessionDAO;    
  2.         
  3.     private CacheManager cacheManager;    
  4.         
  5.     private boolean deleteInvalidSessions;    
  6.         
  7.     public DefaultSessionManager() {    
  8.         this.deleteInvalidSessions = true;    
  9.         this.sessionFactory = new SimpleSessionFactory();    
  10.         this.sessionDAO = new MemorySessionDAO();    
  11.     }    

这里我们看到了，如果不自己注入sessionDAO，defaultWebSessionManager会使用MemorySessionDAO做为默认实现类，这个肯定不是我们想要的，所以这就自己动手实现sessionDAO吧。




[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">package com.tgb.itoo.authority.cache;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.Collection;  
  5. import java.util.HashSet;  
  6. import java.util.Set;  
  7.   
  8. import org.apache.shiro.session.Session;  
  9. import org.apache.shiro.session.UnknownSessionException;  
  10. import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;  
  11. import org.slf4j.Logger;  
  12. import org.slf4j.LoggerFactory;  
  13.   
  14. public class RedisSessionDAO extends AbstractSessionDAO {  
  15.   
  16.     private static Logger logger = LoggerFactory.getLogger(RedisSessionDAO.class);  
  17.     /** 
  18.      * shiro-redis的session对象前缀 
  19.      */  
  20.     private RedisManager redisManager;  
  21.       
  22.     /** 
  23.      * The Redis key prefix for the sessions  
  24.      */  
  25.     private String keyPrefix = "shiro_redis_session:";  
  26.       
  27.     @Override  
  28.     public void update(Session session) throws UnknownSessionException {  
  29.         this.saveSession(session);  
  30.     }  
  31.       
  32.     /** 
  33.      * save session 
  34.      * @param session 
  35.      * @throws UnknownSessionException 
  36.      */  
  37.     private void saveSession(Session session) throws UnknownSessionException{  
  38.         if(session == null || session.getId() == null){  
  39.             logger.error("session or session id is null");  
  40.             return;  
  41.         }  
  42.           
  43.         byte[] key = getByteKey(session.getId());  
  44.         byte[] value = SerializeUtils.serialize(session);  
  45.         session.setTimeout(redisManager.getExpire()*1000);        
  46.         this.redisManager.set(key, value, redisManager.getExpire());  
  47.     }  
  48.   
  49.     @Override  
  50.     public void delete(Session session) {  
  51.         if(session == null || session.getId() == null){  
  52.             logger.error("session or session id is null");  
  53.             return;  
  54.         }  
  55.         redisManager.del(this.getByteKey(session.getId()));  
  56.   
  57.     }  
  58.   
  59.     //用来统计当前活动的session  
  60.     @Override  
  61.     public Collection<Session> getActiveSessions() {  
  62.         Set<Session> sessions = new HashSet<Session>();  
  63.           
  64.         Set<byte[]> keys = redisManager.keys(this.keyPrefix + "*");  
  65.         if(keys != null && keys.size()>0){  
  66.             for(byte[] key:keys){  
  67.                 Session s = (Session)SerializeUtils.deserialize(redisManager.get(key));  
  68.                 sessions.add(s);  
  69.             }  
  70.         }  
  71.           
  72.         return sessions;  
  73.     }  
  74.   
  75.     @Override  
  76.     protected Serializable doCreate(Session session) {  
  77.         Serializable sessionId = this.generateSessionId(session);    
  78.         this.assignSessionId(session, sessionId);  
  79.         this.saveSession(session);  
  80.         return sessionId;  
  81.     }  
  82.   
  83.     @Override  
  84.     protected Session doReadSession(Serializable sessionId) {  
  85.         if(sessionId == null){  
  86.             logger.error("session id is null");  
  87.             return null;  
  88.         }  
  89.           
  90.         Session s = (Session)SerializeUtils.deserialize(redisManager.get(this.getByteKey(sessionId)));  
  91.         return s;  
  92.     }  
  93.       
  94.     /** 
  95.      * 获得byte[]型的key 
  96.      * @param key 
  97.      * @return 
  98.      */  
  99.     private byte[] getByteKey(Serializable sessionId){  
  100.         String preKey = this.keyPrefix + sessionId;  
  101.         return preKey.getBytes();  
  102.     }  
  103.   
  104.     public RedisManager getRedisManager() {  
  105.         return redisManager;  
  106.     }  
  107.   
  108.     public void setRedisManager(RedisManager redisManager) {  
  109.         this.redisManager = redisManager;  
  110.           
  111.         /** 
  112.          * 初始化redisManager 
  113.          */  
  114.         this.redisManager.init();  
  115.     }  
  116.   
  117.     /** 
  118.      * Returns the Redis session keys 
  119.      * prefix. 
  120.      * @return The prefix 
  121.      */  
  122.     public String getKeyPrefix() {  
  123.         return keyPrefix;  
  124.     }  
  125.   
  126.     /** 
  127.      * Sets the Redis sessions key  
  128.      * prefix. 
  129.      * @param keyPrefix The prefix 
  130.      */  
  131.     public void setKeyPrefix(String keyPrefix) {  
  132.         this.keyPrefix = keyPrefix;  
  133.     }  
  134. }  
  135.   


我们自定义RedisSessionDAO继承AbstractSessionDAO，实现对session操作的方法，可以用redis、mongoDB等进行实现。



这个是自己redis的RedisCacheManager存储实现类：



[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><span style="font-size:18px;">package com.tgb.itoo.authority.cache;  
  2.   
  3. import java.util.concurrent.ConcurrentHashMap;  
  4. import java.util.concurrent.ConcurrentMap;  
  5.   
  6. import org.apache.shiro.cache.Cache;  
  7. import org.apache.shiro.cache.CacheException;  
  8. import org.apache.shiro.cache.CacheManager;  
  9. import org.slf4j.Logger;  
  10. import org.slf4j.LoggerFactory;  
  11.   
  12. public class RedisCacheManager implements CacheManager{  
  13.   
  14.     private static final Logger logger = LoggerFactory  
  15.             .getLogger(RedisCacheManager.class);  
  16.   
  17.     // fast lookup by name map  
  18.     private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap<String, Cache>();  
  19.   
  20.     private RedisManager redisManager;  
  21.   
  22.     /** 
  23.      * The Redis key prefix for caches  
  24.      */  
  25.     private String keyPrefix = "shiro_redis_cache:";  
  26.       
  27.     /** 
  28.      * Returns the Redis session keys 
  29.      * prefix. 
  30.      * @return The prefix 
  31.      */  
  32.     public String getKeyPrefix() {  
  33.         return keyPrefix;  
  34.     }  
  35.   
  36.     /** 
  37.      * Sets the Redis sessions key  
  38.      * prefix. 
  39.      * @param keyPrefix The prefix 
  40.      */  
  41.     public void setKeyPrefix(String keyPrefix) {  
  42.         this.keyPrefix = keyPrefix;  
  43.     }  
  44.       
  45.     @Override  
  46.     public <K, V> Cache<K, V> getCache(String name) throws CacheException {  
  47.         logger.debug("获取名称为: " + name + " 的RedisCache实例");  
  48.           
  49.         Cache c = caches.get(name);  
  50.           
  51.         if (c == null) {  
  52.   
  53.             // initialize the Redis manager instance  
  54.             redisManager.init();  
  55.               
  56.             // create a new cache instance  
  57.             c = new RedisCache<K, V>(redisManager, keyPrefix);  
  58.               
  59.             // add it to the cache collection  
  60.             caches.put(name, c);  
  61.         }  
  62.         return c;  
  63.     }  
  64.   
  65.     public RedisManager getRedisManager() {  
  66.         return redisManager;  
  67.     }  
  68.   
  69.     public void setRedisManager(RedisManager redisManager) {  
  70.         this.redisManager = redisManager;  
  71.     }  
  72. }  
  73.   


这样RedisSessionDAO我们就完成了，下面继续修改我们spring配置文件：



[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee"  
  5.     xmlns:context="http://www.springframework.org/schema/context"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  7.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
  8.     http://www.springframework.org/schema/aop   
  9.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
  10.     http://www.springframework.org/schema/tx    
  11.     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   
  12.     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd  
  13.     http://www.springframework.org/schema/context  
  14.     http://www.springframework.org/schema/context/spring-context-3.0.xsd"  
  15.     default-lazy-init="true">  
  16.   
  17.     <!-- 注解支持 -->  
  18.     <context:annotation-config />  
  19.     <bean id="propertyConfigurer"  
  20.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  21.         <property name="locations">  
  22.             <list>  
  23.                 <value>classpath:config/shiro-cas.properties</value>  
  24.             </list>  
  25.         </property>  
  26.     </bean>  
  27.       
  28.       
  29.       
  30.     <jee:local-slsb id="PermissionManager"  
  31.         jndi-name="java:global/itoo-authority-role-ear/itoo-authority-shiro-core-0.0.1-SNAPSHOT/PermissionManager!com.tgb.itoo.authority.service.ShiroBean"  
  32.         business-interface="com.tgb.itoo.authority.service.ShiroBean"></jee:local-slsb>  
  33.   
  34. <!--     <jee:jndi-lookup id="PermissionManager" -->  
  35.   
  36. <!--     jndi-name="ejb:itoo-authority-shiro-ear/itoo-authority-shiro-core-0.0.1-SNAPSHOT/PermissionManager!com.tgb.itoo.authority.service.ShiroBean" -->  
  37.   
  38. <!--     lookup-on-startup="true" cache="true" environment-ref="evn"> -->  
  39.   
  40. <!--     </jee:jndi-lookup> -->  
  41.     <!-- shiro过滤器 start -->  
  42.     <bean id="shiroSecurityFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
  43.         <property name="securityManager" ref="securityManager"></property>  
  44.         <property name="loginUrl" value="${loginUrl}"></property>  
  45.         <property name="successUrl" value="${successUrl}"></property>  
  46.         <property name="filters">  
  47.             <map>  
  48.                 <entry key="casFilter">  
  49.                     <bean class="org.apache.shiro.cas.CasFilter">  
  50.                         <!--配置验证错误时的失败页面 /main 为系统登录页面 -->  
  51.                         <property name="failureUrl" value="/message.jsp" />  
  52.                     </bean>  
  53.                 </entry>  
  54.             </map>  
  55.         </property>  
  56.         <!-- 过滤器链，请求url对应的过滤器 -->  
  57.         <property name="filterChainDefinitions">  
  58.             <value>  
  59.                 /message.jsp=anon  
  60.                 /logout=logout  
  61.                 /shiro-cas=casFilter  
  62.                 /** =user  
  63.             </value>  
  64.         </property>  
  65.     </bean>  
  66.     <!-- shiro过滤器 end -->  
  67.   
  68.     <!-- 保证实现shiro内部的生命周期函数bean的执行 -->  
  69.     <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />  
  70.   
  71.     <!-- 第三：shiro管理中心类 start-李社河 -->  
  72.     <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
  73.         <property name="realm" ref="shiroRealm"></property>  
  74.         <property name="sessionMode" value="http"></property>  
  75.         <property name="subjectFactory" ref="casSubjectFactory"></property>  
  76.         <!-- ehcahe缓存shiro自带 -->  
  77.         <!-- <property name="cacheManager" ref="shiroEhcacheManager"></property> -->  
  78.   
  79.         <!-- redis缓存 -->  
  80.         <property name="cacheManager" ref="redisCacheManager" />  
  81.   
  82.         <!-- sessionManager -->  
  83.         <property name="sessionManager" ref="sessionManager"></property>  
  84.     </bean>  
  85.   
  86.   
  87.     <!-- 缓存管理器redis-start-李社河-2015年4月14日 -->  
  88.   
  89.     <!-- sessionManager -->  
  90.     <!-- <bean id="sessionManager" -->  
  91.     <!-- class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager"> -->  
  92.     <!-- <property name="sessionDAO" ref="redisSessionDAO" /> -->  
  93.     <!-- </bean> -->  
  94.   
  95.     <!-- 自定义redisManager-redis -->  
  96.     <bean id="redisCacheManager" class="com.tgb.itoo.authority.cache.RedisCacheManager">  
  97.         <property name="redisManager" ref="redisManager" />  
  98.     </bean>  
  99.     <!-- 自定义cacheManager -->  
  100.     <bean id="redisCache" class="com.tgb.itoo.authority.cache.RedisCache">  
  101.         <constructor-arg ref="redisManager"></constructor-arg>  
  102.     </bean>  
  103.   
  104.     <bean id="redisManager" class="com.tgb.itoo.authority.cache.RedisManager"></bean>  
  105.   
  106.     <!-- 缓存管理器redis-end-李社河-2015年4月14日 -->  
  107.   
  108.   
  109.   
  110.     <!-- session会话存储的实现类 -->  
  111.     <bean id="redisShiroSessionDAO" class="com.tgb.itoo.authority.cache.RedisSessionDAO">  
  112.         <property name="redisManager" ref="redisManager" />  
  113.     </bean>  
  114.   
  115.   
  116.   
  117.     <!-- sessionManager -->  
  118.     <!-- session管理器 -->  
  119.     <bean id="sessionManager"  
  120.         class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
  121.         <!-- 设置全局会话超时时间，默认30分钟(1800000) -->  
  122.         <property name="globalSessionTimeout" value="1800000" />  
  123.         <!-- 是否在会话过期后会调用SessionDAO的delete方法删除会话 默认true -->  
  124.         <property name="deleteInvalidSessions" value="true" />  
  125.   
  126.         <!-- 会话验证器调度时间 -->  
  127.         <property name="sessionValidationInterval" value="1800000" />  
  128.   
  129.         <!-- session存储的实现 -->  
  130.         <property name="sessionDAO" ref="redisShiroSessionDAO" />  
  131.         <!-- sessionIdCookie的实现,用于重写覆盖容器默认的JSESSIONID -->  
  132.         <property name="sessionIdCookie" ref="sharesession" />  
  133.         <!-- 定时检查失效的session -->  
  134.         <property name="sessionValidationSchedulerEnabled" value="true" />  
  135.   
  136.     </bean>  
  137.   
  138.   
  139.     <!-- sessionIdCookie的实现,用于重写覆盖容器默认的JSESSIONID -->  
  140.     <bean id="sharesession" class="org.apache.shiro.web.servlet.SimpleCookie">  
  141.         <!-- cookie的name,对应的默认是 JSESSIONID -->  
  142.         <constructor-arg name="name" value="SHAREJSESSIONID" />  
  143.         <!-- jsessionId的path为 / 用于多个系统共享jsessionId -->  
  144.         <property name="path" value="/" />  
  145.         <property name="httpOnly" value="true"/>  
  146.     </bean>  
  147.   
  148.   
  149.   
  150.   
  151.   
  152.   
  153.   
  154.     <!-- 第一：shiro于数据交互的类 ，自己写的类的实现-ShiroRealmBean自己重写的类的实现 -->  
  155.     <bean id="shiroRealm" class="com.tgb.itoo.authority.service.ShiroRealmBean">  
  156.         <property name="defaultRoles" value="user"></property>  
  157.   
  158.         <!-- 注入自己实现的类，授权的过程-PermissionManager是云平台重写的授权的过程，用户Id->角色->资源->查找权限-李社河2015年4月15日 -->  
  159.         <property name="permissionMgr" ref="PermissionManager"></property>  
  160.         <property name="casServerUrlPrefix" value="${casServerUrlPrefix}"></property>  
  161.         <property name="casService" value="${casService}"></property>  
  162.     </bean>  
  163.   
  164.     <bean id="casSubjectFactory" class="org.apache.shiro.cas.CasSubjectFactory" />  
  165.   
  166.     <!-- shiro的自带缓存管理器encahe -->  
  167.     <!-- <bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager"> -->  
  168.     <!-- <property name="cacheManagerConfigFile" value="classpath:config/ehcache-shiro.xml"   
  169.         /> -->  
  170.     <!-- </bean> -->  
  171.   
  172.     <!-- 开启shiro的注解，需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证 -->  
  173.     <bean  
  174.         class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"  
  175.         depends-on="lifecycleBeanPostProcessor"></bean>  
  176.     <bean  
  177.         class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">  
  178.         <property name="securityManager" ref="securityManager" />  
  179.     </bean>  
  180. </beans>  
  181. </span>  



这样第一个问题，session的共享问题我们就解决好了，下一篇介绍另一个问题，cache的共享问题。

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/9399028/viewspace-2102815/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： 分布式集群系统下的高可用session解决方案
下一篇： 分布式集群系统下---cache共享
请登录后发表评论 登录
全部评论
xz43
鱼儿的学习空间

注册时间：2010-11-16

  • 博文量
    433
  • 访问量
    1863708

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593