@Data
@ConfigurationProperties(prefix = "redis.sdk", ignoreInvalidFields = true)
public class RedisClientConfigProperties {
    // 默認(rèn)實(shí)例配置
    private DefaultConfig defaultConfig;
    // 多個(gè)實(shí)例配置
    private Map<String, InstanceConfig> instances = new HashMap<>();
    // 路由規(guī)則配置
    private Map<String, RouteRule> routeRules = new HashMap<>();
    @Data
    public static class DefaultConfig {
        private String host;
        private int port;
        private String password;
        private int poolSize = 64;
        private int minIdleSize = 10;
        private int idleTimeout = 10000;
        private int connectTimeout = 10000;
        private int retryAttempts = 3;
        private int retryInterval = 1000;
        private int pingInterval = 0;
        private boolean keepAlive = true;
    }
    @Data
    public static class InstanceConfig {
        private String host;
        private int port;
        private String password;
        private int poolSize = 64;
        private int minIdleSize = 10;
        private int idleTimeout = 10000;
        private int connectTimeout = 10000;
        private int retryAttempts = 3;
        private int retryInterval = 1000;
        private int pingInterval = 0;
        private boolean keepAlive = true;
    }
    @Data
    public static class RouteRule {
        // 路由類(lèi)型：prefix（前綴匹配）、regex（正則匹配）、hash（哈希路由）
        private String type;
        // 匹配規(guī)則
        private String pattern;
        // 目標(biāo)實(shí)例名稱(chēng)
        private String targetInstance;
    }
}

redis:
  sdk:
    # 默認(rèn)實(shí)例配置
    default-config:
      host: 127.0.0.1
      port: 6379
    # 多個(gè)Redis實(shí)例配置
    instances:
      # 普通實(shí)例
      normal:
        host: 127.0.0.1
        port: 6379
      # 熱點(diǎn)Key實(shí)例
      hot:
        host: 127.0.0.1
        port: 6380
      # 活動(dòng)相關(guān)實(shí)例
      activity:
        host: 127.0.0.1
        port: 6381
    # 路由規(guī)則配置
    route-rules:
      # 熱點(diǎn)Key路由規(guī)則：以"hot_"開(kāi)頭的Key路由到hot實(shí)例
      hot-rule:
        type: prefix
        pattern: hot_
        target-instance: hot
      # 活動(dòng)Key路由規(guī)則：以"activity_"開(kāi)頭的Key路由到activity實(shí)例
      activity-rule:
        type: prefix
        pattern: activity_
        target-instance: activity

@Configuration
@EnableConfigurationProperties(RedisClientConfigProperties.class)
public class RedisClientConfig {
    // Redis實(shí)例映射，key為實(shí)例名稱(chēng)，value為RedissonClient實(shí)例
    private final Map<String, RedissonClient> redisInstances = new ConcurrentHashMap<>();
    // 路由規(guī)則列表
    private final List<RouteRuleWrapper> routeRules = new ArrayList<>();
    @PostConstruct
    public void init(ConfigurableApplicationContext applicationContext, RedisClientConfigProperties properties) {
        // 1. 初始化默認(rèn)實(shí)例
        initDefaultInstance(applicationContext, properties);
        // 2. 初始化其他實(shí)例
        initOtherInstances(applicationContext, properties);
        // 3. 初始化路由規(guī)則
        initRouteRules(properties);
    }
    private void initDefaultInstance(ConfigurableApplicationContext applicationContext, RedisClientConfigProperties properties) {
        RedisClientConfigProperties.DefaultConfig defaultConfig = properties.getDefaultConfig();
        RedissonClient redissonClient = createRedissonClient(defaultConfig);
        redisInstances.put("default", redissonClient);
    }
    private void initOtherInstances(ConfigurableApplicationContext applicationContext, RedisClientConfigProperties properties) {
        Map<String, RedisClientConfigProperties.InstanceConfig> instances = properties.getInstances();
        for (Map.Entry<String, RedisClientConfigProperties.InstanceConfig> entry : instances.entrySet()) {
            String instanceName = entry.getKey();
            RedisClientConfigProperties.InstanceConfig instanceConfig = entry.getValue();
            RedissonClient redissonClient = createRedissonClient(instanceConfig);
            redisInstances.put(instanceName, redissonClient);
        }
    }
    private void initRouteRules(RedisClientConfigProperties properties) {
        Map<String, RedisClientConfigProperties.RouteRule> routeRulesConfig = properties.getRouteRules();
        for (Map.Entry<String, RedisClientConfigProperties.RouteRule> entry : routeRulesConfig.entrySet()) {
            RedisClientConfigProperties.RouteRule config = entry.getValue();
            RouteRuleWrapper wrapper = new RouteRuleWrapper();
            wrapper.setType(config.getType());
            wrapper.setPattern(config.getPattern());
            wrapper.setTargetInstance(config.getTargetInstance());
            routeRules.add(wrapper);
        }
    }
    private RedissonClient createRedissonClient(Object configObj) {
        Config config = new Config();
        config.setCodec(JsonJacksonCodec.INSTANCE);
        String host;
        int port;
        String password;
        int poolSize;
        int minIdleSize;
        int idleTimeout;
        int connectTimeout;
        int retryAttempts;
        int retryInterval;
        int pingInterval;
        boolean keepAlive;
        // 根據(jù)配置對(duì)象類(lèi)型獲取配置屬性
        if (configObj instanceof RedisClientConfigProperties.DefaultConfig) {
            RedisClientConfigProperties.DefaultConfig defaultConfig = (RedisClientConfigProperties.DefaultConfig) configObj;
            host = defaultConfig.getHost();
            port = defaultConfig.getPort();
            password = defaultConfig.getPassword();
            poolSize = defaultConfig.getPoolSize();
            minIdleSize = defaultConfig.getMinIdleSize();
            idleTimeout = defaultConfig.getIdleTimeout();
            connectTimeout = defaultConfig.getConnectTimeout();
            retryAttempts = defaultConfig.getRetryAttempts();
            retryInterval = defaultConfig.getRetryInterval();
            pingInterval = defaultConfig.getPingInterval();
            keepAlive = defaultConfig.isKeepAlive();
        } else {
            RedisClientConfigProperties.InstanceConfig instanceConfig = (RedisClientConfigProperties.InstanceConfig) configObj;
            host = instanceConfig.getHost();
            port = instanceConfig.getPort();
            password = instanceConfig.getPassword();
            poolSize = instanceConfig.getPoolSize();
            minIdleSize = instanceConfig.getMinIdleSize();
            idleTimeout = instanceConfig.getIdleTimeout();
            connectTimeout = instanceConfig.getConnectTimeout();
            retryAttempts = instanceConfig.getRetryAttempts();
            retryInterval = instanceConfig.getRetryInterval();
            pingInterval = instanceConfig.getPingInterval();
            keepAlive = instanceConfig.isKeepAlive();
        }
        // 配置單節(jié)點(diǎn)Redis
        SingleServerConfig singleServerConfig = config.useSingleServer()
                .setAddress("redis://" + host + ":" + port)
                .setConnectionPoolSize(poolSize)
                .setConnectionMinimumIdleSize(minIdleSize)
                .setIdleConnectionTimeout(idleTimeout)
                .setConnectTimeout(connectTimeout)
                .setRetryAttempts(retryAttempts)
                .setRetryInterval(retryInterval)
                .setPingConnectionInterval(pingInterval)
                .setKeepAlive(keepAlive);
        // 設(shè)置密碼（如果有）
        if (StringUtils.isNotBlank(password)) {
            singleServerConfig.setPassword(password);
        }
        return Redisson.create(config);
    }
    /**
     * 根據(jù)Key獲取對(duì)應(yīng)的RedissonClient實(shí)例
     */
    public RedissonClient getRedissonClient(String key) {
        // 遍歷路由規(guī)則，找到匹配的規(guī)則
        for (RouteRuleWrapper rule : routeRules) {
            if (matchRule(key, rule)) {
                String targetInstance = rule.getTargetInstance();
                return redisInstances.get(targetInstance);
            }
        }
        // 沒(méi)有匹配到規(guī)則，使用默認(rèn)實(shí)例
        return redisInstances.get("default");
    }
    /**
     * 檢查Key是否匹配路由規(guī)則
     */
    private boolean matchRule(String key, RouteRuleWrapper rule) {
        String type = rule.getType();
        String pattern = rule.getPattern();
        switch (type) {
            case "prefix":
                // 前綴匹配
                return key.startsWith(pattern);
            case "regex":
                // 正則匹配
                return key.matches(pattern);
            case "hash":
                // 哈希路由（根據(jù)Key的哈希值路由到不同實(shí)例）
                // 這里簡(jiǎn)化實(shí)現(xiàn)，實(shí)際可以根據(jù)哈希值和實(shí)例數(shù)量計(jì)算路由
                int hash = key.hashCode();
                return Math.abs(hash) % 2 == 0; // 示例：偶數(shù)哈希值匹配
            default:
                return false;
        }
    }
    /**
     * 路由規(guī)則包裝類(lèi)
     */
    @Data
    private static class RouteRuleWrapper {
        private String type;
        private String pattern;
        private String targetInstance;
    }
    /**
     * 注入Redis服務(wù)
     */
    @Bean("redisService")
    public RedisService redisService() {
        return new RedisServiceImpl(this);
    }
}

/**
 * Redis服務(wù)接口
 */
public interface RedisService {
    /**
     * 設(shè)置Key-Value
     */
    <T> void set(String key, T value);
    /**
     * 設(shè)置Key-Value，帶過(guò)期時(shí)間
     */
    <T> void set(String key, T value, long expireTime, TimeUnit timeUnit);
    /**
     * 獲取Value
     */
    <T> T get(String key, Class<T> clazz);
    /**
     * 刪除Key
     */
    boolean delete(String key);
    /**
     * 設(shè)置Hash字段
     */
    <T> void hset(String key, String field, T value);
    /**
     * 獲取Hash字段
     */
    <T> T hget(String key, String field, Class<T> clazz);
    // 其他Redis操作方法...
}
/**
 * Redis服務(wù)實(shí)現(xiàn)類(lèi)
 */
@Service
public class RedisServiceImpl implements RedisService {
    private final RedisClientConfig redisClientConfig;
    public RedisServiceImpl(RedisClientConfig redisClientConfig) {
        this.redisClientConfig = redisClientConfig;
    }
    @Override
    public <T> void set(String key, T value) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RMap<String, T> map = redissonClient.getMap("cache");
        map.put(key, value);
    }
    @Override
    public <T> void set(String key, T value, long expireTime, TimeUnit timeUnit) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value, expireTime, timeUnit);
    }
    @Override
    public <T> T get(String key, Class<T> clazz) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RBucket<T> bucket = redissonClient.getBucket(key);
        return bucket.get();
    }
    @Override
    public boolean delete(String key) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RBucket<Object> bucket = redissonClient.getBucket(key);
        return bucket.delete();
    }
    @Override
    public <T> void hset(String key, String field, T value) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RMap<String, T> map = redissonClient.getMap(key);
        map.put(field, value);
    }
    @Override
    public <T> T hget(String key, String field, Class<T> clazz) {
        RedissonClient redissonClient = redisClientConfig.getRedissonClient(key);
        RMap<String, T> map = redissonClient.getMap(key);
        return map.get(field);
    }
    // 其他Redis操作方法實(shí)現(xiàn)...
}

@Service
public class ActivityService {
    @Autowired
    private RedisService redisService;
    public void cacheActivityInfo(String activityId, Activity activity) {
        // 活動(dòng)相關(guān)Key，會(huì)路由到activity實(shí)例
        String key = "activity_" + activityId;
        redisService.set(key, activity, 1, TimeUnit.HOURS);
    }
    public Activity getActivityInfo(String activityId) {
        String key = "activity_" + activityId;
        return redisService.get(key, Activity.class);
    }
    public void cacheHotProduct(String productId, Product product) {
        // 熱點(diǎn)Key，會(huì)路由到hot實(shí)例
        String key = "hot_product_" + productId;
        redisService.set(key, product, 30, TimeUnit.MINUTES);
    }
    public Product getHotProduct(String productId) {
        String key = "hot_product_" + productId;
        return redisService.get(key, Product.class);
    }
    public void cacheUserInfo(String userId, User user) {
        // 普通Key，會(huì)路由到default實(shí)例
        String key = "user_" + userId;
        redisService.set(key, user, 24, TimeUnit.HOURS);
    }
}

+-------------------+    +-------------------+    +-------------------+
|                   |    |                   |    |                   |
|  應(yīng)用服務(wù)           |    |  Redis普通實(shí)例    |    |  Redis熱點(diǎn)實(shí)例    |
|  (RedisService)    |--->|  (Port: 6379)     |    |  (Port: 6380)     |
|                   |    |                   |    |                   |
+-------------------+    +-------------------+    +-------------------+
          |
          v
+-------------------+
|                   |
|  Redis活動(dòng)實(shí)例     |
|  (Port: 6381)     |
|                   |
+-------------------+