您的位置: 首页  >  文章  >  shiro 在集群环境下用redis(集群版)做session共享

shiro 在集群环境下用redis(集群版)做session共享

分类: 文章 • 2025-02-08 18:26:46

如今集群环境已是服务器主流,在集群环境中，session共享一般通过应用服务器的session复制或者存储在公用的缓存服务器上，本文主要介绍通过Shiro管理session，并将session缓存到redis集群版中，这样可以在集群中使用。

Shiro除了在管理session上使用redis，也在可以缓存用户权限，即cacheManager可以通过redis来扩展。

下面从 sessionManager这部分讲解Shiro与Redis的集成,

先看下配置问件:

[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!-- 装配 securityManager --><!-- 注入安全管理对象 --><!-- 配置登陆页面 --><!-- 登陆成功后的一面 --><!-- 权限不足页面 --><!-- 具体配置需要拦截哪些 URL, 以及访问对应的 URL 时使用 Shiro 的什么 Filter 进行拦截. --><!-- /cityparlor/home/index.html=authc -->  
  3.                 /cityparlor/cityparlor/**=anon  
  4.                 /cityparlor/**=authc  
  5.                 /common/**=anon  
  6.             <!-- 配置缓存管理器 --><!-- 指定 ehcache 的配置文件 --><!-- 配置进行授权和认证的 Realm --><!-- 配置 Shiro 的 SecurityManager Bean. --><!-- sessionManager --><!-- <property name="cacheManager" ref="mycacheManager" /> --><!-- 要想完成redis代理session 此配置很重要--><!-- sessionManager --><!-- sessionIdCookie的实现,用于重写覆盖容器默认的JSESSIONID --><!-- 设置全局会话超时时间，默认30分钟(1800000) --><!-- 是否在会话过期后会调用SessionDAO的delete方法删除会话 默认true --><!-- 会话验证器调度时间 --><!-- 定时检查失效的session --><!-- sessionIdCookie的实现,用于重写覆盖容器默认的JSESSIONID --><!-- cookie的name,对应的默认是 JSESSIONID --><!-- jsessionId的path为 / 用于多个系统共享jsessionId --><!-- 配置 Bean 后置处理器: 会自动的调用和 Spring 整合后各个组件的生命周期方法. --><!-- 保证实现了Shiro内部lifecycle函数的bean执行 --><!-- <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/> --><!-- AOP式方法级权限检查 --><!-- 切面 -->  

shiro框架中有一个对session配置管理对象:sessionManager对象,对象中可注入对象参数:sessionDAO,源码如下:

shiro 在集群环境下用redis(集群版)做session共享

此SessionDao中封装内容如下:

shiro 在集群环境下用redis(集群版)做session共享

不难发现,里面封装的就是对session的增删改查,因此我们只需对sessionDao进行自己的继承,实现类即可;

自己封装代码如下:

[java] view plain copy
  1. package com.cityparlor.web.admin.realm;  
  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. import com.cityparlor.common.utils.JedisUtils;  
  15.   
  16. public class RedisSessionDAO extends AbstractSessionDAO{  
  17.     private static Logger logger = LoggerFactory.getLogger(RedisSessionDAO.class);  
  18.     /*private JedisUtils redisManager;*/  
  19.     private String keyPrefix;  
  20.     private int expire = 0;  
  21.       
  22.   
  23.     public RedisSessionDAO() {  
  24.         this.keyPrefix = "shiro_redis_session:";  
  25.     }  
  26.   
  27.     @Override  
  28.     public void update(Session session) throws UnknownSessionException {  
  29.         // TODO Auto-generated method stub  
  30.         this.saveSession(session);  
  31.     }  
  32.       
  33.     /** 
  34.      * 获取序列化字节id 
  35.      * TODO 
  36.      * @param sessionId 
  37.      * @return<br> 
  38.      * ============History===========<br> 
  39.      * 2017年7月17日   LHL    新建 
  40.      */  
  41.     /*private byte[] getByteKey(Serializable sessionId) { 
  42.         String preKey = this.keyPrefix + sessionId; 
  43.         return preKey.getBytes(); 
  44.     }*/  
  45.     private String getKey(Serializable sessionId) {  
  46.         String preKey = this.keyPrefix + sessionId;  
  47.         return preKey;  
  48.     }  
  49.       
  50.     private void saveSession(Session session) throws UnknownSessionException {  
  51.         if ((session == null) || (session.getId() == null)) {  
  52.             logger.error("session or session id is null");  
  53.             return;  
  54.         }  
  55.   
  56.         String key = getKey(session.getId());  
  57.         /*byte[] value = SerializeUtils.serialize(session);*/  
  58.         session.setTimeout(expire * 1000);  
  59.         JedisUtils.setObject(key, session, this.expire);//this.redisManager.set(key, value, this.redisManager.getExpire());  
  60.     }  
  61.       
  62.       
  63.     @Override  
  64.     public void delete(Session session) {  
  65.         if ((session == null) || (session.getId() == null)) {  
  66.             logger.error("session or session id is null");  
  67.             return;  
  68.         }  
  69.         JedisUtils.delObject(getKey(session.getId()));//this.redisManager.del(getByteKey(session.getId()));  
  70.           
  71.     }  
  72.   
  73.     @Override  
  74.     public Collection getActiveSessions() {  
  75.         // TODO Auto-generated method stub  
  76.         Set sessions = new HashSet();  
  77.   
  78.         Set keys = JedisUtils.keys(this.keyPrefix + "*");  
  79.         if ((keys != null) && (keys.size() > 0)) {  
  80.             for (String key : keys) {  
  81.                 Session s = (Session) JedisUtils.getObject(key);// (Session) SerializeUtils.deserialize(this.redisManager.get(key));  
  82.                 sessions.add(s);  
  83.             }  
  84.         }  
  85.   
  86.         return sessions;  
  87.     }  
  88.   
  89.     @Override  
  90.     protected Serializable doCreate(Session session) {  
  91.         // TODO Auto-generated method stub  
  92.         Serializable sessionId = generateSessionId(session);  
  93.         assignSessionId(session, sessionId);  
  94.         saveSession(session);  
  95.         return sessionId;  
  96.     }  
  97.   
  98.     @Override  
  99.     protected Session doReadSession(Serializable sessionId) {  
  100.         // TODO Auto-generated method stub  
  101.         if (sessionId == null) {  
  102.             logger.error("session id is null");  
  103.             return null;  
  104.         }  
  105.   
  106.         Session s =(Session) JedisUtils.getObject(getKey(sessionId)) ;// SerializeUtils.deserialize(this.redisManager.get(getByteKey(sessionId)));  
  107.         return s;  
  108.     }  
  109.   
  110. }  
这里我们只是将session的增删改查换成了用redis的增删改查;
redis链接工具类代码如下:
[java] view plain copy
  1. /** 
  2.  *  
  3.  */  
  4. package com.cityparlor.common.utils;  
  5.   
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import java.util.Set;  
  9. import java.util.TreeSet;  
  10.   
  11. import org.slf4j.Logger;  
  12. import org.slf4j.LoggerFactory;  
  13.   
  14. import com.cityparlor.common.config.Global;  
  15. import com.google.common.collect.Lists;  
  16. import com.google.common.collect.Maps;  
  17. import com.google.common.collect.Sets;  
  18.   
  19. import redis.clients.jedis.Jedis;  
  20. import redis.clients.jedis.JedisCluster;  
  21. import redis.clients.jedis.JedisPool;  
  22.   
  23. /** 
  24.  * Jedis Cache 工具类 
  25.  *  
  26.  * @author Administrator 
  27.  * @version 2015-09-29 
  28.  */  
  29. public class JedisUtils {  
  30.   
  31.     private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);  
  32.       
  33.     private static JedisCluster jedisCluster = SpringContextHolder.getBean(JedisCluster.class);  
  34.     //private static JedisPool jedisPool = SpringContextHolder.getBean(JedisPool.class);  
  35.   
  36.     public static final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");  
  37.       
  38.     /** 
  39.      * 利用redis 生成自增长的长整形主键 
  40.      * */  
  41.       
  42.       
  43.     /** 
  44.      * 获取所有keys 
  45.      * TODO 
  46.      * @param pattern 
  47.      * @return<br> 
  48.      * ============History===========<br> 
  49.      * 2017年7月17日   LHL    新建 
  50.      */  
  51.      public static TreeSet keys(String pattern){    
  52.             //logger.debug("Start getting keys...");    
  53.             TreeSet keys = new TreeSet<>();    
  54.             Map clusterNodes = jedisCluster.getClusterNodes();    
  55.             for(String k : clusterNodes.keySet()){    
  56.              //   logger.debug("Getting keys from: {}", k);    
  57.                 JedisPool jp = clusterNodes.get(k);    
  58.                 Jedis connection = jp.getResource();    
  59.                 try {    
  60.                     keys.addAll(connection.keys(pattern));    
  61.                 } catch(Exception e){    
  62.                     logger.error("Getting keys error: {}", e);    
  63.                 } finally{    
  64.                     logger.debug("Connection closed.");    
  65.                     connection.close();//用完一定要close这个链接！！！    
  66.                 }    
  67.             }    
  68.            // logger.debug("Keys gotten!");    
  69.             return keys;    
  70.         }    
  71.     /** 
  72.      * 获取缓存 
  73.      * @param key 键 
  74.      * @return 值 
  75.      */  
  76.     public static String get(String key) {  
  77.         key = KEY_PREFIX + key;  
  78.         String value = null;  
  79.         //Jedis jedis = null;  
  80.         try {  
  81.             //jedis = getResource();  
  82.             if (jedisCluster.exists(key)) {  
  83.                 value = jedisCluster.get(key);  
  84.                 value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;  
  85.                 logger.debug("get {} = {}", key, value);  
  86.             }  
  87.         } catch (Exception e) {  
  88.             logger.warn("get {} = {}", key, value, e);  
  89.         } finally {  
  90.             //returnResource(jedis);  
  91.         }  
  92.         return value;  
  93.     }  
  94.       
  95.     /** 
  96.      * 获取缓存 
  97.      * @param key 键 
  98.      * @return 值 
  99.      */  
  100.     public static Object getObject(String key) {  
  101.         key = KEY_PREFIX + key;  
  102.         Object value = null;  
  103.         //Jedis jedis = null;  
  104.         try {  
  105.             //jedis = getResource();  
  106.             if (jedisCluster.exists(getBytesKey(key))) {  
  107.                 value = toObject(jedisCluster.get(getBytesKey(key)));  
  108.                 logger.debug("getObject {} = {}", key, value);  
  109.             }  
  110.         } catch (Exception e) {  
  111.             logger.warn("getObject {} = {}", key, value, e);  
  112.         } finally {  
  113.             //returnResource(jedis);  
  114.         }  
  115.         return value;  
  116.     }  
  117.       
  118.     /** 
  119.      * 设置缓存，利用setex 
  120.      * @param key 
  121.      * @param seconds 
  122.      * @param value 
  123.      * @return 
  124.      */  
  125.     public static String setex(String key, int seconds, String value){  
  126.         key = KEY_PREFIX + key;  
  127.         String result = null;  
  128.         //Jedis jedis = null;  
  129.         try {  
  130.             //jedis = getResource();  
  131.             result = jedisCluster.setex(key, seconds, value);  
  132.             logger.debug("setex {} = {}", key, value);  
  133.         } catch (Exception e) {  
  134.             logger.warn("setex {} = {}", key, value, e);  
  135.         } finally {  
  136.             //returnResource(jedis);  
  137.         }  
  138.         return result;  
  139.     }  
  140.       
  141.     /** 
  142.      * 设置缓存 
  143.      * @param key 键 
  144.      * @param value 值 
  145.      * @param cacheSeconds 超时时间，0为不超时 
  146.      * @return 
  147.      */  
  148.     public static String set(String key, String value, int cacheSeconds) {  
  149.         key = KEY_PREFIX + key;  
  150.         String result = null;  
  151.         //Jedis jedis = null;  
  152.         try {  
  153.             //jedis = getResource();  
  154.             result = jedisCluster.set(key, value);  
  155.             if (cacheSeconds != 0) {  
  156.                 jedisCluster.expire(key, cacheSeconds);  
  157.             }  
  158.             logger.debug("set {} = {}", key, value);  
  159.         } catch (Exception e) {  
  160.             logger.warn("set {} = {}", key, value, e);  
  161.         } finally {  
  162.             //returnResource(jedis);  
  163.         }  
  164.         return result;  
  165.     }  
  166.       
  167.     /** 
  168.      * 设置缓存 
  169.      * @param key 键 
  170.      * @param value 值 
  171.      * @param cacheSeconds 超时时间，0为不超时 
  172.      * @return 
  173.      */  
  174.     public static String setObject(String key, Object value, int cacheSeconds) {  
  175.         key = KEY_PREFIX + key;  
  176.         String result = null;  
  177.         //Jedis jedis = null;  
  178.         try {  
  179.             //jedis = getResource();  
  180.             result = jedisCluster.set(getBytesKey(key), toBytes(value));  
  181.             if (cacheSeconds != 0) {  
  182.                 jedisCluster.expire(key, cacheSeconds);  
  183.             }  
  184.             logger.debug("setObject {} = {}", key, value);  
  185.         } catch (Exception e) {  
  186.             logger.warn("setObject {} = {}", key, value, e);  
  187.         } finally {  
  188.             //returnResource(jedis);  
  189.         }  
  190.         return result;  
  191.     }  
  192.       
  193.     /** 
  194.      * 获取List缓存 
  195.      * @param key 键 
  196.      * @return 值 
  197.      */  
  198.     public static List getList(String key) {  
  199.         key = KEY_PREFIX + key;  
  200.         List value = null;  
  201.         //Jedis jedis = null;  
  202.         try {  
  203.             //jedis = getResource();  
  204.             if (jedisCluster.exists(key)) {  
  205.                 value = jedisCluster.lrange(key, 0, -1);  
  206.                 logger.debug("getList {} = {}", key, value);  
  207.             }  
  208.         } catch (Exception e) {  
  209.             logger.warn("getList {} = {}", key, value, e);  
  210.         } finally {  
  211.             //returnResource(jedis);  
  212.         }  
  213.         return value;  
  214.     }  
  215.       
  216.     /** 
  217.      * 获取List缓存 
  218.      * @param key 键 
  219.      * @return 值 
  220.      */  
  221.     public static List  
对redis链接池的封装也可按自己的来,只要将自己实现的RedisSessionDAO中的方法重新定义即可;

相关推荐