本文首发于 vivo互联网技术 微信公众号 https://mp.weixin.qq.com/s/KCOFv0nRuymkX79-RZi9eg
作者：张正林
HTTP协议本身是无状态的，为了保存会话信息，浏览器Cookie通过SessionID标识会话请求，服务器以SessionID为key来存储会话信息。在单实例应用中，可以考虑应用进程自身存储，随着应用体量的增长，需要横向扩容，多实例session共享问题随之而来。
Spring Session就是为了解决多进程session共享的问题，本文将介绍怎么使用Spring Session，以及Spring Session工作原理。
1、引入背景
应用部署在Tomcat时，session是由Tomcat内存维护，如果应用部署多个实例，session就不能共享。Spring Session就是解决为了解决分布式场景中的session共享问题。
2、使用方法
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" 3class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"> 4 <!--配置Redis连接池 ，可以不配置，使用默认就行！--> 5 p:poolConfig-ref="jedisPoolConfig" 6 </bean> 7 8 <!--创建一个Spring Bean的名称springSessionRepositoryFilter实现过滤器--> 9 <bean 10class="org.springframework.session.data.redis.config.annotation. 11 web.http.RedisHttpSessionConfiguration"> 12 <!--默认session时效30分钟--> 13 <property name="maxInactiveIntervalInSeconds" value="60" /> 14 </bean>
3、工作流程
Tomcat web.xml解析步骤：
1contextInitialized(ServletContextEvent arg0); // Listener 2init(FilterConfig filterConfig); // Filter 3init(ServletConfig config); // Servlet
初始化顺序：Listener > Filter > Servlet。
1) 通过 Tomcat 的 listener 把SessionRepositoryFilter加载到Spring容器中。
上一小节Spring配置文件里面声明了RedisHttpSessionConfiguration，正是在其父类SpringHttpSessionConfiguration中生成了SessionRepositoryFilter：
1@Bean 2public <S extends ExpiringSession> SessionRepositoryFilter 3<? extends ExpiringSession> springSessionRepositoryFilter( 4 SessionRepository<S> sessionRepository) { 5 ...... 6 return sessionRepositoryFilter; 7}
RedisHttpSessionConfiguration类继承关系
2) filter初始化
web.xml里面配置的filter是DelegatingFilterProxy。
DelegatingFilterProxy类继承关系
DelegatingFilterProxy初始化入口在其父类GenericFilterBean中：
1public final void init(FilterConfig filterConfig) throws ServletException { 2 ...... 3 // Let subclasses do whatever initialization they like. 4 initFilterBean(); 5 ...... 6 }
DelegatingFilterProxy去Spring容器取第1步初始化好的springSessionRepositoryFilter：
1protected 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 工作核心流程：
1protected 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 } 17
4、缓存机制
每一个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的主要内容：
1hgetall spring:session:sessions:1b8b2340-da25-4ca6-864c-4af28f033327 2 1) "creationTime" 3 2) "\xac\xed\x00\x05sr\x00\x0ejava.lang.Long; 4 \x8b\xe4\x90\xcc\x8f#\xdf\x02\x00\x01J\x00 5 \x05valuexr\x00\x10java.lang.Number\x86\xac 6 \x95\x1d\x0b\x94\xe0\x8b\x02\x00\x00xp\x00 7 \x00\x01j\x9b\x83\x9d\xfd" 8 3) "maxInactiveInterval" 9 4) "\xac\xed\x00\x05sr\x00\x11java.lang.Integer\x12 10 \xe2\xa0\xa4\xf7\x81\x878\x02\x00\x01I\x00\x05valuexr 11 \x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94 12 \xe0\x8b\x02\x00\x00xp\x00\x00\a\b" 13 5) "lastAccessedTime" 14 6) "\xac\xed\x00\x05sr\x00\x0ejava.lang.Long;\x8b 15 \xe4\x90\xcc\x8f#\xdf\x02\x00\x01J\x00\x05valuexr 16 \x00\x10java.lang.Number\x86\xac\x95\x1d\x0b\x94 17 \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键值：
1smembers spring:session:expirations:1557389100000 21) "\xac\xed\x00\x05t\x00,expires:1b8b2340-da25-4ca6-864c-4af28f033327"
RedisSessionExpirationPolicy，三个键值生成流程：
1public 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过期键有三种删除策略，分别是定时删除，惰性删除，定期删除。
- 定时删除：通过维护一个定时器，过期马上删除，是最有效的，但是也是最浪费cpu时间的。
- 惰性删除：程序在取出键时才判断它是否过期，过期才删除，这个方法对cpu时间友好，对内存不友好。
- 定期删除：每隔一定时间执行一次删除过期键的操作，并限制每次删除操作的执行时长和频率，是一种折中。
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清理定时任务
1public 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 }
5、事件订阅
默认至少订阅键空间通知gxE事件（http://redisdoc.com/topic/notification.html）。
ConfigureNotifyKeyspaceEventsAction，开启键空间通知：
1public 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，事件处理：
1public 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 2public class SessionExpiredListener implements ApplicationListener<SessionExpiredEvent> { 3 @Override 4 public void onApplicationEvent(SessionExpiredEvent event) { 5 ...... 6 } 7}
6、总结
Spring Session给我们提供了很好的分布式环境下资源共享问题解决思路，其基于Servlet 规范实现，业务使用时只需要简单配置就可以实现session共享，做到与业务低耦合，这都是以后我们项目开发中可以借签的设计理念。
更多内容敬请关注 vivo 互联网技术 微信公众号
注：转载文章请先与微信号：labs2020 联系。