本文首發於 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工作原理。

1、引入背景

應用部署在Tomcat時，session是由Tomcat記憶體維護，如果應用部署多個例項，session就不能共享。Spring Session就是解決為了解決分散式場景中的session共享問題。

2、使用方法

Spring Session支援儲存在Hazelcast 、Redis、MongoDB、關係型資料庫，本文主要討論session儲存在Redis。

web.xml配置：

<!-- spring session -->
  <filter>
    <filter-name>springSessionRepositoryFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>springSessionRepositoryFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

Spring 主要配置：

<!--建立了一個RedisConnectionFactory，它將Spring會話連線到Redis伺服器-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <!--配置Redis連線池 ，可以不配置，使用預設就行！-->
        p:poolConfig-ref="jedisPoolConfig"    </bean>
 
    <!--建立一個Spring Bean的名稱springSessionRepositoryFilter實現過濾器-->
    <bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
        <!--預設session時效30分鐘-->
        <property name="maxInactiveIntervalInSeconds" value="60" />
    </bean>

3、工作流程

Tomcat web.xml解析步驟：

contextInitialized(ServletContextEvent arg0); // Listenerinit(FilterConfig filterConfig); // Filterinit(ServletConfig config); // Servlet

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

1) 透過 Tomcat 的 listener 把SessionRepositoryFilter載入到Spring容器中。

上一小節Spring配置檔案裡面宣告瞭RedisHttpSessionConfiguration，正是在其父類SpringHttpSessionConfiguration中生成了SessionRepositoryFilter：

@Beanpublic <S extends ExpiringSession> SessionRepositoryFilter<? extends ExpiringSession> springSessionRepositoryFilter(
        SessionRepository<S> sessionRepository) {
    ......    return sessionRepositoryFilter;
}

RedisHttpSessionConfiguration類繼承關係

2) filter初始化

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

DelegatingFilterProxy類繼承關係

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

public final void init(FilterConfig filterConfig) throws ServletException {
        ......        // Let subclasses do whatever initialization they like.
        initFilterBean();
        ......
    }

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

protected void initFilterBean() throws ServletException {        synchronized (this.delegateMonitor) {            if (this.delegate == null) {                // If no target bean name specified, use filter name.
                if (this.targetBeanName == null) {                    //targetBeanName 為springSessionRepositoryFilter
                    this.targetBeanName = getFilterName();
                }
                WebApplicationContext wac = findWebApplicationContext();                if (wac != null) {                    this.delegate = initDelegate(wac);
                }
            }
        }
    }

至此 sessionRepositoryFilter 初始化完成，DelegatingFilterProxy 實際代理了SessionRepositoryFilter。

SessionRepositoryFilter 工作核心流程：

protected void doFilterInternal(HttpServletRequest request,
           HttpServletResponse response, FilterChain filterChain)
           throws ServletException, IOException {
       request.setAttribute(SESSION_REPOSITORY_ATTR, this.sessionRepository);       //包裝了HttpServletRequest，覆寫了HttpServletRequest中 getSession(boolean create)方法
       SessionRepositoryRequestWrapper wrappedRequest = new SessionRepositoryRequestWrapper(
               request, response, this.servletContext);
             ......       try {
           filterChain.doFilter(strategyRequest, strategyResponse);
       }       finally {           //保證session持久化
           wrappedRequest.commitSession();
       }
   }

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的主要內容：

hgetall spring:session:sessions:1b8b2340-da25-4ca6-864c-4af28f033327
 1) "creationTime"
 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"
 3) "maxInactiveInterval"
 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"
 5) "lastAccessedTime"
 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鍵值：

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

RedisSessionExpirationPolicy，三個鍵值生成流程：

public void onExpirationUpdated(Long originalExpirationTimeInMilli,
            ExpiringSession session) {
        String keyToExpire = "expires:" + session.getId();        long toExpire = roundUpToNextMinute(expiresInMillis(session));
                ......        //把spring:session:sessions:expires加入到spring:session:expirations開頭的key裡面
        String expireKey = getExpirationKey(toExpire);
        BoundSetOperations<Object, Object> expireOperations = this.redis
                .boundSetOps(expireKey);
        expireOperations.add(keyToExpire); 
        long fiveMinutesAfterExpires = sessionExpireInSeconds
                + TimeUnit.MINUTES.toSeconds(5);        //spring:session:expirations開頭的key過期時間為xml配置的時間後五分鐘
        expireOperations.expire(fiveMinutesAfterExpires, TimeUnit.SECONDS);        if (sessionExpireInSeconds == 0) {            this.redis.delete(sessionKey);
        }        else {            //spring:session:sessions:expires開頭的key過期時間為xml配置的時間
            this.redis.boundValueOps(sessionKey).append("");            this.redis.boundValueOps(sessionKey).expire(sessionExpireInSeconds,
                    TimeUnit.SECONDS);
        }        //spring:session:sessions開頭的key過期時間為xml配置的時間後五分鐘
        this.redis.boundHashOps(getSessionKey(session.getId()))
                .expire(fiveMinutesAfterExpires, TimeUnit.SECONDS);
    }

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清理定時任務

public void cleanExpiredSessions() {
        long now = System.currentTimeMillis();
        long prevMin = roundDownMinute(now);
        ......        //獲取到spring:session:expirations鍵
        String expirationKey = getExpirationKey(prevMin);        // 取出當前這一分鐘應當過期的 session
        Set<Object> sessionsToExpire = this.redis.boundSetOps(expirationKey).members();        // 注意：這裡刪除的是spring:session:expirations鍵，不是刪除 session 本身！
        this.redis.delete(expirationKey);        for (Object session : sessionsToExpire) {            String sessionKey = getSessionKey((String) session);            //遍歷一下spring:session:sessions:expires鍵
            touch(sessionKey);
        }
    } 
    /**
     * By trying to access the session we only trigger a deletion if it the TTL is
     * expired. This is done to handle
     * 
     *
     * @param key the key
     */
    private void touch(String key) {        //並不是直接刪除 key，而只是訪問 key，透過惰性刪除確保spring:session:sessions:expires鍵實時刪除，
        // 同時也保證多執行緒併發續簽的場景下，key移動到不同spring:session:expirations鍵裡面時，
        //以spring:session:sessions:expires鍵實際ttl時間為準
        this.redis.hasKey(key);
    }

5、事件訂閱

預設至少訂閱鍵空間通知gxE事件（

ConfigureNotifyKeyspaceEventsAction，開啟鍵空間通知：

public void configure(RedisConnection connection) {
       String notifyOptions = getNotifyOptions(connection);
       String customizedNotifyOptions = notifyOptions;       if (!customizedNotifyOptions.contains("E")) {
           customizedNotifyOptions += "E";
       }       boolean A = customizedNotifyOptions.contains("A");       if (!(A || customizedNotifyOptions.contains("g"))) {
           customizedNotifyOptions += "g";
       }       if (!(A || customizedNotifyOptions.contains("x"))) {
           customizedNotifyOptions += "x";
       }       if (!notifyOptions.equals(customizedNotifyOptions)) {
           connection.setConfig(CONFIG_NOTIFY_KEYSPACE_EVENTS, customizedNotifyOptions);
       }
   }

RedisHttpSessionConfiguration，註冊監聽事件：

@Bean
 public RedisMessageListenerContainer redisMessageListenerContainer(
         RedisConnectionFactory connectionFactory,
         RedisOperationsSessionRepository messageListener) {
             ......     //psubscribe del和expired事件
     container.addMessageListener(messageListener,
             Arrays.asList(new PatternTopic("__keyevent@*:del"),                     new PatternTopic("__keyevent@*:expired")));     //psubscribe created事件
     container.addMessageListener(messageListener, Arrays.asList(new PatternTopic(
             messageListener.getSessionCreatedChannelPrefix() + "*")));     return container;
 }

RedisOperationsSessionRepository，事件處理：

public void onMessage(Message message, byte[] pattern) {
      ......      if (channel.startsWith(getSessionCreatedChannelPrefix())) {
          ...          //處理spring:session created事件
          handleCreated(loaded, channel);          return;
      } 
      //非spring:session:sessions:expires事件不做處理
      String body = new String(messageBody);      if (!body.startsWith(getExpiredKeyPrefix())) {          return;
      } 
      boolean isDeleted = channel.endsWith(":del");      if (isDeleted || channel.endsWith(":expired")) {
          ......          if (isDeleted) {              //處理spring:session:sessions:expires del事件
              handleDeleted(sessionId, session);
          }          else {              //處理spring:session:sessions:expires expired事件
              handleExpired(sessionId, session);
          }
          ......          return;
      }
  }

事件訂閱樣例：

@Componentpublic class SessionExpiredListener implements ApplicationListener<SessionExpiredEvent> {    @Override
    public void onApplicationEvent(SessionExpiredEvent event) {
        ......
    }
}

6、總結

Spring Session給我們提供了很好的分散式環境下資源共享問題解決思路，其基於Servlet 規範實現，業務使用時只需要簡單配置就可以實現session共享，做到與業務低耦合，這都是以後我們專案開發中可以借籤的設計理念。