Adapter Spring Boot 2.x

Author: ChildrenGreens

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.childrengreens</groupId>
     <artifactId>multi-source-spring-boot-starter</artifactId>
-    <version>2.0</version>
+    <version>1.0-SNAPSHOT</version>
     <packaging>pom</packaging>
 
     <name>Spring Boot Starter for Multi Source</name>
@@ -30,7 +30,7 @@
         <url>https://github.com/ChildrenGreens/multi-source-spring-boot-starter</url>
         <connection>scm:git:[email protected]:ChildrenGreens/multi-source-spring-boot-starter.git</connection>
         <developerConnection>scm:git:[email protected]:ChildrenGreens/multi-source-spring-boot-starter.git</developerConnection>
-        <tag>HEAD</tag>
+        <tag>1.0</tag>
     </scm>
 
     <licenses>
@@ -58,13 +58,13 @@
 
 
     <properties>
-        <java.version>17</java.version>
-        <maven.compiler.source>17</maven.compiler.source>
-        <maven.compiler.target>17</maven.compiler.target>
+        <java.version>1.8</java.version>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
-        <spring-boot-dependencies.version>3.4.0</spring-boot-dependencies.version>
+        <spring-boot-dependencies.version>2.7.18</spring-boot-dependencies.version>
     </properties>
 
     <dependencyManagement>
@@ -93,7 +93,7 @@
             <plugin>
                 <groupId>com.mycila</groupId>
                 <artifactId>license-maven-plugin</artifactId>
-                <version>4.6</version>
+                <version>4.1</version>
                 <configuration>
                     <!-- Template location -->
                     <header>licence-header.template</header>
@@ -127,15 +127,17 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
-                    <version>3.13.0</version>
+                    <version>3.10.1</version>
                     <configuration>
-                        <release>${java.version}</release>
+                        <source>1.8</source>
+                        <target>1.8</target>
+                        <compilerArgs>-parameters</compilerArgs>
                     </configuration>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-release-plugin</artifactId>
-                    <version>3.1.1</version>
+                    <version>2.5.3</version>
                     <configuration>
                         <autoVersionSubmodules>true</autoVersionSubmodules>
                         <useReleaseProfile>false</useReleaseProfile>
@@ -156,7 +158,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-gpg-plugin</artifactId>
-                        <version>3.2.7</version>
+                        <version>3.0.1</version>
                         <executions>
                             <execution>
                                 <id>sign-artifacts</id>
@@ -170,7 +172,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-source-plugin</artifactId>
-                        <version>3.3.1</version>
+                        <version>3.2.1</version>
                         <executions>
                             <execution>
                                 <id>attach-sources</id>
@@ -183,7 +185,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-javadoc-plugin</artifactId>
-                        <version>3.11.1</version>
+                        <version>3.4.1</version>
                         <configuration>
                             <doclint>none</doclint>
                         </configuration>

redis-multi-source-spring-boot-starter/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>com.childrengreens</groupId>
         <artifactId>multi-source-spring-boot-starter</artifactId>
-        <version>2.0</version>
+        <version>1.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>redis-multi-source-spring-boot-starter</artifactId>

redis-multi-source-spring-boot-starter/src/main/java/com/childrengreens/multi/source/LettuceConnectionMultiSourcesRegistrar.java

@@ -22,28 +22,24 @@
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
-import org.springframework.boot.autoconfigure.data.redis.LettuceClientOptionsBuilderCustomizer;
-import org.springframework.boot.autoconfigure.data.redis.RedisConnectionDetails;
-import org.springframework.boot.autoconfigure.thread.Threading;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.context.properties.bind.BindResult;
 import org.springframework.boot.context.properties.bind.Binder;
-import org.springframework.boot.ssl.SslBundles;
 import org.springframework.context.EnvironmentAware;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
 import org.springframework.core.env.Environment;
-import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
 import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.util.CollectionUtils;
 
 import java.util.Objects;
 
 /**
- * Dynamically create multiple {@link RedisConnectionDetails} and {@link LettuceConnectionFactory} based on Environment.
+ * Dynamically create multiple {@link LettuceConnectionFactory} based on Environment.
  *
  * @author ChildrenGreens
  */
@@ -62,54 +58,37 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
             return;
         }
 
-        if (registry instanceof ConfigurableListableBeanFactory beanFactory) {
+        if (registry instanceof ConfigurableListableBeanFactory) {
 
-            // Whether it is virtual threads.
-            boolean active = Threading.VIRTUAL.isActive(environment);
+            ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory) registry;
 
             redisMultiSourcesProperties.getSources().forEach((name, source) -> {
 
                 // Whether it is Primary
                 boolean isPrimary = name.equals(redisMultiSourcesProperties.getPrimaryKey());
 
-                // PropertiesRedisMultiSourcesConnectionDetails registration
-                BeanDefinition connectionDetailsBD = BeanDefinitionBuilder.genericBeanDefinition(PropertiesRedisMultiSourcesConnectionDetails.class,
-                        () -> new PropertiesRedisMultiSourcesConnectionDetails(source)).getBeanDefinition();
-                connectionDetailsBD.setPrimary(isPrimary);
-                String connectionDetailsBDN = name + PropertiesRedisMultiSourcesConnectionDetails.class.getSimpleName();
-                registry.registerBeanDefinition(connectionDetailsBDN, connectionDetailsBD);
-
-
                 // LettuceConnectionFactory registration
                 BeanDefinition connectionFactoryBD = BeanDefinitionBuilder.genericBeanDefinition(LettuceConnectionFactory.class, () -> {
 
                     // new LettuceMultiSourcesConnectionConfiguration
-                    PropertiesRedisMultiSourcesConnectionDetails connectionDetails = beanFactory.getBean(connectionDetailsBDN, PropertiesRedisMultiSourcesConnectionDetails.class);
                     ObjectProvider<RedisStandaloneConfiguration> standaloneProvider = beanFactory.getBeanProvider(RedisStandaloneConfiguration.class);
                     ObjectProvider<RedisSentinelConfiguration> sentinelProvider = beanFactory.getBeanProvider(RedisSentinelConfiguration.class);
                     ObjectProvider<RedisClusterConfiguration> clusterProvider = beanFactory.getBeanProvider(RedisClusterConfiguration.class);
-                    ObjectProvider<SslBundles> sslBundlesProvider = beanFactory.getBeanProvider(SslBundles.class);
 
                     LettuceMultiSourcesConnectionConfiguration lettuceMultiSourcesConnectionConfiguration = new LettuceMultiSourcesConnectionConfiguration(source,
                             standaloneProvider,
                             sentinelProvider,
-                            clusterProvider,
-                            connectionDetails,
-                            sslBundlesProvider);
+                            clusterProvider);
 
                     ObjectProvider<LettuceClientConfigurationBuilderCustomizer> configurationBuilderCustomizerProvider = beanFactory.getBeanProvider(LettuceClientConfigurationBuilderCustomizer.class);
-                    ObjectProvider<LettuceClientOptionsBuilderCustomizer> optionsBuilderCustomizerProvider = beanFactory.getBeanProvider(LettuceClientOptionsBuilderCustomizer.class);
                     ClientResources clientResources = beanFactory.getBean(ClientResources.class);
 
-                    LettuceConnectionFactory factory = lettuceMultiSourcesConnectionConfiguration.createConnectionFactory(configurationBuilderCustomizerProvider, optionsBuilderCustomizerProvider, clientResources);
+                    LettuceClientConfiguration clientConfig = lettuceMultiSourcesConnectionConfiguration.getLettuceClientConfiguration(configurationBuilderCustomizerProvider,
+                            clientResources,
+                            source.getLettuce().getPool());
 
+                    return lettuceMultiSourcesConnectionConfiguration.createLettuceConnectionFactory(clientConfig);
 
-                    if (active) {
-                        SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("redis-");
-                        executor.setVirtualThreads(true);
-                        factory.setExecutor(executor);
-                    }
-                    return factory;
                 }).getBeanDefinition();
 
                 connectionFactoryBD.setPrimary(isPrimary);

redis-multi-source-spring-boot-starter/src/main/java/com/childrengreens/multi/source/LettuceMultiSourcesConnectionConfiguration.java

@@ -24,9 +24,6 @@
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.data.redis.*;
-import org.springframework.boot.ssl.SslBundle;
-import org.springframework.boot.ssl.SslBundles;
-import org.springframework.boot.ssl.SslOptions;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
 import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
@@ -47,26 +44,15 @@ class LettuceMultiSourcesConnectionConfiguration extends RedisMultiSourcesConnec
 
 
     LettuceMultiSourcesConnectionConfiguration(RedisProperties properties,
-                                   ObjectProvider<RedisStandaloneConfiguration> standaloneConfigurationProvider,
-                                   ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
-                                   ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider,
-                                   RedisConnectionDetails connectionDetails, ObjectProvider<SslBundles> sslBundles) {
-        super(properties, connectionDetails, standaloneConfigurationProvider, sentinelConfigurationProvider,
-                clusterConfigurationProvider, sslBundles);
+                                               ObjectProvider<RedisStandaloneConfiguration> standaloneConfigurationProvider,
+                                               ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
+                                               ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider) {
+        super(properties, standaloneConfigurationProvider, sentinelConfigurationProvider, clusterConfigurationProvider);
     }
 
 
 
-    LettuceConnectionFactory createConnectionFactory(
-            ObjectProvider<LettuceClientConfigurationBuilderCustomizer> clientConfigurationBuilderCustomizers,
-            ObjectProvider<LettuceClientOptionsBuilderCustomizer> clientOptionsBuilderCustomizers,
-            ClientResources clientResources) {
-        LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientConfigurationBuilderCustomizers,
-                clientOptionsBuilderCustomizers, clientResources, getProperties().getLettuce().getPool());
-        return createLettuceConnectionFactory(clientConfig);
-    }
-
-    private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration) {
+    LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration) {
         if (getSentinelConfig() != null) {
             return new LettuceConnectionFactory(getSentinelConfig(), clientConfiguration);
         }
@@ -76,18 +62,17 @@ private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientCon
         return new LettuceConnectionFactory(getStandaloneConfig(), clientConfiguration);
     }
 
-    private LettuceClientConfiguration getLettuceClientConfiguration(
-            ObjectProvider<LettuceClientConfigurationBuilderCustomizer> clientConfigurationBuilderCustomizers,
-            ObjectProvider<LettuceClientOptionsBuilderCustomizer> clientOptionsBuilderCustomizers,
+    LettuceClientConfiguration getLettuceClientConfiguration(
+            ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
             ClientResources clientResources, RedisProperties.Pool pool) {
         LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = createBuilder(pool);
         applyProperties(builder);
         if (StringUtils.hasText(getProperties().getUrl())) {
             customizeConfigurationFromUrl(builder);
         }
-        builder.clientOptions(createClientOptions(clientOptionsBuilderCustomizers));
+        builder.clientOptions(createClientOptions());
         builder.clientResources(clientResources);
-        clientConfigurationBuilderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
+        builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
         return builder.build();
     }
 
@@ -98,8 +83,9 @@ private LettuceClientConfiguration.LettuceClientConfigurationBuilder createBuild
         return LettuceClientConfiguration.builder();
     }
 
-    private void applyProperties(LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) {
-        if (isSslEnabled()) {
+    private LettuceClientConfiguration.LettuceClientConfigurationBuilder applyProperties(
+            LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) {
+        if (getProperties().isSsl()) {
             builder.useSsl();
         }
         if (getProperties().getTimeout() != null) {
@@ -114,32 +100,16 @@ private void applyProperties(LettuceClientConfiguration.LettuceClientConfigurati
         if (StringUtils.hasText(getProperties().getClientName())) {
             builder.clientName(getProperties().getClientName());
         }
+        return builder;
     }
 
-    private ClientOptions createClientOptions(
-            ObjectProvider<LettuceClientOptionsBuilderCustomizer> clientConfigurationBuilderCustomizers) {
+    private ClientOptions createClientOptions() {
         ClientOptions.Builder builder = initializeClientOptionsBuilder();
         Duration connectTimeout = getProperties().getConnectTimeout();
         if (connectTimeout != null) {
             builder.socketOptions(SocketOptions.builder().connectTimeout(connectTimeout).build());
         }
-        if (isSslEnabled() && getProperties().getSsl().getBundle() != null) {
-            SslBundle sslBundle = getSslBundles().getBundle(getProperties().getSsl().getBundle());
-            io.lettuce.core.SslOptions.Builder sslOptionsBuilder = io.lettuce.core.SslOptions.builder();
-            sslOptionsBuilder.keyManager(sslBundle.getManagers().getKeyManagerFactory());
-            sslOptionsBuilder.trustManager(sslBundle.getManagers().getTrustManagerFactory());
-            SslOptions sslOptions = sslBundle.getOptions();
-            if (sslOptions.getCiphers() != null) {
-                sslOptionsBuilder.cipherSuites(sslOptions.getCiphers());
-            }
-            if (sslOptions.getEnabledProtocols() != null) {
-                sslOptionsBuilder.protocols(sslOptions.getEnabledProtocols());
-            }
-            builder.sslOptions(sslOptionsBuilder.build());
-        }
-        builder.timeoutOptions(TimeoutOptions.enabled());
-        clientConfigurationBuilderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
-        return builder.build();
+        return builder.timeoutOptions(TimeoutOptions.enabled()).build();
     }
 
     private ClientOptions.Builder initializeClientOptionsBuilder() {
@@ -160,15 +130,16 @@ private ClientOptions.Builder initializeClientOptionsBuilder() {
     }
 
     private void customizeConfigurationFromUrl(LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) {
-        if (urlUsesSsl()) {
+        RedisMultiSourcesConnectionConfiguration.ConnectionInfo connectionInfo = parseUrl(getProperties().getUrl());
+        if (connectionInfo.isUseSsl()) {
             builder.useSsl();
         }
     }
 
     /**
      * Inner class to allow optional commons-pool2 dependency.
      */
-    private static final class PoolBuilderFactory {
+    private static class PoolBuilderFactory {
 
         LettuceClientConfiguration.LettuceClientConfigurationBuilder createBuilder(RedisProperties.Pool properties) {
             return LettucePoolingClientConfiguration.builder().poolConfig(getPoolConfig(properties));