import redis.clients.jedis.Jedis;

public class JedisMultiInstanceExample {
    public static void main(String[] args) {
        // 連接第一個(gè)Redis實(shí)例
        Jedis jedis1 = new Jedis("redis1.example.com", 6379);
        jedis1.auth("password1"); // 認(rèn)證（如有密碼）
        jedis1.set("key1", "value1");
        System.out.println("Redis1 value: " + jedis1.get("key1"));

        // 連接第二個(gè)Redis實(shí)例
        Jedis jedis2 = new Jedis("redis2.example.com", 6379);
        jedis2.auth("password2");
        jedis2.set("key2", "value2");
        System.out.println("Redis2 value: " + jedis2.get("key2"));

        // 關(guān)閉連接
        jedis1.close();
        jedis2.close();
    }
}

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolMultiInstance {
    public static void main(String[] args) {
        // 配置連接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(10); // 最大連接數(shù)

        // 第一個(gè)Redis連接池
        JedisPool jedisPool1 = new JedisPool(poolConfig, "redis1.example.com", 6379, 1000, "password1");
        
        // 第二個(gè)Redis連接池
        JedisPool jedisPool2 = new JedisPool(poolConfig, "redis2.example.com", 6379, 1000, "password2");

        try (Jedis jedis1 = jedisPool1.getResource()) {
            jedis1.set("key1", "value1");
        }

        try (Jedis jedis2 = jedisPool2.getResource()) {
            System.out.println(jedis2.get("key2"));
        }

        jedisPool1.close();
        jedisPool2.close();
    }
}

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

public class LettuceMultiInstanceExample {
    public static void main(String[] args) {
        // 第一個(gè)Redis實(shí)例
        RedisClient client1 = RedisClient.create("redis://password1@redis1.example.com:6379/0");
        StatefulRedisConnection<String, String> connection1 = client1.connect();
        RedisCommands<String, String> commands1 = connection1.sync();
        commands1.set("key1", "value1");

        // 第二個(gè)Redis實(shí)例
        RedisClient client2 = RedisClient.create("redis://password2@redis2.example.com:6379/0");
        StatefulRedisConnection<String, String> connection2 = client2.connect();
        RedisCommands<String, String> commands2 = connection2.sync();
        System.out.println(commands2.get("key2"));

        // 關(guān)閉連接
        connection1.close();
        connection2.close();
        client1.shutdown();
        client2.shutdown();
    }
}

import io.lettuce.core.cluster.RedisClusterClient;
import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
import io.lettuce.core.cluster.api.sync.RedisAdvancedClusterCommands;

public class LettuceClusterExample {
    public static void main(String[] args) {
        // 第一個(gè)Redis集群
        RedisClusterClient clusterClient1 = RedisClusterClient.create("redis://password1@redis-cluster1.example.com:6379");
        StatefulRedisClusterConnection<String, String> clusterConnection1 = clusterClient1.connect();
        RedisAdvancedClusterCommands<String, String> clusterCommands1 = clusterConnection1.sync();
        clusterCommands1.set("cluster-key1", "value1");

        // 第二個(gè)Redis集群
        RedisClusterClient clusterClient2 = RedisClusterClient.create("redis://password2@redis-cluster2.example.com:6379");
        StatefulRedisClusterConnection<String, String> clusterConnection2 = clusterClient2.connect();
        RedisAdvancedClusterCommands<String, String> clusterCommands2 = clusterConnection2.sync();
        System.out.println(clusterCommands2.get("cluster-key2"));

        clusterConnection1.close();
        clusterConnection2.close();
        clusterClient1.shutdown();
        clusterClient2.shutdown();
    }
}

spring:
  redis:
    host: redis1.example.com
    port: 6379
    password: password1
  redis-secondary:
    host: redis2.example.com
    port: 6379
    password: password2

@Configuration
public class RedisConfig {
    @Autowired
    private Environment env;

    @Bean
    @Primary
    public RedisConnectionFactory primaryRedisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(env.getProperty("spring.redis.host"));
        config.setPort(Integer.parseInt(env.getProperty("spring.redis.port")));
        config.setPassword(env.getProperty("spring.redis.password"));
        return new LettuceConnectionFactory(config);
    }

    @Bean
    public RedisConnectionFactory secondaryRedisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(env.getProperty("spring.redis-secondary.host"));
        config.setPort(Integer.parseInt(env.getProperty("spring.redis-secondary.port")));
        config.setPassword(env.getProperty("spring.redis-secondary.password"));
        return new LettuceConnectionFactory(config);
    }

    @Bean
    @Primary
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(primaryRedisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }

    @Bean(name = "secondaryRedisTemplate")
    public RedisTemplate<String, Object> secondaryRedisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(secondaryRedisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate; // 主實(shí)例

    @Autowired
    @Qualifier("secondaryRedisTemplate")
    private RedisTemplate<String, Object> secondaryRedisTemplate; // 次實(shí)例

    public void saveToPrimary(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public Object getFromSecondary(String key) {
        return secondaryRedisTemplate.opsForValue().get(key);
    }
}