本文主要是介绍使用@Cacheable注解Redis时Redis宕机或其他原因连不上继续调用原方法的解决方案，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
《使用@Cacheable注解Redis时Redis宕机或其他原因连不上继续调用原方法的解决方案》在SpringBoot应用中,我们经常使用@Cacheable注解来缓存数据,以提高应用的性能...
@Cacheable注解Redis时，Redis宕机或其他原因连不上，继续调用原方法的解决方案
在Spring Boot应用中，我们经常使用@Cacheable注解来缓存数据，以提高应用的性能。当选择Redis作为缓存存储时，如果Redis服务因某种原因不可用（如宕机、网络问题等），默认情况下，@Cacheable注解会抛出异常，导致整个请求失败。本文将探讨如何在Redis不可用时，让@Cacheable注解继续调用原方法，确保服务的可用性和稳定性。
1. 问题背景
1.1 @Cacheable注解的基本使用
@Cacheable是Spring框架提供的一个注解，用于标识一个方法的结果需要被缓存。当该方法被调用时，Spring会先检查缓存中是否存在对应的数据，如果存在，则直接返回缓存中的数据；如果不存在，则执行方法并将结果存入缓存。
1.2 Redis宕机的影响
当Redis服务宕机或网络连接出现问题时，@Cacheable注解尝试访问Redis时会抛出异常，例如org.springframework.data.redis.RedisConnectionFailureException。这会导致方法调用失败，影响用户体验和系统稳定性。
2. 解决方案
2.1 使用自定义异常处理器
可以通过自定义异常处理器来捕获Redis连接异常，并在捕获到异常时继续调用原方法。具体步骤如下：
2.1.1 创建自定义异常处理器
首先，创建一个自定义异常处理器类，用于处理Redis连接异常。
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.CacheErrorHandler;
public class CustomCacheErrorHandler implements CacheErrorHandler {
@Override
public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
// 处理读取缓存时的异常
System.out.println("Cache get error: " + exception.getMessage());
}
@Override
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
// 处理写入缓存时的异常
System.out.println("Cache put error: " + exception.getMessage());
}
@Override
public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
// 处理清除缓存时的异常
System.out.println("Cache evict error: " + exception.getMessage());
}
@Override
public void handleCacheClearError(RuntimeException exception, Cache cache) {
// 处理清空缓存时的异常
System.out.println("Cache clear error: " + exception.getMessage());
}
}2.1.2 配置自定义异常处理器
在Spring Boot配置文件中，配置自定义的异常处理器。
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.cache.annotation.EnableCaching;
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public CustomCacheErrorHandler customCacheErrorHandler() {
return new CustomCacheErrorHandler();
}
}2.2 使用@Cacheable的unless属性
@Cacheable注解提供了一个unless属性，可以在缓存操作成功后决定是否将结果存入缓存。虽然这个属性不能直接解决Redis宕机的问题，但可以结合其他逻辑来实现类似的效果。
2.3 使用@Cacheable的cache-null-values属性
设置@Cacheable注解的cache-null-values属性为false，这样即使Redis不可用，也不会将null值存入缓存。
@Cacheable(value = "myCache", cacheNullValues = false)
public User getUserById(Long id) {
return userRepository.findById(id).orElse(null);
}2.4 使用降级策略
在Redis不可用时，可以采用降级策略，例如从数据库中直接获取数据。这可以通过自定义的缓存管理器来实现。
import org.springframework.cache.Cache; import org.springframework.cache.CacheManager; import org.springframework.cache.concurrent.ConcurrentMapCacheManager; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; javascriptimport Java.util.Optional; @Configuration public class CustomCacheManager { @Bean public CacheManager cacheManager() { return new ConcurrentMapCacheManager("myCache") { @Override public Cache getCache(String name) { Cache cache = super.getCache(name); if (cache == null) { // 如果Redis不可用，使用本地缓存 cache = new ConcurrentMapCache(name); } php return cache; } }; } }
我们可以在Redis不可用时，确保@Cacheable注解继续调用原方法，从而提高系统的稳定性和可用性。具体实现方式包括自定义异常处理器、使用unless和cache-null-values属性、以及降级策略。在使用Spring框架结合Redis实现缓存功能时，如果Redis宕机或由于其他原因导致连接不上Redis，可以通过配置CacheManager来实现当缓存不可用时自动回退到原始方法的调用。这样可以保证系统的可用性和稳定性。
以下是一个具体的实现示例：
添加依赖：首先确保你的项目中已经添加了Spring Boot和Redis的相关依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>配置Redis连接：在application.properties中配置Redis连接信息。
spring.redis.host=localhost spring.redis.port=6379
自定义CacheManager：创建一个自定义的CacheManager，在其中处理Redis不可用的情况。
import org.springframework.cache.Cache; import org.springframework.cache.CacheManager; import org.springframework.cache.annotation.EnableCaching; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.serializer.GenericJackson2jsonRedisSerializer; import org.springframework.data.redis.serializer.RedisSerializationContext; import java.time.Duration; import java.util.HashMap; import java.util.Map; @Configuration @EnableCaching public class CacheConfig { @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofHours(1)) // 设置默认过期时间 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())); Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>(); cacheConfigurations.put("myCache", config); return new FallbackRedisCacheManager(redisConnectionFactowww.chinasem.cnry, config, cacheConfigurations); } }
实现FallbackRedisCacheManager：创建一个自定义的CacheManager，在Redis不可用时回退到内存缓存。
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFailureException;
import java.util.Arrays;
import java.util.List;
public class FallbackRedisCacheManager extends RedisCacheManager {
private final CacheManager fallbackCacheManager;
public FallbackRedisCacheManager(RedisConnectionFactory connectionFactory, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
super(connectionFactory, defaultCacheConfiguration, initialCacheConfigurations);
SimpleCacheManager simpleCacheManager = new SimpleCacheManager();
simpleCacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("fallbackCache")));
simpleCacheManager.afterPropertiesSet();
this.fallbackCacheManager = simpleCacheManager;
}
@Override
public Cache getCache(String name) {
try {
return super.getCache(name);
} catch (RedisConnectionFailureException e) {
return fallbackCacheManager.getCache(name);
}
}
}使用@Cacheable注解：在需要缓存的方法上使用@Cacheable注解。
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class MyService {
@Cacheable(value = "myCache", key = "#id")
public String getData(String id) {
// 模拟数据获取过程
System.out.println("Fetching data from database for ID: " + id);
return "Data for ID: " + id;
}
}通过上述配置，当Redis不可用时，FallbackRedisCacheManager会捕获到RedisConnectionFailureException异常，并回退到内存缓存。这样可以确保即使Redis宕机，系统仍然能够正常运行并返回数据。在使用Spring Cache与Redis结合时，如果Redis出现宕机或连接问题，可以通过配置CacheManager和实现自定义的CacheErrorHandler来确保即使缓存不可用，业务逻辑也能正常运行。以下是一个详细的解决方案示例：
1. 添加依赖
首先，确保你的项目中已经添加了Spring Boot Starter Cache和Spring Boot Starter Data Redis的依赖：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifaandroidctId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>2. 配置RedisTemplate
配置RedisTemplate以使用JSON序列化方式存储对象：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setHashKeySerializer(new StrinlbDIaQEBEgRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
}3. 配置CacheManager
配置CacheManager以使用Redis作为缓存存储：
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import java.time.Duration;
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofMinutes(60)) // 设置缓存过期时间为60分钟
.disableCachingNullValues();
return RedisCacheManager.builder(connectionFactory)
.cacheDefaults(config)
.build();
}
}4. 实现自定义的CacheErrorHandler
实现自定义的CacheErrorHandler，以便在缓存操作失败时进行处理：
import org.springframework.cache.Cache;
import org.springframework.cache.Cache.ValueException;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.CacheErrorHandler;
@Configuration
public class CacheConfig extends CachingConfigurerSupport {
@Override
public CacheErrorHandler errorHandler() {
return new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
// 处理缓存读取错误
System.out.println("Cache get error: " + exception.getMessage());
}
@Override
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
// 处理缓存写入错误
System.out.println("Cache put error: " + exception.getMessage());
}
@Override
public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
// 处理缓存删除错误
System.out.println("Cache evict error: " + exception.getMessage());
}
@Override
public void handleCacheClearError(RuntimeException exception, Cache cache) {
// 处理缓存清除错误
System.out.println("Cache clear error: " + exception.getMessage());
}
};
}
}5. 使用@Cacheable注解
在需要缓存的方法上使用@Cacheable注解：
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Cacheable(value = "users", key = "#userId")
public User getUserById(String userId) {
// 模拟从数据库获取用户信息
System.out.println("Fetching user from database: " + userId);
return new User(userId, "John Doe");
}
}6. 测试
你可以通过模拟Redis宕机或断开连接来测试上述配置是否生效。例如，可以临时关闭Redis服务，然后调用getUserById方法，查看是否能够正常返回数据。
总结
通过以上配置，当Redis不可用时，CacheErrorHandler会捕获到缓存操作的异常，并打印错误信息。同时，由于@Cacheable注解的默认行为是当缓存不可用时直接调用原方法，因此业务逻辑不会受到影响。这样可以确保系统的高可用性和稳定性。
到此这篇关于使用@Cacheable注解Redis时Redis宕机或其他原因连不上继续调用原方法的解决方案的文章就介绍到这了,更多相关@Cacheable注解 Redis宕机内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！
这篇关于使用@Cacheable注解Redis时Redis宕机或其他原因连不上继续调用原方法的解决方案的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
