经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
shiro源码篇 - shiro的session共享，你值得拥有
来源：cnblogs　　作者：youzhibing2904　　时间：2018/10/30 9:04:04　　对本文有异议

前言

　　开心一刻

　　　　老师对小明说："乳就是小的意思，比如乳猪就是小猪，乳名就是小名，请你用乳字造个句"
　　　　小明："我家很穷，只能住在40平米的乳房"
　　　　老师："..., 这个不行，换一个"
　　　　小明："我每天上学都要跳过我家门口的一条乳沟"
　　　　老师："......, 这个也不行，再换一个"
　　　　小明："老师，我想不出来了，把我的乳头都想破了！"

　　路漫漫其修远兮，吾将上下而求索！

　　github：https://github.com/youzhibing

　　码云(gitee)：https://gitee.com/youzhibing

前情回顾

　　shiro的session创建与session的查询、更新、过期、删除中，shiro对session的操作基本都讲到了，但还缺一个session共享没有讲解；session共享的原理其实在自定义session管理一文已经讲过了，本文不讲原理，只看看shiro的session共享的实现。

　　为何需要session共享

　　　　如果是单机应用，那么谈不上session共享，session放哪都无所谓，不在乎放到默认的servlet容器中，还是抽出来放到单独的地方；

　　　　也就是说session共享是针对集群（或分布式、或分布式集群）的；如果不做session共享，仍然采用默认的方式（session存放到默认的servlet容器），当我们的应用是以集群的方式发布的时候，同个用户的请求会被分发到不同的集群节点（分发依赖具体的负载均衡规则），那么每个处理同个用户请求的节点都会重新生成该用户的session，这些session之间是毫无关联的。那么同个用户的请求会被当成多个不同用户的请求，这肯定是不行的。

　　如何实现session共享

　　　　实现方式其实有很多，甚至可以不做session共享，具体有哪些，大家自行去查资料。本文提供一种方式：redis实现session共享，就是将session从servlet容器抽出来，放到redis中存储，所有集群节点都从redis中对session进行操作。

SessionDAO

　　SessionDAO其实是用于session持久化的，但里面有缓存部分，具体细节我们往下看

　　shiro已有SessionDAO的实现如下

　　SessionDAO接口提供的方法如下

  1. package org.apache.shiro.session.mgt.eis;
  3. import org.apache.shiro.session.Session;
  4. import org.apache.shiro.session.UnknownSessionException;
  6. import java.io.Serializable;
  7. import java.util.Collection;
  10. /**
  11.  * 从EIS操作session的规范（EIS：例如关系型数据库, 文件系统, 持久化缓存等等, 具体依赖DAO实现）
  12.  * 提供了典型的CRUD的方法：create, readSession, update, delete
  13.  */
  14. public interface SessionDAO {
  16.     /**
  17.      * 插入一个新的sesion记录到EIS 
  18.      */
  19.     Serializable create(Session session);
  21.     /**
  22.      * 根据会话ID获取会话
  23.      */
  24.     Session readSession(Serializable sessionId) throws UnknownSessionException;
  26.     /**
  27.      * 更新session; 如更新session最后访问时间/停止会话/设置超时时间/设置移除属性等会调用
  28.      */
  29.     void update(Session session) throws UnknownSessionException;
  31.     /**
  32.      * 删除session; 当会话过期/会话停止（如用户退出时）会调用
  33.      */
  34.     void delete(Session session);
  36.     /**
  37.      * 获取当前所有活跃session, 所有状态不是stopped/expired的session
  38.      * 如果用户量多此方法影响性能
  39.      */
  40.     Collection<Session> getActiveSessions();
  41. }
View Code

　　　　SessionDAO给出了从持久层（一般而言是关系型数据库）操作session的标准。

　　AbstractSessionDAO提供了SessionDAO的基本实现，如下

  1. package org.apache.shiro.session.mgt.eis;
  3. import org.apache.shiro.session.Session;
  4. import org.apache.shiro.session.UnknownSessionException;
  5. import org.apache.shiro.session.mgt.SimpleSession;
  7. import java.io.Serializable;
  10. /**
  11.  * SessionDAO的抽象实现, 在会话创建和读取时做一些健全性检查，并在需要时允许可插入的会话ID生成策略.
  12.  * SessionDAO的update和delete则留给子类来实现
  13.  * EIS需要子类自己实现
  14.  */
  15. public abstract class AbstractSessionDAO implements SessionDAO {
  17.     /**
  18.      * sessionId生成器
  19.      */
  20.     private SessionIdGenerator sessionIdGenerator;
  22.     public AbstractSessionDAO() {
  23.         this.sessionIdGenerator = new JavaUuidSessionIdGenerator();    // 指定JavaUuidSessionIdGenerator为默认sessionId生成器
  24.     }
  26.     /**
  27.      * 获取sessionId生成器
  28.      */
  29.     public SessionIdGenerator getSessionIdGenerator() {
  30.         return sessionIdGenerator;
  31.     }
  33.     /**
  34.      * 设置sessionId生成器
  35.      */
  36.     public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
  37.         this.sessionIdGenerator = sessionIdGenerator;
  38.     }
  40.     /**
  41.      * 生成一个新的sessionId, 并将它应用到session实例
  42.      */
  43.     protected Serializable generateSessionId(Session session) {
  44.         if (this.sessionIdGenerator == null) {
  45.             String msg = "sessionIdGenerator attribute has not been configured.";
  46.             throw new IllegalStateException(msg);
  47.         }
  48.         return this.sessionIdGenerator.generateId(session);
  49.     }
  51.     /**
  52.      * SessionDAO中create实现; 将创建的sesion保存到EIS.
  53.      * 子类doCreate方法的代理，具体的细节委托给了子类的doCreate方法
  54.      */
  55.     public Serializable create(Session session) {
  56.         Serializable sessionId = doCreate(session);
  57.         verifySessionId(sessionId);
  58.         return sessionId;
  59.     }
  61.     /**
  62.      * 保证从doCreate返回的sessionId不是null，并且不是已经存在的.
  63.      * 目前只实现了null校验，是否已存在是没有校验的，可能shiro的开发者会在后续补上吧.
  64.      */
  65.     private void verifySessionId(Serializable sessionId) {
  66.         if (sessionId == null) {
  67.             String msg = "sessionId returned from doCreate implementation is null.  Please verify the implementation.";
  68.             throw new IllegalStateException(msg);
  69.         }
  70.     }
  72.     /**
  73.      * 分配sessionId给session实例
  74.      */
  75.     protected void assignSessionId(Session session, Serializable sessionId) {
  76.         ((SimpleSession) session).setId(sessionId);
  77.     }
  79.     /**
  80.      * 子类通过实现此方法来持久化Session实例到EIS.
  81.      */
  82.     protected abstract Serializable doCreate(Session session);
  84.     /**
  85.      * SessionDAO中readSession实现; 通过sessionId从EIS获取session对象.
  86.      * 子类doReadSession方法的代理，具体的获取细节委托给了子类的doReadSession方法.
  87.      */
  88.     public Session readSession(Serializable sessionId) throws UnknownSessionException {
  89.         Session s = doReadSession(sessionId);
  90.         if (s == null) {
  91.             throw new UnknownSessionException("There is no session with id [" + sessionId + "]");
  92.         }
  93.         return s;
  94.     }
  96.     /**
  97.      * 子类通过实现此方法从EIS获取session实例
  98.      */
  99.     protected abstract Session doReadSession(Serializable sessionId);
  101. }
View Code

　　　　SessionDao的基本实现，实现了SessionDao的create、readSession（具体还是依赖AbstractSessionDAO子类的doCreate、doReadSession实现）；同时加入了自己的sessionId生成器，负责sessionId的操作。

　　CachingSessionDAO提供了session缓存的功能，如下

  1. package org.apache.shiro.session.mgt.eis;
  3. import org.apache.shiro.cache.Cache;
  4. import org.apache.shiro.cache.CacheManager;
  5. import org.apache.shiro.cache.CacheManagerAware;
  6. import org.apache.shiro.session.Session;
  7. import org.apache.shiro.session.UnknownSessionException;
  8. import org.apache.shiro.session.mgt.ValidatingSession;
  10. import java.io.Serializable;
  11. import java.util.Collection;
  12. import java.util.Collections;
  14. /**
  15.  * 应用层与持久层(EIS，如关系型数据库、文件系统、NOSQL)之间的缓存层实现
  16.  * 缓存着所有激活状态的session
  17.  * 实现了CacheManagerAware，会在shiro加载的过程中调用此对象的setCacheManager方法
  18.  */
  19. public abstract class CachingSessionDAO extends AbstractSessionDAO implements CacheManagerAware {
  21.     /**
  22.      * 激活状态的sesion的默认缓存名
  23.      */
  24.     public static final String ACTIVE_SESSION_CACHE_NAME = "shiro-activeSessionCache";
  26.     /**
  27.      * 缓存管理器，用来获取session缓存
  28.      */
  29.     private CacheManager cacheManager;
  31.     /**
  32.      * 用来缓存session的缓存实例
  33.      */
  34.     private Cache<Serializable, Session> activeSessions;
  36.     /**
  37.      * session缓存名, 默认是ACTIVE_SESSION_CACHE_NAME.
  38.      */
  39.     private String activeSessionsCacheName = ACTIVE_SESSION_CACHE_NAME;
  41.     public CachingSessionDAO() {
  42.     }
  44.     /**
  45.      * 设置缓存管理器
  46.      */
  47.     public void setCacheManager(CacheManager cacheManager) {
  48.         this.cacheManager = cacheManager;
  49.     }
  51.     /**
  52.      * 获取缓存管理器
  53.      */
  54.     public CacheManager getCacheManager() {
  55.         return cacheManager;
  56.     }
  58.     /**
  59.      * 获取缓存实例的名称，也就是获取activeSessionsCacheName的值
  60.      */
  61.     public String getActiveSessionsCacheName() {
  62.         return activeSessionsCacheName;
  63.     }
  65.     /**
  66.      * 设置缓存实例的名称，也就是设置activeSessionsCacheName的值
  67.      */
  68.     public void setActiveSessionsCacheName(String activeSessionsCacheName) {
  69.         this.activeSessionsCacheName = activeSessionsCacheName;
  70.     }
  72.     /**
  73.      * 获取缓存实例
  74.      */
  75.     public Cache<Serializable, Session> getActiveSessionsCache() {
  76.         return this.activeSessions;
  77.     }
  79.     /**
  80.      * 设置缓存实例
  81.      */
  82.     public void setActiveSessionsCache(Cache<Serializable, Session> cache) {
  83.         this.activeSessions = cache;
  84.     }
  86.     /**
  87.      * 获取缓存实例
  88.      * 注意：不会返回non-null值
  89.      *
  90.      * @return the active sessions cache instance.
  91.      */
  92.     private Cache<Serializable, Session> getActiveSessionsCacheLazy() {
  93.         if (this.activeSessions == null) {
  94.             this.activeSessions = createActiveSessionsCache();
  95.         }
  96.         return activeSessions;
  97.     }
  99.     /**
  100.      * 创建缓存实例
  101.      */
  102.     protected Cache<Serializable, Session> createActiveSessionsCache() {
  103.         Cache<Serializable, Session> cache = null;
  104.         CacheManager mgr = getCacheManager();
  105.         if (mgr != null) {
  106.             String name = getActiveSessionsCacheName();
  107.             cache = mgr.getCache(name);
  108.         }
  109.         return cache;
  110.     }
  112.     /**
  113.      * AbstractSessionDAO中create的重写
  114.      * 调用父类(AbstractSessionDAO)的create方法, 然后将session缓存起来
  115.      * 返回sessionId
  116.      */
  117.     public Serializable create(Session session) {
  118.         Serializable sessionId = super.create(session);    // 调用父类的create方法
  119.         cache(session, sessionId);                        // 以sessionId作为key缓存session
  120.         return sessionId;
  121.     }
  123.     /**
  124.      * 从缓存中获取session; 若sessionId为null，则返回null
  125.      */
  126.     protected Session getCachedSession(Serializable sessionId) {
  127.         Session cached = null;
  128.         if (sessionId != null) {
  129.             Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
  130.             if (cache != null) {
  131.                 cached = getCachedSession(sessionId, cache);
  132.             }
  133.         }
  134.         return cached;
  135.     }
  137.     /**
  138.      * 从缓存中获取session
  139.      */
  140.     protected Session getCachedSession(Serializable sessionId, Cache<Serializable, Session> cache) {
  141.         return cache.get(sessionId);
  142.     }
  144.     /**
  145.      * 缓存session，以sessionId作为key
  146.      */
  147.     protected void cache(Session session, Serializable sessionId) {
  148.         if (session == null || sessionId == null) {
  149.             return;
  150.         }
  151.         Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
  152.         if (cache == null) {
  153.             return;
  154.         }
  155.         cache(session, sessionId, cache);
  156.     }
  158.     protected void cache(Session session, Serializable sessionId, Cache<Serializable, Session> cache) {
  159.         cache.put(sessionId, session);
  160.     }
  162.     /**
  163.      * AbstractSessionDAO中readSession的重写
  164.      * 先从缓存中获取，若没有则调用父类的readSession方法获取session
  165.      */
  166.     public Session readSession(Serializable sessionId) throws UnknownSessionException {
  167.         Session s = getCachedSession(sessionId);        // 从缓存中获取
  168.         if (s == null) {
  169.             s = super.readSession(sessionId);           // 调用父类readSession方法获取
  170.         }
  171.         return s;
  172.     }
  174.     /**
  175.      * SessionDAO中update的实现
  176.      * 更新session的状态
  177.      */
  178.     public void update(Session session) throws UnknownSessionException {
  179.         doUpdate(session);                               // 更新EIS中的session
  180.         if (session instanceof ValidatingSession) {
  181.             if (((ValidatingSession) session).isValid()) {
  182.                 cache(session, session.getId());         // 更新缓存中的session
  183.             } else {
  184.                 uncache(session);                        // 移除缓存中的sesson
  185.             }
  186.         } else {
  187.             cache(session, session.getId());
  188.         }
  189.     }
  191.     /**
  192.      * 由子类去实现，持久化session到EIS
  193.      */
  194.     protected abstract void doUpdate(Session session);
  196.     /**
  197.      * SessionDAO中delete的实现
  198.      * 删除session
  199.      */
  200.     public void delete(Session session) {
  201.         uncache(session);                                // 从缓存中移除
  202.         doDelete(session);                               // 从EIS中删除
  203.     }
  205.     /**
  206.      * 由子类去实现，从EIS中删除session
  207.      */
  208.     protected abstract void doDelete(Session session);
  210.     /**
  211.      * 从缓存中移除指定的session
  212.      */
  213.     protected void uncache(Session session) {
  214.         if (session == null) {
  215.             return;
  216.         }
  217.         Serializable id = session.getId();
  218.         if (id == null) {
  219.             return;
  220.         }
  221.         Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
  222.         if (cache != null) {
  223.             cache.remove(id);
  224.         }
  225.     }
  227.     /**
  228.      * SessionDAO中getActiveSessions的实现
  229.      * 获取所有的存活的session
  230.      */
  231.     public Collection<Session> getActiveSessions() {
  232.         Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
  233.         if (cache != null) {
  234.             return cache.values();
  235.         } else {
  236.             return Collections.emptySet();
  237.         }
  238.     }
  239. }
View Code

　　　　是应用层与持久化层之间的缓存层，不用频繁请求持久化层以提升效率。重写了AbstractSessionDAO中的create、readSession方法，实现了SessionDAO中的update、delete、getActiveSessions方法，预留doUpdate和doDelele给子类去实现（doXXX方法操作的是持久层）

　　MemorySessionDAO，SessionDAO的简单内存实现，如下

  1. package org.apache.shiro.session.mgt.eis;
  3. import org.apache.shiro.session.Session;
  4. import org.apache.shiro.session.UnknownSessionException;
  5. import org.apache.shiro.util.CollectionUtils;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  9. import java.io.Serializable;
  10. import java.util.Collection;
  11. import java.util.Collections;
  12. import java.util.concurrent.ConcurrentHashMap;
  13. import java.util.concurrent.ConcurrentMap;
  16. /**
  17.  * 基于内存的SessionDao的简单实现，所有的session存在ConcurrentMap中
  18.  * DefaultSessionManager默认用的MemorySessionDAO
  19.  */
  20. public class MemorySessionDAO extends AbstractSessionDAO {
  22.     private static final Logger log = LoggerFactory.getLogger(MemorySessionDAO.class);
  24.     private ConcurrentMap<Serializable, Session> sessions;                // 存放session的容器
  25.  
  26.     public MemorySessionDAO() {
  27.         this.sessions = new ConcurrentHashMap<Serializable, Session>();
  28.     }
  30.     // AbstractSessionDAO 中doCreate的重写; 将session存入sessions
  31.     protected Serializable doCreate(Session session) {
  32.         Serializable sessionId = generateSessionId(session);        // 生成sessionId
  33.         assignSessionId(session, sessionId);                        // 将sessionId赋值到session
  34.         storeSession(sessionId, session);                            // 存储session到sessions
  35.         return sessionId;
  36.     }
  38.     // 存储session到sessions
  39.     protected Session storeSession(Serializable id, Session session) {
  40.         if (id == null) {
  41.             throw new NullPointerException("id argument cannot be null.");
  42.         }
  43.         return sessions.putIfAbsent(id, session);
  44.     }
  46.     // AbstractSessionDAO 中doReadSession的重写; 从sessions中获取session
  47.     protected Session doReadSession(Serializable sessionId) {
  48.         return sessions.get(sessionId);
  49.     }
  51.     // SessionDAO中update的实现; 更新sessions中指定的session
  52.     public void update(Session session) throws UnknownSessionException {
  53.         storeSession(session.getId(), session);
  54.     }
  56.     // SessionDAO中delete的实现; 从sessions中移除指定的session
  57.     public void delete(Session session) {
  58.         if (session == null) {
  59.             throw new NullPointerException("session argument cannot be null.");
  60.         }
  61.         Serializable id = session.getId();
  62.         if (id != null) {
  63.             sessions.remove(id);
  64.         }
  65.     }
  67.     // SessionDAO中SessionDAO中delete的实现的实现; 获取sessions中全部session
  68.     public Collection<Session> SessionDAO中delete的实现() {
  69.         Collection<Session> values = sessions.values();
  70.         if (CollectionUtils.isEmpty(values)) {
  71.             return Collections.emptySet();
  72.         } else {
  73.             return Collections.unmodifiableCollection(values);
  74.         }
  75.     }
  77. }
View Code

　　　　将session保存在内存中，存储结构是ConcurrentHashMap；项目中基本不用，即使我们不实现自己的SessionDAO，一般用的也是EnterpriseCacheSessionDAO。

　　EnterpriseCacheSessionDAO，提供了缓存功能的session维护，如下

  1. package org.apache.shiro.session.mgt.eis;
  3. import org.apache.shiro.cache.AbstractCacheManager;
  4. import org.apache.shiro.cache.Cache;
  5. import org.apache.shiro.cache.CacheException;
  6. import org.apache.shiro.cache.MapCache;
  7. import org.apache.shiro.session.Session;
  9. import java.io.Serializable;
  10. import java.util.concurrent.ConcurrentHashMap;
  12. public class EnterpriseCacheSessionDAO extends CachingSessionDAO {
  14.     public EnterpriseCacheSessionDAO() {
  15.         
  16.         // 设置默认缓存器，并实例化MapCache作为cache实例
  17.         setCacheManager(new AbstractCacheManager() {
  18.             @Override
  19.             protected Cache<Serializable, Session> createCache(String name) throws CacheException {
  20.                 return new MapCache<Serializable, Session>(name, new ConcurrentHashMap<Serializable, Session>());
  21.             }
  22.         });
  23.     }
  25.     // AbstractSessionDAO中doCreate的重写; 
  26.     protected Serializable doCreate(Session session) {
  27.         Serializable sessionId = generateSessionId(session);
  28.         assignSessionId(session, sessionId);
  29.         return sessionId;
  30.     }
  32.     // AbstractSessionDAO中doReadSession的重写
  33.     protected Session doReadSession(Serializable sessionId) {
  34.         return null; //should never execute because this implementation relies on parent class to access cache, which
  35.         //is where all sessions reside - it is the cache implementation that determines if the
  36.         //cache is memory only or disk-persistent, etc.
  37.     }
  39.     // CachingSessionDAO中doUpdate的重写
  40.     protected void doUpdate(Session session) {
  41.         //does nothing - parent class persists to cache.
  42.     }
  44.     // CachingSessionDAO中doDelete的重写
  45.     protected void doDelete(Session session) {
  46.         //does nothing - parent class removes from cache.
  47.     }
  48. }
View Code

　　　　设置了默认的缓存管理器（AbstractCacheManager）和默认的缓存实例（MapCache），实现了缓存效果。从父类继承的持久化操作方法（doXXX）都是空实现，也就说EnterpriseCacheSessionDAO是没有实现持久化操作的，仅仅只是简单的提供了缓存实现。当然我们可以继承EnterpriseCacheSessionDAO，重写doXXX方法来实现持久化操作。

　　总结下：SessionDAO定义了从持久层操作session的标准；AbstractSessionDAO提供了SessionDAO的基础实现，如生成会话ID等；CachingSessionDAO提供了对开发者透明的session缓存的功能，只需要设置相应的 CacheManager 即可；MemorySessionDAO直接在内存中进行session维护；而EnterpriseCacheSessionDAO提供了缓存功能的session维护，默认情况下使用 MapCache 实现，内部使用ConcurrentHashMap保存缓存的会话。因为shiro不知道我们需要将session持久化到哪里（关系型数据库，还是文件系统），所以只提供了MemorySessionDAO持久化到内存（听起来怪怪的，内存中能说成持久层吗）

shiro session共享

　　共享实现

　　　　shiro的session共享其实是比较简单的，重写CacheManager，将其操作指向我们的redis，然后实现我们自己的CachingSessionDAO定制缓存操作和缓存持久化。

　　　　自定义CacheManager

　　　　　　ShiroRedisCacheManager

  1. package com.lee.shiro.config;
  3. import org.apache.shiro.cache.Cache;
  4. import org.apache.shiro.cache.CacheException;
  5. import org.apache.shiro.cache.CacheManager;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. @Component
  10. public class ShiroRedisCacheManager implements CacheManager {
  12.     @Autowired
  13.     private Cache shiroRedisCache;
  15.     @Override
  16.     public <K, V> Cache<K, V> getCache(String s) throws CacheException {
  17.         return shiroRedisCache;
  18.     }
  19. }
View Code

　　　　　　ShiroRedisCache

  1. package com.lee.shiro.config;
  3. import org.apache.shiro.cache.Cache;
  4. import org.apache.shiro.cache.CacheException;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.stereotype.Component;
  10. import java.util.Collection;
  11. import java.util.Set;
  12. import java.util.concurrent.TimeUnit;
  14. @Component
  15. public class ShiroRedisCache<K,V> implements Cache<K,V>{
  17.     @Autowired
  18.     private RedisTemplate<K,V> redisTemplate;
  20.     @Value("${spring.redis.expireTime}")
  21.     private long expireTime;
  23.     @Override
  24.     public V get(K k) throws CacheException {
  25.         return redisTemplate.opsForValue().get(k);
  26.     }
  28.     @Override
  29.     public V put(K k, V v) throws CacheException {
  30.         redisTemplate.opsForValue().set(k,v,expireTime, TimeUnit.SECONDS);
  31.         return null;
  32.     }
  34.     @Override
  35.     public V remove(K k) throws CacheException {
  36.         V v = redisTemplate.opsForValue().get(k);
  37.         redisTemplate.opsForValue().getOperations().delete(k);
  38.         return v;
  39.     }
  41.     @Override
  42.     public void clear() throws CacheException {
  43.     }
  45.     @Override
  46.     public int size() {
  47.         return 0;
  48.     }
  50.     @Override
  51.     public Set<K> keys() {
  52.         return null;
  53.     }
  55.     @Override
  56.     public Collection<V> values() {
  57.         return null;
  58.     }
  59. }
View Code

　　　　自定义CachingSessionDAO

　　　　　　继承EnterpriseCacheSessionDAO，然后重新设置其CacheManager（替换掉默认的内存缓存器），这样也可以实现我们的自定义CachingSessionDAO，但是这是优选吗；如若我们实现持久化，继承EnterpriseCacheSessionDAO是优选，但如果只是实现session缓存，那么CachingSessionDAO是优选，自定义更灵活。那么我们还是继承CachingSessionDAO来实现我们的自定义CachingSessionDAO

　　　　　　ShiroSessionDAO

  1. package com.lee.shiro.config;
  3. import org.apache.shiro.session.Session;
  4. import org.apache.shiro.session.mgt.eis.CachingSessionDAO;
  5. import org.springframework.stereotype.Component;
  7. import java.io.Serializable;
  9. @Component
  10. public class ShiroSessionDAO extends CachingSessionDAO {
  12.     @Override
  13.     protected void doUpdate(Session session) {
  14.     }
  16.     @Override
  17.     protected void doDelete(Session session) {
  18.     }
  20.     @Override
  21.     protected Serializable doCreate(Session session) {
  22.         // 这里绑定sessionId到session，必须要有
  23.         Serializable sessionId = generateSessionId(session);
  24.         assignSessionId(session, sessionId);
  25.         return sessionId;
  26.     }
  28.     @Override
  29.     protected Session doReadSession(Serializable sessionId) {
  30.         return null;
  31.     }
  32. }
View Code

　　　　最后将ShiroSessionDAO实例赋值给SessionManager实例，再讲SessionManager实例赋值给SecurityManager实例即可

　　　　具体代码请参考spring-boot-shiro

　　源码解析

　　　　底层还是利用Filter + HttpServletRequestWrapper将对session的操作接入到自己的实现中来，而不走默认的servlet容器，这样对session的操作完全由我们自己掌握。

　　　　shiro的session创建中其实讲到了shiro中对session操作的基本流程，这里不再赘述，没看的朋友可以先去看看再回过头来看这篇。本文只讲shiro中，如何将一个请求的session接入到自己的实现中来的；shiro中有很多默认的filter，我会单独开一篇来讲shiro的filter，这篇我们先不纠结这些filter。

　　　　OncePerRequestFilter中doFilter方法如下

  1. public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
  2.         throws ServletException, IOException {
  3.     String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
  4.     if ( request.getAttribute(alreadyFilteredAttributeName) != null ) {    // 当前filter已经执行过了，进行下一个filter
  5.         log.trace("Filter '{}' already executed.  Proceeding without invoking this filter.", getName());
  6.         filterChain.doFilter(request, response);
  7.     } else //noinspection deprecation
  8.         if (/* added in 1.2: */ !isEnabled(request, response) ||
  9.             /* retain backwards compatibility: */ shouldNotFilter(request) ) {    // 当前filter未被启用或忽略此filter，则进行下一个filter；shouldNotFilter已经被废弃了
  10.         log.debug("Filter '{}' is not enabled for the current request.  Proceeding without invoking this filter.",
  11.                 getName());
  12.         filterChain.doFilter(request, response);
  13.     } else {
  14.         // Do invoke this filter...
  15.         log.trace("Filter '{}' not yet executed.  Executing now.", getName());
  16.         request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
  18.         try {
  19.             // 执行当前filter
  20.             doFilterInternal(request, response, filterChain);
  21.         } finally {
  22.             // 一旦请求完成，我们清除当前filter的"已经过滤"的状态
  23.             request.removeAttribute(alreadyFilteredAttributeName);
  24.         }
  25.     }
  26. }
View Code

　　　　上图中，我可以看到AbstractShiroFilter的doFilterInternal放中将request封装成了shiro自定义的ShiroHttpServletRequest，将response也封装成了shiro自定义的ShiroHttpServletResponse。既然Filter中将request封装了ShiroHttpServletRequest，那么到我们应用的request就是ShiroHttpServletRequest类型，也就是说我们对session的操作最终都是由shiro完成的，而不是默认的servlet容器。

　　　　另外补充一点，shiro的session创建不是懒创建的。servlet容器中的session创建是第一次请求session（第一调用request.getSession()）时才创建。shiro的session创建如下图

　　　　此时，还没登录，但是subject、session已经创建了，只是subject的认证状态为false，说明还没进行登录认证的。至于session创建过程已经保存到redis的流程需要大家自行去跟，或者阅读我之前的博文

总结

　　1、当以集群方式对外提供服务的时候，不做session共享也是可以的

　　　　可以通过ip_hash的机制将同个ip的请求定向到同一台后端，这样保证用户的请求始终是同一台服务处理，与单机应用基本一致了；但这有很多方面的缺陷（具体就不详说了），不推荐使用。

　　2、servlet容器之间做session同步也是可以实现session共享的

　　　　一个servlet容器生成session，其他节点的servlet容器从此servlet容器进行session同步，以达到session信息一致。这个也不推荐，某个时间点会有session不一致的问题，毕竟同步过程受到各方面的影响，不能保证session实时一致。

　　3、session共享实现的原理其实都是一样的，都是filter + HttpServletRequestWrapper，只是实现细节会有所区别；有兴趣的可以看下spring-session的实现细节。

　　4、如果我们采用的spring集成shiro，其实可以将缓存管理器交由spring管理，相当于由spring统一管理缓存。

　　5、shiro的CacheManager不只是管理session缓存，还管理着身份认证缓存、授权缓存，shiro的缓存都是CacheManager管理。但是身份认证缓存默认是关闭的，个人也不推荐开启。

　　6、shiro的session创建时机是在登录认证之前，而不是第一次调用getSession()时。

参考

　　《跟我学shiro》

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号