HTTP协议本身是无状态的，为了保存会话信息，浏览器Cookie通过SessionID标识会话请求，服务器以SessionID为key来存储会话信息。在单实例应用中，可以考虑应用进程自身存储，随着应用体量的增长，需要横向扩容，多实例Session共享问题随之而来。
Spring Session就是为了解决多进程session共享的问题，本文将介绍怎么使用Spring Session，以及Spring Session工作原理。

本文首发于 vivo互联网技术 微信公众号 https://mp.weixin.qq.com/s/KCOFv0nRuymkX79-RZi9eg 
作者：张正林

目录：
1、引入背景
2、使用方法
3、工作流程
4、缓存机制
5、事件订阅
6、总结

HTTP协议本身是无状态的，为了保存会话信息，浏览器Cookie通过SessionID标识会话请求，服务器以SessionID为key来存储会话信息。在单实例应用中，可以考虑应用进程自身存储，随着应用体量的增长，需要横向扩容，多实例session共享问题随之而来。

Spring Session就是为了解决多进程session共享的问题，本文将介绍怎么使用Spring Session，以及Spring Session工作原理。

应用部署在Tomcat时，session是由Tomcat内存维护，如果应用部署多个实例，session就不能共享。Spring Session就是解决为了解决分布式场景中的session共享问题。

Spring Session支持存储在Hazelcast 、Redis、MongoDB、关系型数据库，本文主要讨论session存储在Redis。

web.xml配置：

  1. <!-- spring session -->
  2.   <filter>
  3.     <filter-name>springSessionRepositoryFilter</filter-name>
  4.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  5.   </filter>
  6.   <filter-mapping>
  7.     <filter-name>springSessionRepositoryFilter</filter-name>
  8.     <url-pattern>/*</url-pattern>
  9.   </filter-mapping>

Spring 主要配置：

  1. <!--创建了一个RedisConnectionFactory，它将Spring会话连接到Redis服务器-->
  2.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  3.         <!--配置Redis连接池 ，可以不配置，使用默认就行！-->
  4.         p:poolConfig-ref="jedisPoolConfig"
  5.     </bean>
  6.  
  7.     <!--创建一个Spring Bean的名称springSessionRepositoryFilter实现过滤器-->
  8.     <bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
  9.         <!--默认session时效30分钟-->
  10.         <property name="maxInactiveIntervalInSeconds" value="60" />
  11.     </bean>

Tomcat web.xml解析步骤：

  1. contextInitialized(ServletContextEvent arg0); // Listener
  2. init(FilterConfig filterConfig); // Filter
  3. init(ServletConfig config); // Servlet

初始化顺序：Listener > Filter > Servlet。

1) 通过 Tomcat 的 listener 把SessionRepositoryFilter加载到Spring容器中。

上一小节Spring配置文件里面声明了RedisHttpSessionConfiguration，正是在其父类SpringHttpSessionConfiguration中生成了SessionRepositoryFilter：

  2. @Bean
  3. public <S extends ExpiringSession> SessionRepositoryFilter<? extends ExpiringSession> springSessionRepositoryFilter(
  4.         SessionRepository<S> sessionRepository) {
  5.     ......
  6.     return sessionRepositoryFilter;
  7. }
 

RedisHttpSessionConfiguration类继承关系

2) filter初始化

web.xml里面配置的filter是DelegatingFilterProxy。

DelegatingFilterProxy类继承关系

DelegatingFilterProxy初始化入口在其父类GenericFilterBean中：

  1. public final void init(FilterConfig filterConfig) throws ServletException {
  2.         ......
  3.         // Let subclasses do whatever initialization they like.
  4.         initFilterBean();
  5.         ......
  6.     }

DelegatingFilterProxy去Spring容器取第1步初始化好的springSessionRepositoryFilter：

  1. protected void initFilterBean() throws ServletException {
  2.         synchronized (this.delegateMonitor) {
  3.             if (this.delegate == null) {
  4.                 // If no target bean name specified, use filter name.
  5.                 if (this.targetBeanName == null) {
  6.                     //targetBeanName 为springSessionRepositoryFilter
  7.                     this.targetBeanName = getFilterName();
  8.                 }
  9.                 WebApplicationContext wac = findWebApplicationContext();
  10.                 if (wac != null) {
  11.                     this.delegate = initDelegate(wac);
  12.                 }
  13.             }
  14.         }
  15.     }

至此 sessionRepositoryFilter 初始化完成，DelegatingFilterProxy 实际代理了SessionRepositoryFilter。

SessionRepositoryFilter 工作核心流程：

  1. protected void doFilterInternal(HttpServletRequest request,
  2.            HttpServletResponse response, FilterChain filterChain)
  3.            throws ServletException, IOException {
  4.        request.setAttribute(SESSION_REPOSITORY_ATTR, this.sessionRepository);
  5.        //包装了HttpServletRequest，覆写了HttpServletRequest中 getSession(boolean create)方法
  6.        SessionRepositoryRequestWrapper wrappedRequest = new SessionRepositoryRequestWrapper(
  7.                request, response, this.servletContext);
  8.              ......
  9.        try {
  10.            filterChain.doFilter(strategyRequest, strategyResponse);
  11.        }
  12.        finally {
  13.            //保证session持久化
  14.            wrappedRequest.commitSession();
  15.        }
  16.    }

每一个session，Redis实际缓存的数据如下：

spring:session:sessions:1b8b2340-da25-4ca6-864c-4af28f033327
spring:session:sessions:expires:1b8b2340-da25-4ca6-864c-4af28f033327
spring:session:expirations:1557389100000

spring:session:sessions为hash结构，存储Spring Session的主要内容：

  1. hgetall spring:session:sessions:1b8b2340-da25-4ca6-864c-4af28f033327
  2.  1) "creationTime"
  3.  2) "\xac\xed\x00\x05sr\x00\x0ejava.lang.Long;\x8b\xe4\x90\xcc\x8f#\xdf\x02\x00\x01J\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x01j\x9b\x83\x9d\xfd"
  4.  3) "maxInactiveInterval"
  5.  4) "\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12\xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\a\b"
  6.  5) "lastAccessedTime"
  7.  6) "\xac\xed\x00\x05sr\x00\x0ejava.lang.Long;\x8b\xe4\x90\xcc\x8f#\xdf\x02\x00\x01J\x00\x05valuexr\x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00\x00\x01j\x9b\x83\x9d\xfd"

spring:session:sessions:expires 为 string 结构，存储一个空值。

spring:session:expirations为set结构，存储1557389100000 时间点过期的spring:session:sessions:expires键值：

  1. smembers spring:session:expirations:1557389100000
  2. 1) "\xac\xed\x00\x05t\x00,expires:1b8b2340-da25-4ca6-864c-4af28f033327"

RedisSessionExpirationPolicy，三个键值生成流程：

  1. public void onExpirationUpdated(Long originalExpirationTimeInMilli,
  2.             ExpiringSession session) {
  3.         String keyToExpire = "expires:" + session.getId();
  4.         long toExpire = roundUpToNextMinute(expiresInMillis(session));
  5.                 ......
  6.         //把spring:session:sessions:expires加入到spring:session:expirations开头的key里面
  7.         String expireKey = getExpirationKey(toExpire);
  8.         BoundSetOperations<Object, Object> expireOperations = this.redis
  9.                 .boundSetOps(expireKey);
  10.         expireOperations.add(keyToExpire);
  11.  
  12.         long fiveMinutesAfterExpires = sessionExpireInSeconds
  13.                 + TimeUnit.MINUTES.toSeconds(5);
  14.         //spring:session:expirations开头的key过期时间为xml配置的时间后五分钟
  15.         expireOperations.expire(fiveMinutesAfterExpires, TimeUnit.SECONDS);
  16.         if (sessionExpireInSeconds == 0) {
  17.             this.redis.delete(sessionKey);
  18.         }
  19.         else {
  20.             //spring:session:sessions:expires开头的key过期时间为xml配置的时间
  21.             this.redis.boundValueOps(sessionKey).append("");
  22.             this.redis.boundValueOps(sessionKey).expire(sessionExpireInSeconds,
  23.                     TimeUnit.SECONDS);
  24.         }
  25.         //spring:session:sessions开头的key过期时间为xml配置的时间后五分钟
  26.         this.redis.boundHashOps(getSessionKey(session.getId()))
  27.                 .expire(fiveMinutesAfterExpires, TimeUnit.SECONDS);
  28.     }

Redis过期键有三种删除策略，分别是定时删除，惰性删除，定期删除。

  1. 定时删除：通过维护一个定时器，过期马上删除，是最有效的，但是也是最浪费cpu时间的。
  2. 惰性删除：程序在取出键时才判断它是否过期，过期才删除，这个方法对cpu时间友好，对内存不友好。
  3. 定期删除：每隔一定时间执行一次删除过期键的操作，并限制每次删除操作的执行时长和频率，是一种折中。

Redis采用了惰性删除和定期删除的策略。由此可见依赖 Redis 的过期策略实时删除过期key是不可靠的。

另外一方面，业务可能会在Spring Session过期后做业务逻辑处理，同时需要session里面的信息，如果只有一个 spring:session:sessions键值，那么Redis删除就删除了，业务没法获取session信息。

spring:session:expirations键中存储了spring:session:sessions:expires键，而spring:session:sessions:expires键过期五分钟早于spring:session:expirations键和spring:session:sessions键（实际Spring Session对于过期事件处理订阅的spring:session:sessions:expires键，下一节会具体讲），这样在订阅到过期事件时还能获取spring:session:sessions键值。

如果通过Redis本身清理机制未及时清除spring:session:sessions:expires，可以通过Spring Session提供的定时任务兜底，保证spring:session:sessions:expires清除。

RedisSessionExpirationPolicy，session清理定时任务

  1. public void cleanExpiredSessions() {
  2.         long now = System.currentTimeMillis();
  3.         long prevMin = roundDownMinute(now);
  4.         ......
  5.         //获取到spring:session:expirations键
  6.         String expirationKey = getExpirationKey(prevMin);
  7.         // 取出当前这一分钟应当过期的 session
  8.         Set<Object> sessionsToExpire = this.redis.boundSetOps(expirationKey).members();
  9.         // 注意：这里删除的是spring:session:expirations键，不是删除 session 本身！
  10.         this.redis.delete(expirationKey);
  11.         for (Object session : sessionsToExpire) {
  12.             String sessionKey = getSessionKey((String) session);
  13.             //遍历一下spring:session:sessions:expires键
  14.             touch(sessionKey);
  15.         }
  16.     }
  17.  
  18.     /**
  19.      * By trying to access the session we only trigger a deletion if it the TTL is
  20.      * expired. This is done to handle
  21.      * https://github.com/spring-projects/spring-session/issues/93
  22.      *
  23.      * @param key the key
  24.      */
  25.     private void touch(String key) {
  26.         //并不是直接删除 key，而只是访问 key，通过惰性删除确保spring:session:sessions:expires键实时删除，
  27.         // 同时也保证多线程并发续签的场景下，key移动到不同spring:session:expirations键里面时，
  28.         //以spring:session:sessions:expires键实际ttl时间为准
  29.         this.redis.hasKey(key);
  30.     }

默认至少订阅键空间通知gxE事件（http://redisdoc.com/topic/notification.html）。

ConfigureNotifyKeyspaceEventsAction，开启键空间通知：

  1. public void configure(RedisConnection connection) {
  2.        String notifyOptions = getNotifyOptions(connection);
  3.        String customizedNotifyOptions = notifyOptions;
  4.        if (!customizedNotifyOptions.contains("E")) {
  5.            customizedNotifyOptions += "E";
  6.        }
  7.        boolean A = customizedNotifyOptions.contains("A");
  8.        if (!(A || customizedNotifyOptions.contains("g"))) {
  9.            customizedNotifyOptions += "g";
  10.        }
  11.        if (!(A || customizedNotifyOptions.contains("x"))) {
  12.            customizedNotifyOptions += "x";
  13.        }
  14.        if (!notifyOptions.equals(customizedNotifyOptions)) {
  15.            connection.setConfig(CONFIG_NOTIFY_KEYSPACE_EVENTS, customizedNotifyOptions);
  16.        }
  17.    }

RedisHttpSessionConfiguration，注册监听事件：

  1. @Bean
  2.  public RedisMessageListenerContainer redisMessageListenerContainer(
  3.          RedisConnectionFactory connectionFactory,
  4.          RedisOperationsSessionRepository messageListener) {
  5.              ......
  6.      //psubscribe del和expired事件
  7.      container.addMessageListener(messageListener,
  8.              Arrays.asList(new PatternTopic("__keyevent@*:del"),
  9.                      new PatternTopic("__keyevent@*:expired")));
  10.      //psubscribe created事件
  11.      container.addMessageListener(messageListener, Arrays.asList(new PatternTopic(
  12.              messageListener.getSessionCreatedChannelPrefix() + "*")));
  13.      return container;
  14.  }

RedisOperationsSessionRepository，事件处理：

  1. public void onMessage(Message message, byte[] pattern) {
  2.       ......
  3.       if (channel.startsWith(getSessionCreatedChannelPrefix())) {
  4.           ...
  5.           //处理spring:session created事件
  6.           handleCreated(loaded, channel);
  7.           return;
  8.       }
  9.  
  10.       //非spring:session:sessions:expires事件不做处理
  11.       String body = new String(messageBody);
  12.       if (!body.startsWith(getExpiredKeyPrefix())) {
  13.           return;
  14.       }
  15.  
  16.       boolean isDeleted = channel.endsWith(":del");
  17.       if (isDeleted || channel.endsWith(":expired")) {
  18.           ......
  19.           if (isDeleted) {
  20.               //处理spring:session:sessions:expires del事件
  21.               handleDeleted(sessionId, session);
  22.           }
  23.           else {
  24.               //处理spring:session:sessions:expires expired事件
  25.               handleExpired(sessionId, session);
  26.           }
  27.           ......
  28.           return;
  29.       }
  30.   }

事件订阅样例：

  1. @Component
  2. public class SessionExpiredListener implements ApplicationListener<SessionExpiredEvent> {
  3.     @Override
  4.     public void onApplicationEvent(SessionExpiredEvent event) {
  5.         ......
  6.     }
  7. }

Spring Session给我们提供了很好的分布式环境下资源共享问题解决思路，其基于Servlet 规范实现，业务使用时只需要简单配置就可以实现session共享，做到与业务低耦合，这都是以后我们项目开发中可以借签的设计理念。

更多内容敬请关注 vivo 互联网技术 微信公众号

 

注：转载文章请先与微信号：labs2020 联系。

版权声明：本文为vivotech原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/vivotech/p/11265381.html