Shiro 解决分布式 Session

Myth丶恋晨 2023-10-16 10:48 16阅读 0赞

#### 文章目录 ####

*  前言
 *  Shiro 会话管理组件
 *  配置 RedisSessionManager
 *  使用 RedisSession 问题
 *  Shiro的授权缓存
 *   *  实现RedisCache
     *  实现CacheManager

## 前言 ##

在分布式系统中，会话管理是一个重要的问题。Shiro框架提供了一种解决方案，通过其会话管理组件来处理分布式会话。本文演示通过RedisSessionManager解决分布式会话问题。

## Shiro 会话管理组件 ##

Shiro框架的会话管理组件提供了会话的创建、维护、删除和失效等操作。在分布式环境中，多个应用服务器可能需要共享会话状态。为了实现这一点，Shiro框架提供了一些会话管理器实现，其中包括：

*  DefaultSessionManager：默认会话管理器，提供了基本的会话管理功能。在分布式环境中，如果需要在多个应用服务器之间共享会话状态，则需要使用其他会话管理器。
 *  EnterpriseCacheSessionDAO：基于缓存的会话管理器，使用缓存来存储会话状态。在分布式环境中，可以使用分布式缓存来实现会话状态的共享。
 *  RedisSessionManager：基于Redis的会话管理器，使用Redis来存储会话状态。Redis是一个分布式缓存系统，可以在多个应用服务器之间共享会话状态。

使用这些会话管理器实现，可以将会话状态存储在分布式缓存中，以便在多个应用服务器之间共享。

## 配置 RedisSessionManager ##

导入依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

编写配置

spring:
          redis:
            host: 192.168.0.10
            port: 6379
            password: xxxxx

声明SessionDAO的实现类，并重写核心方法

@Component
      public class RedisSessionDAO extends AbstractSessionDAO {
        
    
          @Resource
          private RedisTemplate redisTemplate;
    
          // 存储到Redis时，sessionId作为key，Session作为Value
          // sessionId就是一个字符串
          // Session可以和sessionId绑定到一起，绑定之后，可以基于Session拿到sessionId
          // 需要给Key设置一个统一的前缀，这样才可以方便通过keys命令查看到所有关联的信息
    
          private final String SHIOR_SESSION = "session:";
    
          @Override
          protected Serializable doCreate(Session session) {
        
              System.out.println("Redis---doCreate");
              //1. 基于Session生成一个sessionId（唯一标识）
              Serializable sessionId = generateSessionId(session);
    
              //2. 将Session和sessionId绑定到一起（可以基于Session拿到sessionId）
              assignSessionId(session, sessionId);
    
              //3. 将 前缀:sessionId 作为key，session作为value存储
              redisTemplate.opsForValue().set(SHIOR_SESSION + sessionId,session,30, TimeUnit.MINUTES);
    
              //4. 返回sessionId
              return sessionId;
          }
    
       	@Override
          protected Session doReadSession(Serializable sessionId) {
        
              //1. 基于sessionId获取Session （与Redis交互）
              if (sessionId == null) {
        
                  return null;
              }
              Session session = (Session) redisTemplate.opsForValue().get(SHIOR_SESSION + sessionId);
              if (session != null) {
        
                  redisTemplate.expire(SHIOR_SESSION + sessionId,30,TimeUnit.MINUTES);
              }
              return session;
          }
    
          @Override
          public void update(Session session) throws UnknownSessionException {
        
              System.out.println("Redis---update");
              //1. 修改Redis中session
              if(session == null){
        
                  return ;
              }
              redisTemplate.opsForValue().set(SHIOR_SESSION + session.getId(),session,30, TimeUnit.MINUTES);
          }
    
          @Override
          public void delete(Session session) {
        
              // 删除Redis中的Session
              if(session == null){
        
                  return ;
              }
              redisTemplate.delete(SHIOR_SESSION + session.getId());
          }
    
          @Override
          public Collection<Session> getActiveSessions() {
        
              Set keys = redisTemplate.keys(SHIOR_SESSION + "*");
    
              Set<Session> sessionSet = new HashSet<>();
              // 尝试修改为管道操作，pipeline（Redis的知识）
              for (Object key : keys) {
        
                  Session session = (Session) redisTemplate.opsForValue().get(key);
                  sessionSet.add(session);
              }
              return sessionSet;
          }
      }

将RedisSessionDAO交给SessionManager

@Bean
      public SessionManager sessionManager(RedisSessionDAO sessionDAO) {
        
          DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
          sessionManager.setSessionDAO(sessionDAO);
          return sessionManager;
      }

将SessionManager注入到SecurityManager

@Bean
      public DefaultWebSecurityManager securityManager(ShiroRealm realm,SessionManager sessionManager){
        
          DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
          securityManager.setRealm(realm);
          securityManager.setSessionManager(sessionManager);
          return securityManager;
      }

## 使用 RedisSession 问题 ##

将传统的基于Web容器或者ConcurrentHashMap切换为Redis之后，发现每次请求需要访问多次Redis服务，这个访问的频次会出现很长时间的IO等待，对每次请求的性能减低了，并且对Redis的压力也提高了。

基于装饰者模式重新声明SessionManager中提供的retrieveSession方法，让每次请求先去request域中查询session信息，request域中没有，再去Redis中查询

public class DefaultRedisWebSessionManager extends DefaultWebSessionManager {
        
    
          @Override
          protected Session retrieveSession(SessionKey sessionKey) throws UnknownSessionException {
        
              // 通过sessionKey获取sessionId
              Serializable sessionId = getSessionId(sessionKey);
    
              // 将sessionKey转为WebSessionKey
              if(sessionKey instanceof WebSessionKey){
        
                  WebSessionKey webSessionKey = (WebSessionKey) sessionKey;
                  // 获取到request域
                  ServletRequest request = webSessionKey.getServletRequest();
                  // 通过request尝试获取session信息
                  Session session = (Session) request.getAttribute(sessionId + "");
                  if(session != null){
        
                      System.out.println("从request域中获取session信息");
                      return session;
                  }else{
        
                      session = retrieveSessionFromDataSource(sessionId);
                      if (session == null) {
        
                          //session ID was provided, meaning one is expected to be found, but we couldn't find one:
                          String msg = "Could not find session with ID [" + sessionId + "]";
                          throw new UnknownSessionException(msg);
                      }
                      System.out.println("Redis---doReadSession");
                      request.setAttribute(sessionId + "",session);
                      return session;
                  }
              }
              return null;
          }
      }

配置DefaultRedisWebSessionManager到SecurityManager中

@Bean
      public SessionManager sessionManager(RedisSessionDAO sessionDAO) {
        
          DefaultRedisWebSessionManager sessionManager = new DefaultRedisWebSessionManager();
          sessionManager.setSessionDAO(sessionDAO);
          return sessionManager;
      }

## Shiro的授权缓存 ##

如果后台接口存在授权操作，那么每次请求都需要去数据库查询对应的角色信息和权限信息，对数据库来说，这样的查询压力太大了。

在Shiro中，发现每次在执行自定义Realm的授权方法查询数据库之前，会有一个执行Cache的操作。先从Cache中基于一个固定的key去查询角色以及权限的信息。

只需要提供好响应的CacheManager实例，还要实现一个与Redis交互的Cache对象，将Cache对象设置到CacheManager实例中。

将上述设置好的CacheManager设置到SecurityManager对象中

### 实现RedisCache ###

@Component
    public class RedisCache<K, V> implements Cache<K, V> {
        
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        private final String CACHE_PREFIX = "cache:";
    
        /**
         * 获取授权缓存信息
         * @param k
         * @return
         * @throws CacheException
         */
        @Override
        public V get(K k) throws CacheException {
        
            V v = (V) redisTemplate.opsForValue().get(CACHE_PREFIX + k);
            if(v != null){
        
                redisTemplate.expire(CACHE_PREFIX + k,15, TimeUnit.MINUTES);
            }
            return v;
        }
    
        /**
         * 存放缓存信息
         * @param k
         * @param v
         * @return
         * @throws CacheException
         */
        @Override
        public V put(K k, V v) throws CacheException {
        
            redisTemplate.opsForValue().set(CACHE_PREFIX + k,v,15,TimeUnit.MINUTES);
            return v;
        }
    
        /**
         * 清空当前缓存
         * @param k
         * @return
         * @throws CacheException
         */
        @Override
        public V remove(K k) throws CacheException {
        
            V v = (V) redisTemplate.opsForValue().get(CACHE_PREFIX + k);
            if(v != null){
        
                redisTemplate.delete(CACHE_PREFIX + k);
            }
            return v;
        }
    
        /**
         * 清空全部的授权缓存
         * @throws CacheException
         */
        @Override
        public void clear() throws CacheException {
        
            Set keys = redisTemplate.keys(CACHE_PREFIX + "*");
            redisTemplate.delete(keys);
        }
    
        /**
         * 查看有多个权限缓存信息
         * @return
         */
        @Override
        public int size() {
        
            Set keys = redisTemplate.keys(CACHE_PREFIX + "*");
            return keys.size();
        }
    
        /**
         * 获取全部缓存信息的key
         * @return
         */
        @Override
        public Set<K> keys() {
        
            Set keys = redisTemplate.keys(CACHE_PREFIX + "*");
            return keys;
        }
    
        /**
         * 获取全部缓存信息的value
         * @return
         */
        @Override
        public Collection<V> values() {
        
            Set values = new HashSet();
            Set keys = redisTemplate.keys(CACHE_PREFIX + "*");
            for (Object key : keys) {
        
                Object value = redisTemplate.opsForValue().get(key);
                values.add(value);
            }
            return values;
        }
    }

### 实现CacheManager ###

@Component
    public class RedisCacheManager implements CacheManager {
        
        @Autowired
        private RedisCache redisCache;
    
        @Override
        public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        
            return redisCache;
        }
    }

将RedisCacheManager配置到SecurityManager

@Bean
    public DefaultWebSecurityManager securityManager(ShiroRealm realm, SessionManager sessionManager, RedisCacheManager redisCacheManager){
        
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        securityManager.setSessionManager(sessionManager);
        // 设置CacheManager，提供与Redis交互的Cache对象
        securityManager.setCacheManager(redisCacheManager);
        return securityManager;
    }

启用授权缓存后，Shiro框架会将授权数据缓存在内存中，以便快速进行授权验证。在需要进行授权验证时，Shiro框架会首先从缓存中查找授权数据，如果缓存中不存在，则会从数据源中获取授权数据，并将其缓存到内存中。

需要注意的是，授权缓存可能会导致数据的过时。因此，在启用授权缓存时，需要根据具体的业务需求，设置合适的缓存失效时间和更新机制，以确保授权数据的实时性和准确性。