深入浅析Redis的高可用方案

import redis.clients.jedis.jedis;
import redis.clients.jedis.jedissentinelpool;
import java.util.hashset;
import java.util.set;
public class redissentinelconfig {
    // 技术亮点1：单例模式+双重检查锁，保证连接池唯一
    private static volatile jedissentinelpool jedissentinelpool;
    public static jedissentinelpool getjedissentinelpool() {
        if (jedissentinelpool == null) {
            synchronized (redissentinelconfig.class) {
                if (jedissentinelpool == null) {
                    // 哨兵节点地址集合
                    set<string> sentinels = new hashset<>();
                    sentinels.add("192.168.1.10:26379");
                    sentinels.add("192.168.1.11:26379");
                    sentinels.add("192.168.1.12:26379");
                    // 技术亮点2：精细化连接池配置，避免连接泄漏
                    jedissentinelpool = new jedissentinelpool(
                            "mymaster", // 主节点名称
                            sentinels,
                            "password123", // redis密码
                            2000, // 连接超时
                            100, // 最大连接数
                            10, // 最小空闲连接数
                            30000 // 连接最大空闲时间
                    );
                }
            }
        }
        return jedissentinelpool;
    }
    // 使用示例
    public static void main(string[] args) {
        try (jedis jedis = getjedissentinelpool().getresource()) {
            jedis.set("key", "value");
            system.out.println(jedis.get("key"));
        }
    }
}

import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.connection.redisclusterconfiguration;
import org.springframework.data.redis.connection.lettuce.lettuceconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.stringredisserializer;
@configuration
public class redisclusterconfig {
    @bean
    public lettuceconnectionfactory redisconnectionfactory() {
        redisclusterconfiguration clusterconfig = new redisclusterconfiguration();
        // 集群节点地址
        clusterconfig.clusternode("192.168.1.20", 6379);
        clusterconfig.clusternode("192.168.1.21", 6379);
        clusterconfig.clusternode("192.168.1.22", 6379);
        clusterconfig.setpassword("password123");
        // 技术亮点3：开启集群重定向自动跟随
        clusterconfig.setmaxredirects(3);
        return new lettuceconnectionfactory(clusterconfig);
    }
    @bean
    public redistemplate<string, object> redistemplate(lettuceconnectionfactory connectionfactory) {
        redistemplate<string, object> template = new redistemplate<>();
        template.setconnectionfactory(connectionfactory);
        // 技术亮点4：使用string序列化器，避免默认jdk序列化的乱码问题
        template.setkeyserializer(new stringredisserializer());
        template.setvalueserializer(new stringredisserializer());
        template.afterpropertiesset();
        return template;
    }
}

/**
 * 技术亮点：自定义哈希标签工具类
 * 将相同业务的key强制路由到同一个哈希槽，支持mget/mset等多键操作
 */
public class redishashtagutil {
    // 哈希标签分隔符
    private static final string hash_tag_start = "{";
    private static final string hash_tag_end = "}";
    /**
     * 生成带哈希标签的key
     * @param businessid 业务id（如用户id、订单id）
     * @param keysuffix key后缀
     * @return 带哈希标签的key
     */
    public static string generatekey(string businessid, string keysuffix) {
        return hash_tag_start + businessid + hash_tag_end + ":" + keysuffix;
    }
    // 使用示例
    public static void main(string[] args) {
        // 同一个用户的所有key都会路由到同一个哈希槽
        string userinfokey = generatekey("user123", "info");
        string userorderkey = generatekey("user123", "orders");
        string usercartkey = generatekey("user123", "cart");
        // 现在可以安全地执行mget操作
        // redistemplate.opsforvalue().multiget(arrays.aslist(userinfokey, userorderkey, usercartkey));
    }
}

import org.springframework.retry.annotation.backoff;
import org.springframework.retry.annotation.retryable;
import org.springframework.stereotype.component;
import redis.clients.jedis.exceptions.jedisconnectionexception;
@component
public class redisretryservice {
    /**
     * 技术亮点：使用spring retry实现主从切换时的自动重试
     * 当发生连接异常时，最多重试3次，每次间隔1秒
     */
    @retryable(
            value = jedisconnectionexception.class,
            maxattempts = 3,
            backoff = @backoff(delay = 1000, multiplier = 2)
    )
    public string getwithretry(string key) {
        return redistemplate.opsforvalue().get(key);
    }
}

@configuration
public class redissentinelconfig {
    @bean
    public lettuceconnectionfactory lettuceconnectionfactory() {
        redissentinelconfiguration sentinelconfig = 
            new redissentinelconfiguration()
                .master("mymaster")                     // 哨兵监控的主库名
                .sentinel("192.168.1.10", 26379)
                .sentinel("192.168.1.11", 26379)
                .sentinel("192.168.1.12", 26379);
        sentinelconfig.setpassword(redispassword.of("sentinel_pass"));
        lettuceclientconfiguration clientconfig = 
            lettuceclientconfiguration.builder()
                .readfrom(readfrom.replica_preferred)   // 优先从副本读，分担压力
                .commandtimeout(duration.ofseconds(2))
                .build();
        return new lettuceconnectionfactory(sentinelconfig, clientconfig);
    }
    @bean
    public redistemplate<string, object> redistemplate(
            lettuceconnectionfactory factory) {
        redistemplate<string, object> template = new redistemplate<>();
        template.setconnectionfactory(factory);
        template.setkeyserializer(new stringredisserializer());
        template.setvalueserializer(new genericjackson2jsonredisserializer());
        return template;
    }
}

@configuration
public class redisclusterconfig {
    @bean
    public lettuceconnectionfactory clusterconnectionfactory() {
        redisclusterconfiguration clusterconfig = 
            new redisclusterconfiguration(arrays.aslist(
                "192.168.2.10:6379",
                "192.168.2.11:6379",
                "192.168.2.12:6379"
            ));
        clusterconfig.setpassword("cluster_pass");
        // 开启自适应刷新，集群拓扑变化时自动感知
        clustertopologyrefreshoptions refreshoptions = 
            clustertopologyrefreshoptions.builder()
                .enableperiodicrefresh(duration.ofseconds(30))  // 每30秒检查一次
                .enablealladaptiverefreshtriggers()             // 检测到moved/ask等自动立即刷新
                .build();
        lettuceclientconfiguration clientconfig = 
            lettuceclientconfiguration.builder()
                .clientoptions(clusterclientoptions.builder()
                    .topologyrefreshoptions(refreshoptions)
                    .build())
                .build();
        return new lettuceconnectionfactory(clusterconfig, clientconfig);
    }
}

@service
public class cacheservice {
    @autowired
    private redistemplate<string, object> redistemplate;
    public optional<user> getuserbyid(string id) {
        try {
            user user = (user) redistemplate.opsforvalue().get("user:" + id);
            return optional.ofnullable(user);
        } catch (redisconnectionfailureexception e) {
            log.warn("redis 不可用，降级查 db", e);
            // 降级到数据库查询
            return optional.ofnullable(userdao.findbyid(id));
        } catch (exception e) {
            log.error("redis 异常", e);
            return optional.empty();
        }
    }
}