Refactor Redis properties.

Integrate lettuce properties into RedisProperties. Relocate jedis pool properties from spring.redis.pool to spring.redis.jedis.pool.

Author: mp911de

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/redis/LettuceRedisProperties.java

@@ -29,7 +29,9 @@
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
 import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Cluster;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Lettuce;
 import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Sentinel;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
@@ -40,14 +42,14 @@
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
 import org.springframework.data.redis.connection.jedis.JedisConnection;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
-import org.springframework.data.redis.connection.lettuce.LettuceConnection;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.core.RedisOperations;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
+
 /**
  * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Redis support.
  *
@@ -61,29 +63,24 @@
  * @author Mark Paluch
  */
 @Configuration
-@ConditionalOnClass({ RedisOperations.class,})
+@ConditionalOnClass({ RedisOperations.class })
 @EnableConfigurationProperties(RedisProperties.class)
 public class RedisAutoConfiguration {
 
 	/**
-	 * Redis connection configuration.
+	 * Jedis Redis connection configuration.
 	 */
 	@Configuration
-	@ConditionalOnClass(GenericObjectPool.class)
-	protected static class RedisConnectionConfiguration {
+	@ConditionalOnClass({ GenericObjectPool.class, JedisConnection.class, Jedis.class })
+	protected static class JedisRedisConnectionConfiguration extends RedisBaseConfiguration {
 
 		private final RedisProperties properties;
 
-		private final RedisSentinelConfiguration sentinelConfiguration;
-
-		private final RedisClusterConfiguration clusterConfiguration;
-
-		public RedisConnectionConfiguration(RedisProperties properties,
+		public JedisRedisConnectionConfiguration(RedisProperties properties,
 				ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
 				ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider) {
+			super(properties, sentinelConfigurationProvider, clusterConfigurationProvider);
 			this.properties = properties;
-			this.sentinelConfiguration = sentinelConfigurationProvider.getIfAvailable();
-			this.clusterConfiguration = clusterConfigurationProvider.getIfAvailable();
 		}
 
 		@Bean
@@ -93,68 +90,6 @@ public JedisConnectionFactory redisConnectionFactory()
 			return applyProperties(createJedisConnectionFactory());
 		}
 
-		protected final RedisSentinelConfiguration getSentinelConfig() {
-			if (this.sentinelConfiguration != null) {
-				return this.sentinelConfiguration;
-			}
-			Sentinel sentinelProperties = this.properties.getSentinel();
-			if (sentinelProperties != null) {
-				RedisSentinelConfiguration config = new RedisSentinelConfiguration();
-				config.master(sentinelProperties.getMaster());
-				config.setSentinels(createSentinels(sentinelProperties));
-				return config;
-			}
-			return null;
-		}
-
-		/**
-		 * Create a {@link RedisClusterConfiguration} if necessary.
-		 * @return {@literal null} if no cluster settings are set.
-		 */
-		protected final RedisClusterConfiguration getClusterConfiguration() {
-			if (this.clusterConfiguration != null) {
-				return this.clusterConfiguration;
-			}
-			if (this.properties.getCluster() == null) {
-				return null;
-			}
-			Cluster clusterProperties = this.properties.getCluster();
-			RedisClusterConfiguration config = new RedisClusterConfiguration(
-					clusterProperties.getNodes());
-
-			if (clusterProperties.getMaxRedirects() != null) {
-				config.setMaxRedirects(clusterProperties.getMaxRedirects());
-			}
-			return config;
-		}
-
-		private List<RedisNode> createSentinels(Sentinel sentinel) {
-			List<RedisNode> nodes = new ArrayList<RedisNode>();
-			for (String node : StringUtils
-					.commaDelimitedListToStringArray(sentinel.getNodes())) {
-				try {
-					String[] parts = StringUtils.split(node, ":");
-					Assert.state(parts.length == 2, "Must be defined as 'host:port'");
-					nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
-				}
-				catch (RuntimeException ex) {
-					throw new IllegalStateException(
-							"Invalid redis sentinel " + "property '" + node + "'", ex);
-				}
-			}
-			return nodes;
-		}
-	}
-
-	/**
-	 * Base class for Redis configurations using the Jedis driver.
-	 */
-	protected static abstract class AbstractJedisRedisConfiguration
-			extends AbstractRedisConfiguration {
-
-		@Autowired
-		protected RedisProperties properties;
-
 		protected final JedisConnectionFactory applyProperties(
 				JedisConnectionFactory factory) {
 			factory.setHostName(this.properties.getHost());
@@ -169,52 +104,15 @@ protected final JedisConnectionFactory applyProperties(
 			return factory;
 		}
 
-	}
-
-	/**
-	 * Redis connection configuration.
-	 */
-	@Configuration
-	@ConditionalOnMissingClass("org.apache.commons.pool2.impl.GenericObjectPool")
-	protected static class RedisConnectionConfiguration
-			extends AbstractRedisConfiguration {
-
-		@Bean
-		@ConditionalOnMissingBean(RedisConnectionFactory.class)
-		public JedisConnectionFactory redisConnectionFactory()
-				throws UnknownHostException {
-			return applyProperties(createJedisConnectionFactory());
-		}
-
 		private JedisConnectionFactory createJedisConnectionFactory() {
-			if (getSentinelConfig() != null) {
-				return new JedisConnectionFactory(getSentinelConfig());
+
+			JedisPoolConfig poolConfig;
+			if (this.properties.getJedis() != null && this.properties.getJedis().getPool() != null) {
+				poolConfig = jedisPoolConfig(this.properties.getJedis().getPool());
 			}
-			if (getClusterConfiguration() != null) {
-				return new JedisConnectionFactory(getClusterConfiguration());
+			else {
+				poolConfig = new JedisPoolConfig();
 			}
-			return new JedisConnectionFactory();
-		}
-	}
-
-	/**
-	 * Redis pooled connection configuration.
-	 */
-	@Configuration
-	@ConditionalOnClass(GenericObjectPool.class)
-	protected static class RedisPooledConnectionConfiguration
-			extends AbstractRedisConfiguration {
-
-		@Bean
-		@ConditionalOnMissingBean(RedisConnectionFactory.class)
-		public JedisConnectionFactory redisConnectionFactory()
-				throws UnknownHostException {
-			return applyProperties(createJedisConnectionFactory());
-		}
-
-		private JedisConnectionFactory createJedisConnectionFactory() {
-			JedisPoolConfig poolConfig = this.properties.getPool() != null
-					? jedisPoolConfig() : new JedisPoolConfig();
 
 			if (getSentinelConfig() != null) {
 				return new JedisConnectionFactory(getSentinelConfig(), poolConfig);
@@ -225,9 +123,8 @@ private JedisConnectionFactory createJedisConnectionFactory() {
 			return new JedisConnectionFactory(poolConfig);
 		}
 
-		private JedisPoolConfig jedisPoolConfig() {
+		private JedisPoolConfig jedisPoolConfig(RedisProperties.Pool props) {
 			JedisPoolConfig config = new JedisPoolConfig();
-			RedisProperties.Pool props = this.properties.getPool();
 			config.setMaxTotal(props.getMaxActive());
 			config.setMaxIdle(props.getMaxIdle());
 			config.setMinIdle(props.getMinIdle());
@@ -238,13 +135,28 @@ private JedisPoolConfig jedisPoolConfig() {
 	}
 
 	/**
-	 * Base class for Redis configurations using the Jedis driver.
+	 * Lettuce Redis connection configuration.
 	 */
-	protected static abstract class AbstractLettuceRedisConfiguration
-			extends AbstractRedisConfiguration {
+	@Configuration
+	@ConditionalOnClass(RedisClient.class)
+	@ConditionalOnMissingClass("redis.clients.jedis.Jedis")
+	protected static class LettuceRedisConnectionConfiguration extends RedisBaseConfiguration {
 
-		@Autowired
-		protected LettuceRedisProperties lettuceRedisProperties;
+		protected final RedisProperties properties;
+
+		public LettuceRedisConnectionConfiguration(RedisProperties properties,
+				ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
+				ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider) {
+			super(properties, sentinelConfigurationProvider, clusterConfigurationProvider);
+			this.properties = properties;
+		}
+
+		@Bean
+		@ConditionalOnMissingBean(RedisConnectionFactory.class)
+		public LettuceConnectionFactory redisConnectionFactory()
+				throws UnknownHostException {
+			return applyProperties(createLettuceConnectionFactory());
+		}
 
 		protected final LettuceConnectionFactory applyProperties(
 				LettuceConnectionFactory factory) {
@@ -257,27 +169,16 @@ protected final LettuceConnectionFactory applyProperties(
 			if (this.properties.getTimeout() > 0) {
 				factory.setTimeout(this.properties.getTimeout());
 			}
-			if (this.lettuceRedisProperties.getShutdownTimeout() > 0) {
-				factory.setShutdownTimeout(this.lettuceRedisProperties.getShutdownTimeout());
-			}
-			return factory;
-		}
-	}
 
-	/**
-	 * Redis connection configuration using the Lettuce driver.
-	 */
-	@Configuration
-	@ConditionalOnClass({ LettuceConnection.class, RedisClient.class })
-	@ConditionalOnMissingClass("redis.clients.jedis.Jedis")
-	protected static class LettuceRedisConnectionConfiguration
-			extends AbstractLettuceRedisConfiguration {
+			if (this.properties.getLettuce() != null) {
 
-		@Bean
-		@ConditionalOnMissingBean(RedisConnectionFactory.class)
-		public LettuceConnectionFactory redisConnectionFactory()
-				throws UnknownHostException {
-			return applyProperties(createLettuceConnectionFactory());
+				Lettuce lettuce = this.properties.getLettuce();
+				if (lettuce.getShutdownTimeout() >= 0) {
+					factory.setShutdownTimeout(this.properties.getLettuce().getShutdownTimeout());
+				}
+			}
+
+			return factory;
 		}
 
 		private LettuceConnectionFactory createLettuceConnectionFactory() {
@@ -289,6 +190,80 @@ private LettuceConnectionFactory createLettuceConnectionFactory() {
 			}
 			return new LettuceConnectionFactory();
 		}
+
+	}
+
+	protected abstract static class RedisBaseConfiguration {
+
+		protected final RedisProperties properties;
+
+		protected final RedisSentinelConfiguration sentinelConfiguration;
+
+		protected final RedisClusterConfiguration clusterConfiguration;
+
+		public RedisBaseConfiguration(RedisProperties properties,
+				ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
+				ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider) {
+			this.properties = properties;
+			this.sentinelConfiguration = sentinelConfigurationProvider.getIfAvailable();
+			this.clusterConfiguration = clusterConfigurationProvider.getIfAvailable();
+		}
+
+		protected final RedisSentinelConfiguration getSentinelConfig() {
+			if (this.sentinelConfiguration != null) {
+				return this.sentinelConfiguration;
+			}
+
+			Sentinel sentinelProperties = this.properties.getSentinel();
+			if (sentinelProperties != null) {
+				RedisSentinelConfiguration config = new RedisSentinelConfiguration();
+				config.master(sentinelProperties.getMaster());
+				config.setSentinels(createSentinels(sentinelProperties));
+				return config;
+			}
+			return null;
+		}
+
+		/**
+		 * Create a {@link RedisClusterConfiguration} if necessary.
+		 * @return {@literal null} if no cluster settings are set.
+		 */
+		protected final RedisClusterConfiguration getClusterConfiguration() {
+			if (this.clusterConfiguration != null) {
+				return this.clusterConfiguration;
+			}
+
+			if (this.properties.getCluster() == null) {
+				return null;
+			}
+
+			Cluster clusterProperties = this.properties.getCluster();
+			RedisClusterConfiguration config = new RedisClusterConfiguration(
+					clusterProperties.getNodes());
+
+			if (clusterProperties.getMaxRedirects() != null) {
+				config.setMaxRedirects(clusterProperties.getMaxRedirects());
+			}
+			return config;
+		}
+
+		private List<RedisNode> createSentinels(Sentinel sentinel) {
+			List<RedisNode> nodes = new ArrayList<RedisNode>();
+			for (String node : StringUtils
+					.commaDelimitedListToStringArray(sentinel.getNodes())) {
+				try {
+					String[] parts = StringUtils.split(node, ":");
+					Assert.state(parts.length == 2, "Must be defined as 'host:port'");
+					nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
+				}
+				catch (RuntimeException ex) {
+					throw new IllegalStateException(
+							"Invalid redis sentinel " + "property '" + node + "'", ex);
+				}
+			}
+			return nodes;
+		}
+
 	}
 
 	/**