SpringHttpSessionConfiguration

1. SpringHttpSessionConfiguration是RedisHttpSessionConfiguration的父類

2. 程式碼

   @Configuration
   public class SpringHttpSessionConfiguration {
   
       private CookieHttpSessionStrategy defaultHttpSessionStrategy = new CookieHttpSessionStrategy();
   
       private HttpSessionStrategy httpSessionStrategy = this
    
   .defaultHttpSessionStrategy;
   
       private List<HttpSessionListener> httpSessionListeners = new ArrayList<HttpSessionListener>();
   
       private ServletContext servletContext;
   
       @Bean
       public SessionEventHttpSessionListenerAdapter sessionEventHttpSessionListenerAdapter() {
           return
    
    new SessionEventHttpSessionListenerAdapter(this.httpSessionListeners);
       }
       /***
       SessionRepositoryFilter的Bean是在這裡被注入的
       **/
       @Bean
       public <S extends ExpiringSession> SessionRepositoryFilter<? extends ExpiringSession> springSessionRepositoryFilter(
               SessionRepository<S> sessionRepository) {
           SessionRepositoryFilter<S> sessionRepositoryFilter = new
    
    SessionRepositoryFilter<S>(
                   sessionRepository);
           sessionRepositoryFilter.setServletContext(this.servletContext);
           if (this.httpSessionStrategy instanceof MultiHttpSessionStrategy) {
               sessionRepositoryFilter.setHttpSessionStrategy(
                       (MultiHttpSessionStrategy) this.httpSessionStrategy);
           }
           else {
               sessionRepositoryFilter.setHttpSessionStrategy(this.httpSessionStrategy);
           }
           return sessionRepositoryFilter;
       }
   
       @Autowired(required = false)
       public void setServletContext(ServletContext servletContext) {
           this.servletContext = servletContext;
       }
   
       @Autowired(required = false)
       public void setCookieSerializer(CookieSerializer cookieSerializer) {
           this.defaultHttpSessionStrategy.setCookieSerializer(cookieSerializer);
       }
   
       @Autowired(required = false)
       public void setHttpSessionStrategy(HttpSessionStrategy httpSessionStrategy) {
           this.httpSessionStrategy = httpSessionStrategy;
       }
   
       @Autowired(required = false)
       public void setHttpSessionListeners(List<HttpSessionListener> listeners) {
           this.httpSessionListeners = listeners;
       }
   }

RedisHttpSessionConfiguration

1. 程式碼

           /**
           0.RedisHttpSessionConfiguration 是一個程式設計式註解
           1. @Configuration相當於xml中的<beans>標籤，使用AnnotationConfigApplicationContext讀取配置
           而xml使用ClassPathXmlApplicationContext讀取
           2. @EnableScheduling使用該註解讓Spring可以進行任務排程，功能類似於Spring的xml名稱空間<task:*>
           */
           @Configuration
           @EnableScheduling
           public class RedisHttpSessionConfiguration extends SpringHttpSessionConfiguration
                   implements ImportAware {
               //redis鍵的超時時間，即session,key的超時時間 
               private Integer maxInactiveIntervalInSeconds = 1800;
               /***
               *在Redis 2.8.0版本起，加入了“Keyspace notifications”（即“鍵空間通知”）的功能
               鍵空間通知，允許Redis客戶端從“釋出/訂閱”通道中建立訂閱關係，以便客戶端能夠在Redis中的資料因某種方式受到影響時收到相應事件
               在官方文件中，keyevent通道的格式永遠是這樣的：
           [email protected]<db>__:prefix
           對於資料過期事件，我們在繫結訂閱時通配模板也可以精確地寫成：
           [email protected]*__:expired
               **/
               private ConfigureRedisAction configureRedisAction = new ConfigureNotifyKeyspaceEventsAction();
               //redis key的名稱空間 spring:session:<redisNamespace>
               private String redisNamespace = "";
               /**
               *ON_SAVE  當呼叫SessionRepository.save時候才被呼叫，web環境下就是響應提交的時候(預設)
               IMMEDIATE 當建立SessionRepository.createSession() 的時候或者給session設定屬性的時候立即存入redis
               *ON_SAVE Only writes to Redis when SessionRepository.save(org.springframework.session.Session) is invoked. In a web environment this is typically done as soon as the HTTP response is committed.
               IMMEDIATE Writes to Redis as soon as possible. For example SessionRepository.createSession() will write the session to Redis. Another example is that setting an attribute on the session will also write to Redis immediately.
               **/
               private RedisFlushMode redisFlushMode = RedisFlushMode.ON_SAVE;
               //序列化方式
               private RedisSerializer<Object> defaultRedisSerializer;
   
               private Executor redisTaskExecutor;
   
               private Executor redisSubscriptionExecutor;
   
               /**
               RedisMessageListenerContainer 表示訊息監聽容器
               **/
               @Bean
               public RedisMessageListenerContainer redisMessageListenerContainer(
                       RedisConnectionFactory connectionFactory,
                       RedisOperationsSessionRepository messageListener) {
   
                   RedisMessageListenerContainer container = new RedisMessageListenerContainer();
                   container.setConnectionFactory(connectionFactory);
                   if (this.redisTaskExecutor != null) {
                       container.setTaskExecutor(this.redisTaskExecutor);
                   }
                   if (this.redisSubscriptionExecutor != null) {
                       container.setSubscriptionExecutor(this.redisSubscriptionExecutor);
                   }
                   /***
                   設定監聽器與釋出主題，主題名稱為 [email protected]*:del  [email protected]*:expired
                   ***/
                   container.addMessageListener(messageListener,
                           Arrays.asList(new PatternTopic("[email protected]*:del"),
                                   new PatternTopic("[email protected]*:expired")));
                   /***
                   * this.keyPrefix + "event:created:"+ "*";
                   **/
                   container.addMessageListener(messageListener, Arrays.asList(new PatternTopic(
                           messageListener.getSessionCreatedChannelPrefix() + "*")));
                   return container;
               }
   
               @Bean
               public RedisTemplate<Object, Object> sessionRedisTemplate(
                       RedisConnectionFactory connectionFactory) {
                   RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
                   template.setKeySerializer(new StringRedisSerializer());
                   template.setHashKeySerializer(new StringRedisSerializer());
                   if (this.defaultRedisSerializer != null) {
                       template.setDefaultSerializer(this.defaultRedisSerializer);
                   }
                   template.setConnectionFactory(connectionFactory);
                   return template;
               }
   
               @Bean
               public RedisOperationsSessionRepository sessionRepository(
                       @Qualifier("sessionRedisTemplate") RedisOperations<Object, Object> sessionRedisTemplate,
                       ApplicationEventPublisher applicationEventPublisher) {
                   RedisOperationsSessionRepository sessionRepository = new RedisOperationsSessionRepository(
                           sessionRedisTemplate);
                   sessionRepository.setApplicationEventPublisher(applicationEventPublisher);
                   sessionRepository
                           .setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
                   if (this.defaultRedisSerializer != null) {
                       sessionRepository.setDefaultSerializer(this.defaultRedisSerializer);
                   }
   
                   String redisNamespace = getRedisNamespace();
                   if (StringUtils.hasText(redisNamespace)) {
                       sessionRepository.setRedisKeyNamespace(redisNamespace);
                   }
   
                   sessionRepository.setRedisFlushMode(this.redisFlushMode);
                   return sessionRepository;
               }
   
               public void setMaxInactiveIntervalInSeconds(int maxInactiveIntervalInSeconds) {
                   this.maxInactiveIntervalInSeconds = maxInactiveIntervalInSeconds;
               }
   
               public void setRedisNamespace(String namespace) {
                   this.redisNamespace = namespace;
               }
   
               public void setRedisFlushMode(RedisFlushMode redisFlushMode) {
                   Assert.notNull(redisFlushMode, "redisFlushMode cannot be null");
                   this.redisFlushMode = redisFlushMode;
               }
   
               private String getRedisNamespace() {
                   if (StringUtils.hasText(this.redisNamespace)) {
                       return this.redisNamespace;
                   }
                   return System.getProperty("spring.session.redis.namespace", "");
               }
   
               public void setImportMetadata(AnnotationMetadata importMetadata) {
   
                   Map<String, Object> enableAttrMap = importMetadata
                           .getAnnotationAttributes(EnableRedisHttpSession.class.getName());
                   AnnotationAttributes enableAttrs = AnnotationAttributes.fromMap(enableAttrMap);
                   this.maxInactiveIntervalInSeconds = enableAttrs
                           .getNumber("maxInactiveIntervalInSeconds");
                   this.redisNamespace = enableAttrs.getString("redisNamespace");
                   this.redisFlushMode = enableAttrs.getEnum("redisFlushMode");
               }
   
               @Bean
               public InitializingBean enableRedisKeyspaceNotificationsInitializer(
                       RedisConnectionFactory connectionFactory) {
                   return new EnableRedisKeyspaceNotificationsInitializer(connectionFactory,
                           this.configureRedisAction);
               }
   
               /**
                * Sets the action to perform for configuring Redis.
                *
                * @param configureRedisAction the configureRedis to set. The default is
                * {@link ConfigureNotifyKeyspaceEventsAction}.
                */
               @Autowired(required = false)
               public void setConfigureRedisAction(ConfigureRedisAction configureRedisAction) {
                   this.configureRedisAction = configureRedisAction;
               }
               /**
               *如果需要覆蓋預設的Redis序列化實現類,在spring中將自己的實現類id設定為  springSessionDefaultRedisSerializer
               **/
               @Autowired(required = false)
               @Qualifier("springSessionDefaultRedisSerializer")
               public void setDefaultRedisSerializer(
                       RedisSerializer<Object> defaultRedisSerializer) {
                   this.defaultRedisSerializer = defaultRedisSerializer;
               }
           /**
               *如果需要覆蓋預設Redis任務多執行緒Executor,在spring中將自己的實現類id設定為springSessionRedisTaskExecutor
               **/
               @Autowired(required = false)
               @Qualifier("springSessionRedisTaskExecutor")
               public void setRedisTaskExecutor(Executor redisTaskExecutor) {
                   this.redisTaskExecutor = redisTaskExecutor;
               }
               /**
               *如果需要覆蓋預設訂閱任務多執行緒Executor,在spring中將自己的實現類id設定為   springSessionRedisSubscriptionExecutor
               **/
               @Autowired(required = false)
               @Qualifier("springSessionRedisSubscriptionExecutor")
               public void setRedisSubscriptionExecutor(Executor redisSubscriptionExecutor) {
                   this.redisSubscriptionExecutor = redisSubscriptionExecutor;
               }
   
               /**
                * Ensures that Redis is configured to send keyspace notifications. This is important
                * to ensure that expiration and deletion of sessions trigger SessionDestroyedEvents.
                * Without the SessionDestroyedEvent resources may not get cleaned up properly. For
                * example, the mapping of the Session to WebSocket connections may not get cleaned
                * up.
                */
               static class EnableRedisKeyspaceNotificationsInitializer implements InitializingBean {
                   private final RedisConnectionFactory connectionFactory;
   
                   private ConfigureRedisAction configure;
   
                   EnableRedisKeyspaceNotificationsInitializer(
                           RedisConnectionFactory connectionFactory,
                           ConfigureRedisAction configure) {
                       this.connectionFactory = connectionFactory;
                       this.configure = configure;
                   }
   
                   public void afterPropertiesSet() throws Exception {
                       RedisConnection connection = this.connectionFactory.getConnection();
                       this.configure.configure(connection);
                   }
               }

2. 配置

           <bean id="redisHttpSessionConfiguration"
               class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
               <property name="maxInactiveIntervalInSeconds" value="${redis.session.time}" />
               <property name="redisNamespace" value="${redis.session.namespace}"/>
               <property name="cookieSerializer" ref="cookieSerializer" />
           </bean>
   
           <bean id="cookieSerializer" class="org.springframework.session.web.http.DefaultCookieSerializer">
               <property name="domainName" value="${cookie.domain}" />
               <property name="cookiePath" value="/" />
               <property name="cookieName" value="${cookie.cookieName}" />
           </bean>