Rework Lettuce configuration to use new client pooling config API

Closes gh-9538

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

@@ -31,21 +31,23 @@ import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Pool;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
-import org.springframework.data.redis.connection.lettuce.DefaultLettucePool;
 import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
 import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration.LettuceClientConfigurationBuilder;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
 import org.springframework.util.StringUtils;
 
 /**
  * Redis connection configuration using Lettuce.
  *
  * @author Mark Paluch
+ * @author Andy Wilkinson
  */
 @Configuration
 @ConditionalOnClass({ GenericObjectPool.class, RedisClient.class,
@@ -76,62 +78,10 @@ class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
 	@ConditionalOnMissingBean(RedisConnectionFactory.class)
 	public LettuceConnectionFactory redisConnectionFactory(
 			ClientResources clientResources) throws UnknownHostException {
-		if (this.properties.getLettuce().getPool() != null) {
-			return createLettuceConnectionFactory(clientResources);
-		}
-		return createLettuceConnectionFactory(
-				getLettuceClientConfiguration(clientResources));
-	}
-
-	private LettuceConnectionFactory createLettuceConnectionFactory(
-			ClientResources clientResources) {
-		return applyProperties(
-				new LettuceConnectionFactory(applyProperties(createLettucePool(),
-						this.properties.getLettuce().getPool(), clientResources)));
-	}
-
-	@SuppressWarnings("deprecation")
-	private LettuceConnectionFactory applyProperties(
-			LettuceConnectionFactory connectionFactory) {
-		connectionFactory
-				.setShutdownTimeout(this.properties.getLettuce().getShutdownTimeout());
-		return connectionFactory;
-	}
-
-	private DefaultLettucePool createLettucePool() {
-		return getSentinelConfig() != null ? new DefaultLettucePool(getSentinelConfig())
-				: new DefaultLettucePool();
-	}
-
-	private DefaultLettucePool applyProperties(DefaultLettucePool pool,
-			RedisProperties.Pool properties, ClientResources clientResources) {
-		if (StringUtils.hasText(this.properties.getUrl())) {
-			configureConnectionFromUrl(pool);
-		}
-		else {
-			pool.setHostName(this.properties.getHost());
-			pool.setPort(this.properties.getPort());
-			if (this.properties.getPassword() != null) {
-				pool.setPassword(this.properties.getPassword());
-			}
-			pool.setDatabase(this.properties.getDatabase());
-		}
-		if (this.properties.getTimeout() > 0) {
-			pool.setTimeout(this.properties.getTimeout());
-		}
-		pool.setPoolConfig(lettucePoolConfig(properties));
-		pool.setClientResources(clientResources);
-		pool.afterPropertiesSet();
-		return pool;
-	}
-
-	private void configureConnectionFromUrl(DefaultLettucePool lettucePool) {
-		ConnectionInfo connectionInfo = parseUrl(this.properties.getUrl());
-		lettucePool.setHostName(connectionInfo.getHostName());
-		lettucePool.setPort(connectionInfo.getPort());
-		if (connectionInfo.getPassword() != null) {
-			lettucePool.setPassword(connectionInfo.getPassword());
-		}
+		LettuceClientConfiguration clientConfig;
+		clientConfig = getLettuceClientConfiguration(clientResources,
+				this.properties.getLettuce().getPool());
+		return createLettuceConnectionFactory(clientConfig);
 	}
 
 	private static GenericObjectPoolConfig lettucePoolConfig(RedisProperties.Pool props) {
@@ -156,9 +106,16 @@ class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
 	}
 
 	private LettuceClientConfiguration getLettuceClientConfiguration(
-			ClientResources clientResources) {
-		LettuceClientConfigurationBuilder builder = applyProperties(
-				LettuceClientConfiguration.builder());
+			ClientResources clientResources, Pool pool) {
+		LettuceClientConfigurationBuilder builder;
+		if (pool != null) {
+			builder = LettucePoolingClientConfiguration.builder()
+					.poolConfig(lettucePoolConfig(pool));
+		}
+		else {
+			builder = LettuceClientConfiguration.builder();
+		}
+		applyProperties(builder);
 		if (StringUtils.hasText(this.properties.getUrl())) {
 			customizeConfigurationFromUrl(builder);
 		}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/redis/RedisAutoConfigurationTests.java

@@ -26,9 +26,9 @@ import org.springframework.boot.test.util.TestPropertyValues;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.data.redis.connection.lettuce.DefaultLettucePool;
 import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration.LettuceClientConfigurationBuilder;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
 import org.springframework.data.redis.core.RedisOperations;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.test.util.ReflectionTestUtils;
@@ -121,11 +121,14 @@ public class RedisAutoConfigurationTests {
 				"spring.redis.lettuce.shutdown-timeout:1000");
 		LettuceConnectionFactory cf = this.context
 				.getBean(LettuceConnectionFactory.class);
-		assertThat(getDefaultLettucePool(cf).getHostName()).isEqualTo("foo");
-		assertThat(getDefaultLettucePool(cf).getPoolConfig().getMinIdle()).isEqualTo(1);
-		assertThat(getDefaultLettucePool(cf).getPoolConfig().getMaxIdle()).isEqualTo(4);
-		assertThat(getDefaultLettucePool(cf).getPoolConfig().getMaxTotal()).isEqualTo(16);
-		assertThat(getDefaultLettucePool(cf).getPoolConfig().getMaxWaitMillis())
+		assertThat(cf.getHostName()).isEqualTo("foo");
+		assertThat(getPoolingClientConfiguration(cf).getPoolConfig().getMinIdle())
+				.isEqualTo(1);
+		assertThat(getPoolingClientConfiguration(cf).getPoolConfig().getMaxIdle())
+				.isEqualTo(4);
+		assertThat(getPoolingClientConfiguration(cf).getPoolConfig().getMaxTotal())
+				.isEqualTo(16);
+		assertThat(getPoolingClientConfiguration(cf).getPoolConfig().getMaxWaitMillis())
 				.isEqualTo(2000);
 		assertThat(cf.getShutdownTimeout()).isEqualTo(1000);
 	}
@@ -177,8 +180,10 @@ public class RedisAutoConfigurationTests {
 				.isEqualTo("password");
 	}
 
-	private DefaultLettucePool getDefaultLettucePool(LettuceConnectionFactory factory) {
-		return (DefaultLettucePool) ReflectionTestUtils.getField(factory, "pool");
+	private LettucePoolingClientConfiguration getPoolingClientConfiguration(
+			LettuceConnectionFactory factory) {
+		return (LettucePoolingClientConfiguration) ReflectionTestUtils.getField(factory,
+				"clientConfiguration");
 	}
 
 	private void load(String... environment) {