Address feedback for connection pool

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/AbstractRedisConnectionPoolConfiguration.java

@@ -15,6 +15,8 @@
  */
 package io.micronaut.configuration.lettuce;
 
+import io.micronaut.core.annotation.NonNull;
+
 import java.util.Optional;
 
 /**
@@ -34,47 +36,31 @@ public abstract class AbstractRedisConnectionPoolConfiguration {
      * @return The minimum idle connections count.
      * @see io.micronaut.configuration.lettuce.NamedRedisServersConfiguration
      */
-    public Optional<Integer> getMinIdle() {
-        if (minIdle != null) {
-            return Optional.of(minIdle);
-        } else {
-            return Optional.empty();
-        }
+    public @NonNull Optional<Integer> getMinIdle() {
+        return Optional.ofNullable(minIdle);
     }
 
     /**
      * @return The maximum idle connections count.
      * @see io.micronaut.configuration.lettuce.NamedRedisServersConfiguration
      */
-    public Optional<Integer> getMaxIdle() {
-        if (maxIdle != null) {
-            return Optional.of(maxIdle);
-        } else {
-            return Optional.empty();
-        }
+    public @NonNull Optional<Integer> getMaxIdle() {
+        return Optional.ofNullable(maxIdle);
     }
 
     /**
      * @return The maximum total connections count.
      * @see io.micronaut.configuration.lettuce.NamedRedisServersConfiguration
      */
-    public Optional<Integer> getMaxTotal() {
-        if (maxTotal != null) {
-            return Optional.of(maxTotal);
-        } else {
-            return Optional.empty();
-        }
+    public @NonNull Optional<Integer> getMaxTotal() {
+        return Optional.ofNullable(maxTotal);
     }
 
     /**
      * @return The maximum total connections count.
      * @see io.micronaut.configuration.lettuce.NamedRedisServersConfiguration
      */
-    public Optional<Boolean> getEnabled() {
-        if (enabled != null) {
-            return Optional.of(enabled);
-        } else {
-            return Optional.empty();
-        }
+    public @NonNull Optional<Boolean> getEnabled() {
+        return Optional.ofNullable(enabled);
     }
 }

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/DefaultRedisConnectionPoolConfiguration.java

@@ -27,7 +27,7 @@
  * Allows configuration of redis connection pool.
  *
  * @author Graeme Rocher, Illia Kovalov
- * @since 1.3
+ * @since 5.3.0
  */
 @ConfigurationProperties(RedisSetting.REDIS_POOL)
 @Requires(classes = SyncCache.class, property = RedisSetting.REDIS_POOL + ".enabled", defaultValue = StringUtils.FALSE, notEquals = StringUtils.FALSE)

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/RedisConnectionUtil.java

@@ -25,6 +25,7 @@
 import io.micronaut.context.BeanLocator;
 import io.micronaut.context.exceptions.ConfigurationException;
 import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.annotation.NonNull;
 import io.micronaut.inject.qualifiers.Qualifiers;
 
 import java.util.Optional;
@@ -46,7 +47,7 @@ public class RedisConnectionUtil {
      * @return The connection
      * @throws ConfigurationException If the connection cannot be found
      */
-    public static AbstractRedisClient findClient(BeanLocator beanLocator, Optional<String> serverName, String errorMessage) {
+    public static @NonNull AbstractRedisClient findClient(BeanLocator beanLocator, Optional<String> serverName, String errorMessage) {
         Optional<? extends AbstractRedisClient> clusterConn = findRedisClusterClient(beanLocator, serverName);
         if (clusterConn.isPresent()) {
             return clusterConn.get();

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/cache/AbstractRedisCache.java

@@ -39,9 +39,10 @@
 
 /**
  * An abstract class implementing SyncCache for the redis.
- * Author: Graeme Rocher, Kovalov Illia
  *
+ * @author Graeme Rocher, Kovalov Illia
  * @param <C> – The native cache implementation
+ * @since 5.3.0
  */
 public abstract class AbstractRedisCache<C> implements SyncCache<C>, AutoCloseable {
 

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/cache/RedisAsyncConnectionPoolFactory.java

@@ -37,28 +37,21 @@
 
 /**
  * Default redis connection pool factory.
- * Author: Kovalov Illia
+ *
+ * @author Kovalov Illia
+ * @since 5.3.0
  */
 @Factory
 public final class RedisAsyncConnectionPoolFactory {
-    private final BeanLocator beanLocator;
-    private final DefaultRedisCacheConfiguration defaultRedisCacheConfiguration;
-    private final DefaultRedisConnectionPoolConfiguration defaultRedisConnectionPoolConfiguration;
 
-    public RedisAsyncConnectionPoolFactory(
+    @Singleton
+    public AsyncPool<StatefulConnection<byte[], byte[]>> getAsyncPool(
             DefaultRedisCacheConfiguration defaultRedisCacheConfiguration,
             BeanLocator beanLocator,
             DefaultRedisConnectionPoolConfiguration defaultRedisConnectionPoolConfiguration
     ) {
-        this.beanLocator = beanLocator;
-        this.defaultRedisCacheConfiguration = defaultRedisCacheConfiguration;
-        this.defaultRedisConnectionPoolConfiguration = defaultRedisConnectionPoolConfiguration;
-    }
-
-    @Singleton
-    public AsyncPool<StatefulConnection<byte[], byte[]>> getAsyncPool() {
         Optional<String> server = defaultRedisCacheConfiguration.getServer();
-        AbstractRedisClient client = RedisConnectionUtil.findClient(this.beanLocator, server, "No Redis server configured to allow caching");
+        AbstractRedisClient client = RedisConnectionUtil.findClient(beanLocator, server, "No Redis server configured to allow caching");
         BoundedPoolConfig asyncConfig = defaultRedisConnectionPoolConfiguration.getBoundedPoolConfig();
         CompletionStage<BoundedAsyncPool<StatefulConnection<byte[], byte[]>>> stage =  AsyncConnectionPoolSupport.createBoundedObjectPoolAsync(() -> {
                     if (client instanceof RedisClusterClient) {

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/cache/RedisCache.java

@@ -27,6 +27,7 @@
 import io.micronaut.context.BeanLocator;
 import io.micronaut.context.annotation.EachBean;
 import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.convert.ConversionService;
 import io.micronaut.core.type.Argument;
 import io.micronaut.core.util.StringUtils;
@@ -160,6 +161,38 @@ protected <T> void putValue(byte[] serializedKey, T value) {
                 value);
     }
 
+    @Override
+    @NonNull
+    @SuppressWarnings("java:S1185") // This is here for binary compatibility
+    public <T> Optional<T> get(Object key, Argument<T> requiredType) {
+        return super.get(key, requiredType);
+    }
+
+    @Override
+    @SuppressWarnings("java:S1185") // This is here for binary compatibility
+    public void put(Object key, Object value) {
+        super.put(key, value);
+    }
+
+    @Override
+    @NonNull
+    @SuppressWarnings("java:S1185") // This is here for binary compatibility
+    public <T> Optional<T> putIfAbsent(Object key, T value) {
+        return super.putIfAbsent(key, value);
+    }
+
+    @Override
+    @SuppressWarnings("java:S1185") // This is here for binary compatibility
+    protected String getKeysPattern() {
+        return super.getKeysPattern();
+    }
+
+    @Override
+    @SuppressWarnings("java:S1185") // This is here for binary compatibility
+    protected byte[] serializeKey(Object key) {
+        return super.serializeKey(key);
+    }
+
     @PreDestroy
     @Override
     public void close() {

redis-lettuce/src/main/java/io/micronaut/configuration/lettuce/cache/RedisConnectionPoolCache.java

@@ -47,7 +47,7 @@
  * An implementation of {@link SyncCache} for Lettuce / Redis using connection pooling.
  *
  * @author Graeme Rocher, Kovalov Illia
- * @since 1.0
+ * @since 5.3.0
  */
 @EachBean(RedisCacheConfiguration.class)
 @Requires(classes = SyncCache.class, property = RedisSetting.REDIS_POOL + ".enabled", defaultValue = StringUtils.FALSE, notEquals = StringUtils.FALSE)