Add support for configuring Redis session cleanup cron

Author: vpavic

samples/boot/findbyusername/spring-session-sample-boot-findbyusername.gradle

@@ -20,9 +20,3 @@ dependencies {
 	integrationTestCompile seleniumDependencies
 	integrationTestCompile "org.testcontainers:testcontainers"
 }
-
-integrationTest {
-	doFirst {
-		systemProperties['spring.session.redis.namespace'] = project.name
-	}
-}

spring-session-data-redis/src/main/java/org/springframework/session/data/redis/RedisOperationsSessionRepository.java

@@ -39,7 +39,6 @@
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.expression.Expression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.session.FindByIndexNameSessionRepository;
 import org.springframework.session.MapSession;
 import org.springframework.session.Session;
@@ -401,7 +400,6 @@ public void save(RedisSession session) {
 		}
 	}
 
-	@Scheduled(cron = "${spring.session.cleanup.cron.expression:0 * * * * *}")
 	public void cleanupExpiredSessions() {
 		this.expirationPolicy.cleanExpiredSessions();
 	}

spring-session-data-redis/src/main/java/org/springframework/session/data/redis/config/annotation/web/http/EnableRedisHttpSession.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2016 the original author or authors.
+ * Copyright 2014-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,9 @@
 package org.springframework.session.data.redis.config.annotation.web.http;
 
 import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 import org.springframework.context.annotation.Configuration;
@@ -31,32 +33,40 @@
  * Add this annotation to an {@code @Configuration} class to expose the
  * SessionRepositoryFilter as a bean named "springSessionRepositoryFilter" and backed by
  * Redis. In order to leverage the annotation, a single {@link RedisConnectionFactory}
- * must be provided. For example: <pre>
- * <code>
- * {@literal @Configuration}
- * {@literal @EnableRedisHttpSession}
+ * must be provided. For example:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableRedisHttpSession
  * public class RedisHttpSessionConfig {
  *
- *     {@literal @Bean}
+ *     &#064;Bean
  *     public LettuceConnectionFactory connectionFactory() {
  *         return new LettuceConnectionFactory();
  *     }
  *
  * }
- * </code> </pre>
+ * </pre>
  *
  * More advanced configurations can extend {@link RedisHttpSessionConfiguration} instead.
  *
  * @author Rob Winch
+ * @author Vedran Pavic
  * @since 1.0
  * @see EnableSpringHttpSession
  */
-@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
-@Target({ java.lang.annotation.ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
 @Documented
 @Import(RedisHttpSessionConfiguration.class)
 @Configuration
 public @interface EnableRedisHttpSession {
+
+	/**
+	 * The session timeout in seconds. By default, it is set to 1800 seconds (30 minutes).
+	 * This should be a non-negative integer.
+	 * @return the seconds a session can be inactive before expiring
+	 */
 	int maxInactiveIntervalInSeconds() default 1800;
 
 	/**
@@ -93,4 +103,11 @@
 	 * @since 1.1
 	 */
 	RedisFlushMode redisFlushMode() default RedisFlushMode.ON_SAVE;
+
+	/**
+	 * The cron expression for expired session cleanup job. By default runs every minute.
+	 * @return the session cleanup cron expression
+	 */
+	String cleanupCron() default RedisHttpSessionConfiguration.DEFAULT_CLEANUP_CRON;
+
 }

spring-session-data-redis/src/main/java/org/springframework/session/data/redis/config/annotation/web/http/RedisHttpSessionConfiguration.java

@@ -32,7 +32,6 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.ImportAware;
-import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.redis.connection.RedisConnection;
@@ -43,6 +42,8 @@
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.SchedulingConfigurer;
+import org.springframework.scheduling.config.ScheduledTaskRegistrar;
 import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;
 import org.springframework.session.data.redis.RedisFlushMode;
 import org.springframework.session.data.redis.RedisOperationsSessionRepository;
@@ -68,42 +69,46 @@
 @Configuration
 @EnableScheduling
 public class RedisHttpSessionConfiguration extends SpringHttpSessionConfiguration
-		implements EmbeddedValueResolverAware, ImportAware {
+		implements EmbeddedValueResolverAware, ImportAware, SchedulingConfigurer {
+
+	static final String DEFAULT_CLEANUP_CRON = "0 * * * * *";
 
 	private Integer maxInactiveIntervalInSeconds = 1800;
 
 	private String redisNamespace = "";
 
 	private RedisFlushMode redisFlushMode = RedisFlushMode.ON_SAVE;
 
+	private String cleanupCron = DEFAULT_CLEANUP_CRON;
+
 	private ConfigureRedisAction configureRedisAction = new ConfigureNotifyKeyspaceEventsAction();
 
 	private RedisConnectionFactory redisConnectionFactory;
 
 	private RedisSerializer<Object> defaultRedisSerializer;
 
+	private ApplicationEventPublisher applicationEventPublisher;
+
 	private Executor redisTaskExecutor;
 
 	private Executor redisSubscriptionExecutor;
 
 	private StringValueResolver embeddedValueResolver;
 
 	@Bean
-	public RedisOperationsSessionRepository sessionRepository(
-			ApplicationEventPublisher applicationEventPublisher) {
+	public RedisOperationsSessionRepository sessionRepository() {
 		RedisTemplate<Object, Object> redisTemplate = createRedisTemplate(
 				this.redisConnectionFactory, this.defaultRedisSerializer);
 		RedisOperationsSessionRepository sessionRepository = new RedisOperationsSessionRepository(
 				redisTemplate);
-		sessionRepository.setApplicationEventPublisher(applicationEventPublisher);
+		sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
 		if (this.defaultRedisSerializer != null) {
 			sessionRepository.setDefaultSerializer(this.defaultRedisSerializer);
 		}
 		sessionRepository
 				.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
-		String redisNamespace = getRedisNamespace();
-		if (StringUtils.hasText(redisNamespace)) {
-			sessionRepository.setRedisKeyNamespace(redisNamespace);
+		if (StringUtils.hasText(this.redisNamespace)) {
+			sessionRepository.setRedisKeyNamespace(this.redisNamespace);
 		}
 		sessionRepository.setRedisFlushMode(this.redisFlushMode);
 		return sessionRepository;
@@ -135,15 +140,6 @@ public InitializingBean enableRedisKeyspaceNotificationsInitializer() {
 				this.redisConnectionFactory, this.configureRedisAction);
 	}
 
-	/**
-	 * Property placeholder to process the @Scheduled annotation.
-	 * @return the {@link PropertySourcesPlaceholderConfigurer} to use
-	 */
-	@Bean
-	public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
-		return new PropertySourcesPlaceholderConfigurer();
-	}
-
 	public void setMaxInactiveIntervalInSeconds(int maxInactiveIntervalInSeconds) {
 		this.maxInactiveIntervalInSeconds = maxInactiveIntervalInSeconds;
 	}
@@ -157,6 +153,10 @@ public void setRedisFlushMode(RedisFlushMode redisFlushMode) {
 		this.redisFlushMode = redisFlushMode;
 	}
 
+	public void setCleanupCron(String cleanupCron) {
+		this.cleanupCron = cleanupCron;
+	}
+
 	/**
 	 * Sets the action to perform for configuring Redis.
 	 *
@@ -187,6 +187,12 @@ public void setDefaultRedisSerializer(
 		this.defaultRedisSerializer = defaultRedisSerializer;
 	}
 
+	@Autowired
+	public void setApplicationEventPublisher(
+			ApplicationEventPublisher applicationEventPublisher) {
+		this.applicationEventPublisher = applicationEventPublisher;
+	}
+
 	@Autowired(required = false)
 	@Qualifier("springSessionRedisTaskExecutor")
 	public void setRedisTaskExecutor(Executor redisTaskExecutor) {
@@ -206,17 +212,27 @@ public void setEmbeddedValueResolver(StringValueResolver resolver) {
 
 	@Override
 	public void setImportMetadata(AnnotationMetadata importMetadata) {
-		Map<String, Object> enableAttrMap = importMetadata
+		Map<String, Object> attributeMap = importMetadata
 				.getAnnotationAttributes(EnableRedisHttpSession.class.getName());
-		AnnotationAttributes enableAttrs = AnnotationAttributes.fromMap(enableAttrMap);
-		this.maxInactiveIntervalInSeconds = enableAttrs
+		AnnotationAttributes attributes = AnnotationAttributes.fromMap(attributeMap);
+		this.maxInactiveIntervalInSeconds = attributes
 				.getNumber("maxInactiveIntervalInSeconds");
-		String redisNamespaceValue = enableAttrs.getString("redisNamespace");
+		String redisNamespaceValue = attributes.getString("redisNamespace");
 		if (StringUtils.hasText(redisNamespaceValue)) {
 			this.redisNamespace = this.embeddedValueResolver
 					.resolveStringValue(redisNamespaceValue);
 		}
-		this.redisFlushMode = enableAttrs.getEnum("redisFlushMode");
+		this.redisFlushMode = attributes.getEnum("redisFlushMode");
+		String cleanupCron = attributes.getString("cleanupCron");
+		if (StringUtils.hasText(cleanupCron)) {
+			this.cleanupCron = cleanupCron;
+		}
+	}
+
+	@Override
+	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
+		taskRegistrar.addCronTask(() -> sessionRepository().cleanupExpiredSessions(),
+				this.cleanupCron);
 	}
 
 	private static RedisTemplate<Object, Object> createRedisTemplate(
@@ -233,13 +249,6 @@ private static RedisTemplate<Object, Object> createRedisTemplate(
 		return redisTemplate;
 	}
 
-	private String getRedisNamespace() {
-		if (StringUtils.hasText(this.redisNamespace)) {
-			return this.redisNamespace;
-		}
-		return System.getProperty("spring.session.redis.namespace", "");
-	}
-
 	/**
 	 * Ensures that Redis is configured to send keyspace notifications. This is important
 	 * to ensure that expiration and deletion of sessions trigger SessionDestroyedEvents.