#Как получить доступ к экземпляру кластера

package io.alauda.demo.redis;

import redis.clients.jedis.ConnectionPoolConfig;
import redis.clients.jedis.JedisClientConfig;
import redis.clients.jedis.DefaultJedisClientConfig;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.HostAndPort;

import java.time.Duration;
import java.util.Set;
import java.util.HashSet;

public class Main {
    public static void main(String []args) {
        // Configure Jedis pool options
        ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
        // Set connection pool size; -1 means unlimited. New connections will fail if this limit is exceeded.
        poolConfig.setMaxTotal(200);
        // Set maximum idle connections; idle connections exceeding this limit will be released immediately.
        poolConfig.setMaxIdle(10);
        // Set minimum idle connections; new idle connections will be created if below this threshold.
        poolConfig.setMinIdle(3);
        // Maximum wait time when no available connections exist and max connection count is reached.
        poolConfig.setMaxWait(Duration.ofSeconds(1));
        // PING to verify connection availability each time a connection is borrowed from the pool.
        poolConfig.setTestOnBorrow(true);
        // Test idle connections to detect and release invalid ones; only effective when timeBetweenEvictionRunsMillis > 1ms.
        poolConfig.setTestWhileIdle(true);
        // Set minimum idle duration for connections; connections exceeding this time will be released. -1 means never release. Only effective when timeBetweenEvictionRunsMillis > 0. Default: 30m.
        poolConfig.setMinEvictableIdleDuration(Duration.ofMinutes(5));
        // Number of connections to validate during each idle connection check; -n means 1/n of connections.
        poolConfig.setNumTestsPerEvictionRun(-1);
        // Set idle connection check interval; negative value means no eviction thread runs.
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofMinutes(1));

        // Maximum retry attempts.
        int maxAttempts = 3;
        // Maximum retry duration.
        Duration maxAttemptsDuration = Duration.ofSeconds(3);
        // Topology refresh interval.
        Duration topologyRefreshPeriod = Duration.ofMinutes(1);

        JedisClientConfig clientConfig = DefaultJedisClientConfig.builder()
                // Connection timeout, default 2 seconds.
                .connectionTimeoutMillis(2000)
                // Command timeout.
                .timeoutMillis(10000)
                // Client name for identifying connection source during debugging.
                .clientName("demo-jedis")
                .password("<password>")
                .build();

        Set<HostAndPort> nodes =  new HashSet<>();
        nodes.add(new HostAndPort("<ip1>", <port1>));
        nodes.add(new HostAndPort("<ip2>", <port2>));
        JedisCluster cluster = new JedisCluster(nodes, clientConfig, poolConfig, topologyRefreshPeriod, maxAttempts, maxAttemptsDuration);

        try {
            String val = cluster.get("test");
            System.out.printf("%s", val);
        } catch (Exception e) {
            e.printStackTrace();
        }
        cluster.close();
    }
}

package io.alauda.demo.redis;

// It is recommended to periodically upgrade to the latest version of the client for the latest bug fixes.
import io.lettuce.core.ClientOptions;
import io.lettuce.core.RedisURI;
import io.lettuce.core.SocketOptions;
import io.lettuce.core.TimeoutOptions;
import io.lettuce.core.cluster.ClusterClientOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions;
import io.lettuce.core.cluster.RedisClusterClient;
import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;
import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        RedisURI node1 = RedisURI.create("<ip1>", <port1>);
        node1.setPassword("<password>");
        node1.setClientName("demo-lettuce");

        RedisURI node2 = RedisURI.create("<ip2>", <port2>);
        node2.setPassword("<password>");
        node2.setClientName("demo-lettuce");

        List<RedisURI> nodes = new ArrayList<>();
        nodes.add(node1);
        nodes.add(node2);

        ClusterTopologyRefreshOptions refreshOptions = ClusterTopologyRefreshOptions.builder()
                // The default interval for refreshing topology is 60 seconds.
                .enablePeriodicRefresh()
                // Triggers topology refresh when encountering the following errors: ASK_REDIRECT, MOVED_REDIRECT, PERSISTENT_RECONNECTS, UNCOVERED_SLOT, UNKNOWN_NODE
                .enableAllAdaptiveRefreshTriggers()
                .build();

        TimeoutOptions timeoutOptions = TimeoutOptions.builder()
                // Sets the command timeout.
                .fixedTimeout(Duration.ofSeconds(10))
                .build();

        SocketOptions socketOptions = SocketOptions.builder()
                // Sets the connection timeout.
                .connectTimeout(Duration.ofSeconds(10))
                .tcpNoDelay(true)
                // Enables TCP keepalive to quickly identify invalid connections.
                // This value is not mandatory for non-pub/sub requests; it can be managed via timely release of idle connections.
                .keepAlive(true)
                .build();

        ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
                .topologyRefreshOptions(refreshOptions)
                // Sets the command timeout.
                .timeoutOptions(timeoutOptions)
                // Automatic reconnection (default behavior).
                .autoReconnect(true)
                // Configures client behavior when disconnected.
                // DEFAULT - When autoReconnect = true, commands will not be rejected when they come in; otherwise, commands will be rejected.
                .disconnectedBehavior(ClientOptions.DisconnectedBehavior.DEFAULT)
                // Configures socket parameters; lettuce does not enable keepalive by default; this should be enabled for long connection business needs.
                .socketOptions(socketOptions)
                .build();

        RedisClusterClient redisClient = RedisClusterClient.create(nodes);
        redisClient.setOptions(clusterClientOptions);

        GenericObjectPoolConfig<StatefulRedisClusterConnection<String, String>> poolConfig = new GenericObjectPoolConfig<>();
        // Connection pool size should not be too large to avoid wasting server connection resources, leading to exhaustion of connections and instance unavailability.
        // It is recommended to estimate your business concurrency divided by the number of shards; the final value should be 1.2-1.5 times.
        poolConfig.setMaxTotal(200);
        // Minimum number of idle connections to reserve for faster business response.
        poolConfig.setMinIdle(3);
        // Maximum number of idle connections; exceeding this limit will release idle connections immediately.
        poolConfig.setMaxIdle(10);
        // Minimum idle duration for connections.
        poolConfig.setMinEvictableIdleDuration(Duration.ofMinutes(5));
        // Number of connections to validate during each idle connection check; -n means 1/n of connections.
        poolConfig.setNumTestsPerEvictionRun(3);
        // Eviction interval; -1 means disable.
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofMinutes(1));
        // Maximum wait time when no available connections and max connection count is reached.
        poolConfig.setMaxWait(Duration.ofSeconds(1));
        // PING to verify if the connection is available each time a connection is borrowed.
        poolConfig.setTestOnBorrow(true);
        // Test idle connections to find invalid ones and release them; this configuration only takes effect when timeBetweenEvictionRunsMillis is greater than 1ms.
        poolConfig.setTestWhileIdle(true);

        GenericObjectPool<StatefulRedisClusterConnection<String, String>> pool = ConnectionPoolSupport
                .createGenericObjectPool(redisClient::connect, poolConfig);

        try {
            try (StatefulRedisClusterConnection<String, String> connection = pool.borrowObject()) {
                String val = connection.sync().get("test");
                System.out.printf("%s", val);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        pool.close();
    }
}

package io.alauda.demo.redis;

// It is recommended to periodically upgrade to the latest version of the client for the latest bug fixes.
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        List<String> nodes = new ArrayList<>();
        nodes.add("redis://<ip1>:<port1>");
        nodes.add("redis://<ip2>:<port2>");

        Config config = new Config();
        config
                .setNettyThreads(64)
                .useClusterServers()
                .addNodeAddress(nodes.toArray(new String[0]))
                .setPassword("<password>")
                // Check cluster slots state on service startup.
                .setCheckSlotsCoverage(true)
                // Interval for scanning cluster topology.
                .setScanInterval(5000)
                // Connection timeout.
                .setConnectTimeout(10000)
                // Command timeout.
                .setTimeout(10000)
                // Every 30 seconds test a connection for availability.
                // If KeepAlive is enabled, this timeout can be proportionally extended.
                .setPingConnectionInterval(30000)
                // Idle connection timeout; drop connections idle for more than 60 seconds, default of 10 seconds is too short.
                .setIdleConnectionTimeout(60000)
                // Connection pool size should not be too large to avoid wasting server connection resources, leading to exhaustion of connections and instance unavailability.
                // It is recommended to estimate your business concurrency divided by the number of shards; the final value should be 1.2-1.5 times.
                .setMasterConnectionPoolSize(200)
                // Minimum number of idle connections to reserve for faster business response.
                .setMasterConnectionMinimumIdleSize(10)
                // Number of retry attempts for failed commands.
                .setRetryAttempts(3)
                // Retry interval for failed commands.
                .setRetryInterval(1500)
                // Enable TCP keepalive mechanism for quick discovery of unexpectedly disconnected connections.
                .setKeepAlive(true)
                // TCP no delay.
                .setTcpNoDelay(true)
                // Client name for checking connection source during debugging.
                .setClientName("demo-redisson");
        RedissonClient redissonClient = Redisson.create(config);

        System.out.printf("%s", redissonClient.getBucket("test").get().toString());

        redissonClient.shutdown();
    }
}