Shiro 解决分布式 Session

文章目录

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

前言

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

Shiro 会话管理组件

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

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

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

配置 RedisSessionManager

导入依赖

    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-data-redisartifactId>
    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框架会首先从缓存中查找授权数据,如果缓存中不存在,则会从数据源中获取授权数据,并将其缓存到内存中。

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

你可能感兴趣的:(Java,分布式,java)