Fix formatting and imports

Author: uglide

src/main/java/redis/clients/jedis/RedisClient.java

@@ -10,19 +10,44 @@
 import redis.clients.jedis.util.JedisURIHelper;
 import redis.clients.jedis.util.Pool;
 
+/**
+ * {@code RedisClient} is the recommended client for connecting to standalone Redis deployments.
+ * <p>
+ * This class provides a modern, unified interface for interacting with Redis, supporting connection
+ * pooling, authentication, and configuration via a fluent builder API.
+ * </p>
+ * <p>
+ * {@code RedisClient} supersedes the deprecated {@link JedisPooled} and {@link UnifiedJedis}
+ * classes, offering improved usability and extensibility. For new applications, use
+ * {@code RedisClient} instead of the older classes.
+ * </p>
+ * <p>
+ * Example usage:
+ * </p>
+ * 
+ * <pre>
+ * {
+ *   &#64;code
+ *   RedisClient client = RedisClient.builder().host("localhost").port(6379).build();
+ * }
+ * </pre>
+ * <p>
+ * For advanced configuration, see the {@link RedisClient.Builder} class.
+ * </p>
+ */
 public class RedisClient extends UnifiedJedis {
 
   public RedisClient() {
     this(Protocol.DEFAULT_HOST, Protocol.DEFAULT_PORT);
   }
 
   /**
-   * WARNING: This constructor only accepts a uri string as {@code url}. {@link JedisURIHelper#isValid(java.net.URI)}
-   * can be used before this.
+   * WARNING: This constructor only accepts a uri string as {@code url}.
+   * {@link JedisURIHelper#isValid(java.net.URI)} can be used before this.
    * <p>
-   * To use a host string, {@link #RedisClient(java.lang.String, int)} can be used with {@link Protocol#DEFAULT_PORT}.
-   *
-   * @param url
+   * To use a host string, {@link #RedisClient(java.lang.String, int)} can be used with
+   * {@link Protocol#DEFAULT_PORT}.
+   * @param url redis url
    */
   public RedisClient(final String url) {
     super(url);
@@ -37,14 +62,16 @@ public RedisClient(final HostAndPort hostAndPort) {
   }
 
   public RedisClient(final String host, final int port, final String user, final String password) {
-    super(new HostAndPort(host, port), DefaultJedisClientConfig.builder().user(user).password(password).build());
+    super(new HostAndPort(host, port),
+        DefaultJedisClientConfig.builder().user(user).password(password).build());
   }
 
   public RedisClient(final URI uri) {
     super(uri);
   }
 
-  private RedisClient(CommandExecutor commandExecutor, ConnectionProvider connectionProvider, CommandObjects commandObjects, RedisProtocol redisProtocol, Cache cache) {
+  private RedisClient(CommandExecutor commandExecutor, ConnectionProvider connectionProvider,
+      CommandObjects commandObjects, RedisProtocol redisProtocol, Cache cache) {
     super(commandExecutor, connectionProvider, commandObjects, redisProtocol, cache);
   }
 
@@ -54,12 +81,12 @@ private RedisClient(CommandExecutor commandExecutor, ConnectionProvider connecti
    * Obtain an instance via {@link #builder()}.
    * </p>
    */
-  static public class Builder extends StandaloneClientBuilder<RedisClient> {
+  public static class Builder extends StandaloneClientBuilder<RedisClient> {
 
     @Override
     protected RedisClient createClient() {
-      return new RedisClient(commandExecutor, connectionProvider, commandObjects, clientConfig.getRedisProtocol(),
-          cache);
+      return new RedisClient(commandExecutor, connectionProvider, commandObjects,
+          clientConfig.getRedisProtocol(), cache);
     }
   }
 
@@ -80,4 +107,3 @@ public Pipeline pipelined() {
     return (Pipeline) super.pipelined();
   }
 }
-

src/main/java/redis/clients/jedis/RedisClusterClient.java

@@ -13,6 +13,35 @@
 import redis.clients.jedis.providers.ConnectionProvider;
 import redis.clients.jedis.util.JedisClusterCRC16;
 
+/**
+ * RedisClusterClient provides a high-level, unified interface for interacting with a Redis Cluster.
+ * <p>
+ * This class is intended as a modern replacement for the deprecated {@code JedisCluster} class. It
+ * supports all cluster operations and is designed to work seamlessly with the {@link UnifiedJedis}
+ * API, allowing for consistent usage patterns across standalone, sentinel, and cluster deployments.
+ * <p>
+ * <b>Usage:</b>
+ * 
+ * <pre>
+ * {
+ *   &#64;code
+ *   Set<HostAndPort> clusterNodes = new HashSet<>();
+ *   clusterNodes.add(new HostAndPort("127.0.0.1", 7000));
+ *   RedisClusterClient client = new RedisClusterClient(clusterNodes);
+ *   client.set("key", "value");
+ *   String value = client.get("key");
+ * }
+ * </pre>
+ * <p>
+ * <b>Migration:</b> Users of {@code JedisCluster} are encouraged to migrate to this class for
+ * improved API consistency, better resource management, and enhanced support for future Redis
+ * features.
+ * <p>
+ * <b>Thread-safety:</b> This client is thread-safe and can be shared across multiple threads.
+ * <p>
+ * <b>Configuration:</b> Various constructors allow for flexible configuration, including
+ * authentication and custom timeouts.
+ */
 public class RedisClusterClient extends UnifiedJedis {
 
   public static final String INIT_NO_ERROR_PROPERTY = "jedis.cluster.initNoError";
@@ -28,35 +57,46 @@ public class RedisClusterClient extends UnifiedJedis {
   public static final int DEFAULT_MAX_ATTEMPTS = 5;
 
   /**
-   * Creates a RedisClusterClient instance. The provided node is used to make the first contact with the cluster.
+   * Creates a RedisClusterClient instance. The provided node is used to make the first contact with
+   * the cluster.
    * <p>
-   * Here, the default timeout of {@value redis.clients.jedis.RedisClusterClient#DEFAULT_TIMEOUT} ms is being used with
-   * {@value redis.clients.jedis.RedisClusterClient#DEFAULT_MAX_ATTEMPTS} maximum attempts.
+   * Here, the default timeout of {@value redis.clients.jedis.RedisClusterClient#DEFAULT_TIMEOUT} ms
+   * is being used with {@value redis.clients.jedis.RedisClusterClient#DEFAULT_MAX_ATTEMPTS} maximum
+   * attempts.
    * @param node Node to first connect to.
    */
   public RedisClusterClient(HostAndPort node) {
-    super(new ClusterConnectionProvider(Collections.singleton(node), DefaultJedisClientConfig.builder().timeoutMillis(DEFAULT_TIMEOUT).build()),
+    super(
+        new ClusterConnectionProvider(Collections.singleton(node),
+            DefaultJedisClientConfig.builder().timeoutMillis(DEFAULT_TIMEOUT).build()),
         DEFAULT_MAX_ATTEMPTS, Duration.ofMillis((long) DEFAULT_TIMEOUT * DEFAULT_MAX_ATTEMPTS));
   }
 
   /**
    * Creates a RedisClusterClient with multiple entry points.
    * <p>
-   * Here, the default timeout of {@value redis.clients.jedis.RedisClusterClient#DEFAULT_TIMEOUT} ms is being used with
-   * {@value redis.clients.jedis.RedisClusterClient#DEFAULT_MAX_ATTEMPTS} maximum attempts.
+   * Here, the default timeout of {@value redis.clients.jedis.RedisClusterClient#DEFAULT_TIMEOUT} ms
+   * is being used with {@value redis.clients.jedis.RedisClusterClient#DEFAULT_MAX_ATTEMPTS} maximum
+   * attempts.
    * @param nodes Nodes to connect to.
    */
   public RedisClusterClient(Set<HostAndPort> nodes) {
-    super(new ClusterConnectionProvider(nodes, DefaultJedisClientConfig.builder().timeoutMillis(DEFAULT_TIMEOUT).build()),
+    super(
+        new ClusterConnectionProvider(nodes,
+            DefaultJedisClientConfig.builder().timeoutMillis(DEFAULT_TIMEOUT).build()),
         DEFAULT_MAX_ATTEMPTS, Duration.ofMillis((long) DEFAULT_TIMEOUT * DEFAULT_MAX_ATTEMPTS));
   }
 
   public RedisClusterClient(Set<HostAndPort> nodes, String user, String password) {
-    super(new ClusterConnectionProvider(nodes, DefaultJedisClientConfig.builder().user(user).password(password).build()),
-        DEFAULT_MAX_ATTEMPTS, Duration.ofMillis((long) Protocol.DEFAULT_TIMEOUT * DEFAULT_MAX_ATTEMPTS));
+    super(
+        new ClusterConnectionProvider(nodes,
+            DefaultJedisClientConfig.builder().user(user).password(password).build()),
+        DEFAULT_MAX_ATTEMPTS,
+        Duration.ofMillis((long) Protocol.DEFAULT_TIMEOUT * DEFAULT_MAX_ATTEMPTS));
   }
 
-  private RedisClusterClient(CommandExecutor commandExecutor, ConnectionProvider connectionProvider, CommandObjects commandObjects, RedisProtocol redisProtocol, Cache cache) {
+  private RedisClusterClient(CommandExecutor commandExecutor, ConnectionProvider connectionProvider,
+      CommandObjects commandObjects, RedisProtocol redisProtocol, Cache cache) {
     super(commandExecutor, connectionProvider, commandObjects, redisProtocol, cache);
   }
 
@@ -70,8 +110,8 @@ static public class Builder extends ClusterClientBuilder<RedisClusterClient> {
 
     @Override
     protected RedisClusterClient createClient() {
-      return new RedisClusterClient(commandExecutor, connectionProvider, commandObjects, clientConfig.getRedisProtocol(),
-          cache);
+      return new RedisClusterClient(commandExecutor, connectionProvider, commandObjects,
+          clientConfig.getRedisProtocol(), cache);
     }
   }
 
@@ -95,7 +135,8 @@ public Map<String, ConnectionPool> getClusterNodes() {
   /**
    * Returns the connection for one of the 16,384 slots.
    * @param slot the slot to retrieve the connection for.
-   * @return connection of the provided slot. {@code close()} of this connection must be called after use.
+   * @return connection of the provided slot. {@code close()} of this connection must be called
+   *         after use.
    */
   public Connection getConnectionFromSlot(int slot) {
     return ((ClusterConnectionProvider) provider).getConnectionFromSlot(slot);
@@ -125,7 +166,8 @@ public void ssubscribe(BinaryJedisShardedPubSub jedisPubSub, final byte[]... cha
 
   @Override
   public ClusterPipeline pipelined() {
-    return new ClusterPipeline((ClusterConnectionProvider) provider, (ClusterCommandObjects) commandObjects);
+    return new ClusterPipeline((ClusterConnectionProvider) provider,
+        (ClusterCommandObjects) commandObjects);
   }
 
   /**
@@ -140,9 +182,9 @@ public AbstractTransaction transaction(boolean doMulti) {
 
   public final <T> T executeCommandToReplica(CommandObject<T> commandObject) {
     if (!(executor instanceof ClusterCommandExecutor)) {
-      throw new UnsupportedOperationException("Support only execute to replica in ClusterCommandExecutor");
+      throw new UnsupportedOperationException(
+          "Support only execute to replica in ClusterCommandExecutor");
     }
     return ((ClusterCommandExecutor) executor).executeCommandToReplica(commandObject);
   }
 }
-

src/main/java/redis/clients/jedis/RedisSentinelClient.java

@@ -1,19 +1,43 @@
 package redis.clients.jedis;
 
-import java.util.Set;
-import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
-import redis.clients.jedis.annots.Experimental;
 import redis.clients.jedis.builders.SentinelClientBuilder;
 import redis.clients.jedis.csc.Cache;
-import redis.clients.jedis.csc.CacheConfig;
-import redis.clients.jedis.csc.CacheFactory;
+
 import redis.clients.jedis.executors.CommandExecutor;
 import redis.clients.jedis.providers.ConnectionProvider;
 import redis.clients.jedis.providers.SentineledConnectionProvider;
 
+/**
+ * A high-level client for interacting with Redis Sentinel-managed Redis deployments.
+ * <p>
+ * {@code RedisSentinelClient} provides robust support for automatic master failover, connection
+ * management, and command execution in environments where Redis Sentinel is used to monitor and
+ * manage Redis servers.
+ * </p>
+ * <p>
+ * Usage:
+ * </p>
+ * 
+ * <pre>
+ * RedisSentinelClient client = RedisSentinelClient.builder().sentinel("localhost", 26379)
+ *     .masterName("mymaster").build();
+ * </pre>
+ * <p>
+ * <b>Relationship to {@code JedisSentineled}:</b>
+ * <ul>
+ * <li>{@code RedisSentinelClient} is the recommended replacement for the deprecated
+ * {@code JedisSentineled} class.</li>
+ * <li>It offers improved API consistency, better failover handling, and a fluent builder for
+ * configuration.</li>
+ * <li>Use {@code RedisSentinelClient} for new codebases and when migrating from
+ * {@code JedisSentineled}.</li>
+ * </ul>
+ * </p>
+ */
 public class RedisSentinelClient extends UnifiedJedis {
-
-  private RedisSentinelClient(CommandExecutor commandExecutor, ConnectionProvider connectionProvider, CommandObjects commandObjects, RedisProtocol redisProtocol, Cache cache) {
+  private RedisSentinelClient(CommandExecutor commandExecutor,
+      ConnectionProvider connectionProvider, CommandObjects commandObjects,
+      RedisProtocol redisProtocol, Cache cache) {
     super(commandExecutor, connectionProvider, commandObjects, redisProtocol, cache);
   }
 
@@ -23,18 +47,17 @@ private RedisSentinelClient(CommandExecutor commandExecutor, ConnectionProvider
    * Obtain an instance via {@link #builder()}.
    * </p>
    */
-  static public class Builder extends SentinelClientBuilder<RedisSentinelClient> {
+  public static class Builder extends SentinelClientBuilder<RedisSentinelClient> {
 
     @Override
     protected RedisSentinelClient createClient() {
-      return new RedisSentinelClient(commandExecutor, connectionProvider, commandObjects, clientConfig.getRedisProtocol(),
-          cache);
+      return new RedisSentinelClient(commandExecutor, connectionProvider, commandObjects,
+          clientConfig.getRedisProtocol(), cache);
     }
   }
 
   /**
    * Create a new builder for configuring RedisSentinelClient instances.
-   *
    * @return a new {@link RedisSentinelClient.Builder} instance
    */
   public static Builder builder() {
@@ -50,4 +73,3 @@ public Pipeline pipelined() {
     return (Pipeline) super.pipelined();
   }
 }
-

src/main/java/redis/clients/jedis/UnifiedJedis.java

@@ -26,7 +26,6 @@
 import redis.clients.jedis.json.JsonSetParams;
 import redis.clients.jedis.json.Path;
 import redis.clients.jedis.json.Path2;
-import redis.clients.jedis.mcf.MultiDbCommandExecutor;
 import redis.clients.jedis.params.VAddParams;
 import redis.clients.jedis.params.VSimParams;
 import redis.clients.jedis.resps.RawVector;