Redis

关注公众号 jb51net

关闭
首页 > 数据库 > Redis > Redis缓存降级

Redis缓存降级的四种策略

作者：风象南

在高并发系统架构中,Redis作为核心缓存组件扮演着至关重要的角色,它不仅能够显著提升系统响应速度,还能有效减轻数据库压力,然而,当Redis服务出现故障、性能下降或连接超时时,如果没有适当的降级机制,可能导致系统雪崩,所以本文给大家介绍了Redis缓存降级的四种策略

引言

在高并发系统架构中，Redis作为核心缓存组件扮演着至关重要的角色。它不仅能够显著提升系统响应速度，还能有效减轻数据库压力。

然而，当Redis服务出现故障、性能下降或连接超时时，如果没有适当的降级机制，可能导致系统雪崩，引发全局性的服务不可用。

缓存降级是高可用系统设计中的关键环节，它提供了在缓存层故障时系统行为的备选方案，确保核心业务流程能够继续运行。

什么是缓存降级？

缓存降级是指当缓存服务不可用或响应异常缓慢时，系统主动或被动采取的备选处理机制，以保障业务流程的连续性和系统的稳定性。

与缓存穿透、缓存击穿和缓存雪崩等问题的应对策略相比，缓存降级更关注的是"优雅降级"，即在性能和功能上做出一定妥协，但保证系统核心功能可用。

策略一：本地缓存回退策略

原理

本地缓存回退策略在Redis缓存层之外，增加一个应用内的本地缓存层(如Caffeine、Guava Cache等)。当Redis不可用时，系统自动切换到本地缓存，虽然数据一致性和实时性可能受到影响，但能保证基本的缓存功能。

实现方式

以下是使用Spring Boot + Caffeine实现的本地缓存回退示例：

@Service
public class ProductService {
    @Autowired
    private RedisTemplate<String, Product> redisTemplate;
    
    // 配置本地缓存
    private Cache<String, Product> localCache = Caffeine.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();
    
    @Autowired
    private ProductRepository productRepository;
    
    private final AtomicBoolean redisAvailable = new AtomicBoolean(true);
    
    public Product getProductById(String productId) {
        Product product = null;
        
        // 尝试从Redis获取
        if (redisAvailable.get()) {
            try {
                product = redisTemplate.opsForValue().get("product:" + productId);
            } catch (Exception e) {
                // Redis异常，标记为不可用，记录日志
                redisAvailable.set(false);
                log.warn("Redis unavailable, switching to local cache", e);
                // 启动后台定时任务检测Redis恢复
                scheduleRedisRecoveryCheck();
            }
        }
        
        // 如果Redis不可用或未命中，尝试本地缓存
        if (product == null) {
            product = localCache.getIfPresent(productId);
        }
        
        // 如果本地缓存也未命中，从数据库加载
        if (product == null) {
            product = productRepository.findById(productId).orElse(null);
            
            // 如果找到产品，更新本地缓存
            if (product != null) {
                localCache.put(productId, product);
                
                // 如果Redis可用，也更新Redis缓存
                if (redisAvailable.get()) {
                    try {
                        redisTemplate.opsForValue().set("product:" + productId, product, 30, TimeUnit.MINUTES);
                    } catch (Exception e) {
                        // 更新失败仅记录日志，不影响返回结果
                        log.error("Failed to update Redis cache", e);
                    }
                }
            }
        }
        
        return product;
    }
    
    // 定时检查Redis是否恢复
    private void scheduleRedisRecoveryCheck() {
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(() -> {
            try {
                redisTemplate.getConnectionFactory().getConnection().ping();
                redisAvailable.set(true);
                log.info("Redis service recovered");
                scheduler.shutdown();
            } catch (Exception e) {
                log.debug("Redis still unavailable");
            }
        }, 30, 30, TimeUnit.SECONDS);
    }
}

优缺点分析

优点：

缺点：

适用场景

策略二：静态默认值策略

原理

静态默认值策略是最简单的降级方式，当缓存不可用时，直接返回预定义的默认数据或静态内容，避免对底层数据源的访问。这种策略适用于非核心数据展示，如推荐列表、广告位、配置项等。

实现方式

@Service
public class RecommendationService {
    @Autowired
    private RedisTemplate<String, List<ProductRecommendation>> redisTemplate;
    
    @Autowired
    private RecommendationEngine recommendationEngine;
    
    // 预加载的静态推荐数据，可以在应用启动时初始化
    private static final List<ProductRecommendation> DEFAULT_RECOMMENDATIONS = new ArrayList<>();
    
    static {
        // 初始化一些通用热门商品作为默认推荐
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1001", "热门商品1", 4.8));
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1002", "热门商品2", 4.7));
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1003", "热门商品3", 4.9));
        // 更多默认推荐...
    }
    
    public List<ProductRecommendation> getRecommendationsForUser(String userId) {
        String cacheKey = "recommendations:" + userId;
        
        try {
            // 尝试从Redis获取个性化推荐
            List<ProductRecommendation> cachedRecommendations = redisTemplate.opsForValue().get(cacheKey);
            
            if (cachedRecommendations != null) {
                return cachedRecommendations;
            }
            
            // 缓存未命中，生成新的推荐
            List<ProductRecommendation> freshRecommendations = recommendationEngine.generateForUser(userId);
            
            // 缓存推荐结果
            if (freshRecommendations != null && !freshRecommendations.isEmpty()) {
                redisTemplate.opsForValue().set(cacheKey, freshRecommendations, 1, TimeUnit.HOURS);
                return freshRecommendations;
            } else {
                // 推荐引擎返回空结果，使用默认推荐
                return DEFAULT_RECOMMENDATIONS;
            }
        } catch (Exception e) {
            // Redis或推荐引擎异常，返回默认推荐
            log.warn("Failed to get recommendations, using defaults", e);
            return DEFAULT_RECOMMENDATIONS;
        }
    }
}

优缺点分析

优点

缺点

适用场景

策略三：降级开关策略

原理

降级开关策略通过配置动态开关，在缓存出现故障时，临时关闭特定功能或简化处理流程，减轻系统负担。这种策略通常结合配置中心实现，具有较强的灵活性和可控性。

实现方式

使用Spring Cloud Config和Apollo等配置中心实现降级开关：

@Service
public class UserProfileService {
    @Autowired
    private RedisTemplate<String, UserProfile> redisTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @Value("${feature.profile.full-mode:true}")
    private boolean fullProfileMode;
    
    @Value("${feature.profile.use-cache:true}")
    private boolean useCache;
    
    // Apollo配置中心监听器自动刷新配置
    @ApolloConfigChangeListener
    private void onChange(ConfigChangeEvent changeEvent) {
        if (changeEvent.isChanged("feature.profile.full-mode")) {
            fullProfileMode = Boolean.parseBoolean(changeEvent.getChange("feature.profile.full-mode").getNewValue());
        }
        if (changeEvent.isChanged("feature.profile.use-cache")) {
            useCache = Boolean.parseBoolean(changeEvent.getChange("feature.profile.use-cache").getNewValue());
        }
    }
    
    public UserProfile getUserProfile(String userId) {
        if (!useCache) {
            // 缓存降级开关已启用，直接查询数据库
            return getUserProfileFromDb(userId, fullProfileMode);
        }
        
        // 尝试从缓存获取
        try {
            UserProfile profile = redisTemplate.opsForValue().get("user:profile:" + userId);
            if (profile != null) {
                return profile;
            }
        } catch (Exception e) {
            // 缓存异常时记录日志，并继续从数据库获取
            log.warn("Redis cache failure when getting user profile", e);
            // 可以在这里触发自动降级开关
            triggerAutoDegradation("profile.cache");
        }
        
        // 缓存未命中或异常，从数据库获取
        return getUserProfileFromDb(userId, fullProfileMode);
    }
    
    // 根据fullProfileMode决定是否加载完整或简化的用户资料
    private UserProfile getUserProfileFromDb(String userId, boolean fullMode) {
        if (fullMode) {
            // 获取完整用户资料，包括详细信息、偏好设置等
            UserProfile fullProfile = userRepository.findFullProfileById(userId);
            try {
                // 尝试更新缓存，但不影响主流程
                if (useCache) {
                    redisTemplate.opsForValue().set("user:profile:" + userId, fullProfile, 30, TimeUnit.MINUTES);
                }
            } catch (Exception e) {
                log.error("Failed to update user profile cache", e);
            }
            return fullProfile;
        } else {
            // 降级模式：只获取基本用户信息
            return userRepository.findBasicProfileById(userId);
        }
    }
    
    // 触发自动降级
    private void triggerAutoDegradation(String feature) {
        // 实现自动降级逻辑，如通过配置中心API修改配置
        // 或更新本地降级状态，在达到阈值后自动降级
    }
}

优缺点分析

优点

缺点

适用场景

策略四：熔断与限流策略

原理

熔断与限流策略通过监控Redis的响应状态，当发现异常时自动触发熔断机制，暂时切断对Redis的访问，避免雪崩效应。同时，通过限流控制进入系统的请求量，防止在降级期间系统过载。

实现方式

使用Resilience4j或Sentinel实现熔断与限流：

@Service
public class ProductCatalogService {
    @Autowired
    private RedisTemplate<String, List<Product>> redisTemplate;
    
    @Autowired
    private ProductCatalogRepository repository;
    
    // 创建熔断器
    private final CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("redisCatalogCache");
    
    // 创建限流器
    private final RateLimiter rateLimiter = RateLimiter.of("catalogService", RateLimiterConfig.custom()
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .limitForPeriod(1000) // 每秒允许1000次请求
            .timeoutDuration(Duration.ofMillis(25))
            .build());
    
    public List<Product> getProductsByCategory(String category, int page, int size) {
        // 应用限流
        rateLimiter.acquirePermission();
        
        String cacheKey = "products:category:" + category + ":" + page + ":" + size;
        
        // 使用熔断器包装Redis调用
        Supplier<List<Product>> redisCall = CircuitBreaker.decorateSupplier(
                circuitBreaker, 
                () -> redisTemplate.opsForValue().get(cacheKey)
        );
        
        try {
            // 尝试从Redis获取数据
            List<Product> products = redisCall.get();
            if (products != null) {
                return products;
            }
        } catch (Exception e) {
            // 熔断器会处理异常，这里只需记录日志
            log.warn("Failed to get products from cache, fallback to database", e);
        }
        
        // 熔断或缓存未命中，从数据库加载
        List<Product> products = repository.findByCategory(category, PageRequest.of(page, size));
        
        // 只在熔断器闭合状态下更新缓存
        if (circuitBreaker.getState() == CircuitBreaker.State.CLOSED) {
            try {
                redisTemplate.opsForValue().set(cacheKey, products, 1, TimeUnit.HOURS);
            } catch (Exception e) {
                log.error("Failed to update product cache", e);
            }
        }
        
        return products;
    }
    
    // 提供熔断器状态监控端点
    public CircuitBreakerStatus getCircuitBreakerStatus() {
        return new CircuitBreakerStatus(
                circuitBreaker.getState().toString(),
                circuitBreaker.getMetrics().getFailureRate(),
                circuitBreaker.getMetrics().getNumberOfBufferedCalls(),
                circuitBreaker.getMetrics().getNumberOfFailedCalls()
        );
    }
    
    // 值对象：熔断器状态
    @Data
    @AllArgsConstructor
    public static class CircuitBreakerStatus {
        private String state;
        private float failureRate;
        private int totalCalls;
        private int failedCalls;
    }
}

优缺点分析

优点

缺点

适用场景

总结

通过合理实施Redis缓存降级策略，即使在缓存层出现故障的情况下，系统仍能保持基本功能，为用户提供持续可用的服务。这不仅提高了系统的可靠性，也为业务连续性提供了有力保障。

到此这篇关于Redis缓存降级的四种策略的文章就介绍到这了,更多相关Redis缓存降级内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文