专业建设网站专家/百度seo关键词工具

redis中常见的问题

前言

在本文中，我们将探讨 Redis 在缓存中的应用，并解决一些常见的缓存问题。为了简化理解，本文中的一些配置是直接写死的，实际项目中建议将这些配置写入配置文件，并通过配置文件读取。

一、为什么需要缓存？

在Web应用开发中，频繁的数据库查询和复杂的计算操作会显著影响系统性能。为了提升系统的响应速度和整体性能，缓存机制成为了不可或缺的一部分。Spring Cache通过抽象缓存层，使开发者能够通过简单的注解实现方法级别的缓存，从而有效减少重复计算和数据库访问，显著提升系统的响应速度。

前提

本文使用Redis作为缓存管理器（CacheManager），因此你需要确保正确引入并配置Redis。

引入与基本使用（此处由AI代写，非本文重点）

Spring Cache快速配置

Java配置类示例：

@Configuration
@EnableCaching
@Slf4j
public class RedisCachingAutoConfiguration {@Resourceprivate RedisConnectionFactory redisConnectionFactory;@Beanpublic CacheManager defaultCacheManager() {RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1));return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)).cacheDefaults(configuration).build();}
}

三、核心注解深度解析

1. @Cacheable：数据读取缓存

@Cacheable(value = "users", key = "#userId", unless = "#result == null")
public User getUserById(Long userId) {return userRepository.findById(userId).orElse(null);
}

value：指定缓存名称（必填）
key：支持SpEL表达式生成缓存键
condition：方法执行前判断（例如userId > 1000才缓存）
unless：方法执行后判断（例如空结果不缓存）

属性	执行时机	访问变量	作用场景
`condition`	方法执行前判断	只能访问方法参数（如 `#argName`）	决定是否执行缓存逻辑（包括是否执行方法体）
`unless`	方法执行后判断	可以访问方法参数和返回值（如 `#result`）	决定是否将方法返回值存入缓存（不影响是否执行方法体）

2. @CachePut：强制更新缓存

@CachePut(value = "users", key = "#user.id")
public User updateUser(User user) {return userRepository.save(user);
}

适用场景：数据更新后同步缓存，确保后续读取的是最新数据。

3. @CacheEvict：精准清除缓存

@CacheEvict(value = "users", key = "#userId", beforeInvocation = true)
public void deleteUser(Long userId) {userRepository.deleteById(userId);
}

删除指定条目：通过key精准定位
清空整个缓存：allEntries = true
beforeInvocation：方法执行前清除（避免执行失败导致脏数据）

4. @Caching：组合操作

@Caching(put = @CachePut(value = "users", key = "#user.id"),evict = @CacheEvict(value = "userList", allEntries = true)
)
public User updateUserProfile(User user) {// 业务逻辑
}

5. @CacheConfig：类级别配置

@Service
@CacheConfig(cacheNames = "products")
public class ProductService {// 类中方法默认使用products缓存
}

工程化实践解决方案

前面的示例内容由AI编写，经过测试可用。然而，在实际使用中，这些用法可能不符合某些场景需求，或者使用起来不够方便。以下是一些常见问题及解决方案：

自动生成的key格式为{cacheable.value}::{cacheable.key}，为什么一定是"::"两个冒号？
（查看源码org.springframework.data.redis.cache.CacheKeyPrefix）
如果需要为key统一加前缀，可以在RedisCacheConfiguration中设置。
批量删除时，@CacheEvict不够灵活。
- 方案一：使用@CacheEvict并设置allEntries为true，但这样会删除所有value相同的缓存，可能会误删不需要清除的数据。
- 方案二：手动调用删除缓存。
- 方案三：自定义批量删除缓存注解。
大部分场景下，使用某个固定属性值作为缓存时，增删改操作每次都要写key取某个值，非常繁琐。
- 方案一：自定义KeyGenerator。
高并发场景下如何确保数据的一致性和系统的稳定性？
- 方案一：在单体架构中，可以在构建CacheManager时指定RedisCacheWriter为lockingRedisCacheWriter，并在@CachePut和@CacheEvict中指定带锁的CacheManager。
- 方案二：在集群环境中，可以在@CachePut和@CacheEvict对应的方法上加分布式锁（如Redisson）。
如何防止缓存雪崩？
- 定义多个缓存管理器，每个管理器有不同的过期时间。
- 在方法上指定使用哪个缓存管理器。
如何防止缓存穿透？
- 缓存框架中允许缓存null，未找到的数据可以直接缓存空值。

统一修改前缀与定义key序列化

import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
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.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;import javax.annotation.Resource;
import java.time.Duration;/***redisCache配置** @author weiwenbin* @date 2025/03/11 下午5:15*/
@Configuration
@EnableCaching
@Slf4j
public class RedisCachingAutoConfiguration {@Resourceprivate RedisConnectionFactory redisConnectionFactory;@Beanpublic CacheManager defaultNoLockingCacheManager() {String keyPre = "hatzi";String directoryName = "cache";RedisCacheConfiguration configuration = getCacheConfiguration(Duration.ofHours(1), keyPre, directoryName);return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)).cacheDefaults(configuration).build();}/*** 缓存的异常处理*/@Beanpublic CacheErrorHandler errorHandler() {// 异常处理，当Redis发生异常时，打印日志，但是程序正常走log.info("初始化 -> [{}]", "Redis CacheErrorHandler");return new CacheErrorHandler() {@Overridepublic void handleCacheGetError(RuntimeException e, Cache cache, Object key) {log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);}@Overridepublic void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);}@Overridepublic void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);}@Overridepublic void handleCacheClearError(RuntimeException e, Cache cache) {log.error("Redis occur handleCacheClearError：", e);}};}public static RedisCacheConfiguration getCacheConfiguration(Duration duration, String keyPre, String directoryName) {RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(duration);/*** 默认CacheKeyPrefix 中分隔符为"::" 我想改成":" 所以这样写* 20250315放弃serializeKeysWith是因为自定义批量删除注解serializeKeysWith设置的前缀未生效*/configuration = configuration.computePrefixWith(cacheName -> {String pre = "";if (StrUtil.isNotBlank(keyPre)) {pre += keyPre + ":";}if (StrUtil.isNotBlank(directoryName)) {pre += directoryName + ":";}return pre + cacheName + ":";});return configuration;}
}

自定义KeyGenerator

@Component
@Slf4j
public class PkKeyGenerator implements KeyGenerator {@Override@Nonnullpublic Object generate(@Nonnull Object target, @Nonnull Method method, Object... params) {if (params.length == 0) {log.info("PkKeyGenerator key defaultKey");return "defaultKey";}for (Object param : params) {if (param == null) {continue;}if (param instanceof PkKeyGeneratorInterface) {PkKeyGeneratorInterface pkKeyGenerator = (PkKeyGeneratorInterface) param;String key = pkKeyGenerator.cachePkVal();if (StrUtil.isBlank(key)) {return "defaultKey";}log.info("PkKeyGenerator key :{}", key);return key;}}log.info("PkKeyGenerator key defaultKey");return "defaultKey";}
}

自定义接口

public interface PkKeyGeneratorInterface {String cachePkVal();
}

入参实现接口

public class SysTenantQueryDTO implements PkKeyGeneratorInterface, Serializable {private static final long serialVersionUID = 1L;@ApiModelProperty(value = "id")private Long id;@Overridepublic String cachePkVal() {return id.toString();}
}

注解中使用

@Cacheable(value = "sysTenant", keyGenerator = "pkKeyGenerator")
public SysTenantVO getVOInfoBy(SysTenantQueryDTO queryDTO) {// 业务代码
}

自定义注解批量删除

工具类

public class CacheDataUtils {/*** 批量键清除方法* 该方法用于从指定的缓存中清除一批键对应的缓存对象* 主要解决批量清除缓存的需求，提高缓存管理的灵活性和效率** @param cacheManager 缓存管理器，用于管理缓存* @param cacheName    缓存名称，用于指定需要操作的缓存* @param keys         需要清除的键集合，这些键对应的缓存对象将会被清除*/public static void batchEvict(CacheManager cacheManager, String cacheName, Collection<?> keys) {// 检查传入的键集合是否为空，如果为空则直接返回，避免不必要的操作if (CollUtil.isEmpty(keys)) {return;}// 获取指定名称的缓存对象Cache cache = cacheManager.getCache(cacheName);// 检查缓存对象是否存在，如果存在则逐个清除传入的键对应的缓存对象if (cache != null) {keys.forEach(cache::evict);}}
}

自定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BatchCacheEvict {/*** 目标缓存名称** @return String[]*/String[] cacheNames() default {};/*** 缓存键（SpEL表达式）** @return String*/String key();/*** 指定CacheManager Bean名称** @return String*/String cacheManager() default "";/*** 是否在方法执行前删除* 建议后置删除** @return boolean*/boolean beforeInvocation() default false;/*** 条件表达式（SpEL）** @return String*/String condition() default "";
}

切面编程

import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.hatzi.core.enums.SystemResultEnum;
import com.hatzi.core.exception.BaseException;
import com.hatzi.sys.cache.annotation.BatchCacheEvict;
import com.hatzi.sys.cache.util.CacheDataUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.cache.CacheManager;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Component;import java.util.Collection;/*** 批量清除缓存切面类* 用于处理带有 @BatchCacheEvict 注解的方法，进行缓存的批量清除操作** @author weiwenbin*/
@Aspect
@Component
@Slf4j
public class BatchCacheEvictAspect {// SpEL 解析器private final ExpressionParser parser = new SpelExpressionParser();// 参数名发现器（用于解析方法参数名）private final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();/*** 处理批量清除缓存的操作** @param joinPoint  切入点* @param batchEvict 批量清除缓存注解* @return 方法执行结果* @throws Throwable 可能抛出的异常*/@Around("@annotation(batchEvict)")public Object handleBatchEvict(ProceedingJoinPoint joinPoint, BatchCacheEvict batchEvict) throws Throwable {// 条件判断if (StrUtil.isNotBlank(batchEvict.condition()) && !isConditionPassed(joinPoint, batchEvict.condition())) {log.info("handleBatchEvict isConditionPassed is false");return joinPoint.proceed();}// 空值检查if (ArrayUtil.isEmpty(batchEvict.cacheNames()) || StrUtil.isEmpty(batchEvict.key())) {log.info("handleBatchEvict cacheNames or key is empty");return joinPoint.proceed();}// 前置删除if (batchEvict.beforeInvocation()) {evictCaches(joinPoint, batchEvict);}try {Object result = joinPoint.proceed();// 后置删除if (!batchEvict.beforeInvocation()) {evictCaches(joinPoint, batchEvict);}return result;} catch (Exception ex) {log.error(ex.getMessage());throw ex;}}/*** 执行缓存的批量清除操作** @param joinPoint  切入点* @param batchEvict 批量清除缓存注解*/private void evictCaches(ProceedingJoinPoint joinPoint, BatchCacheEvict batchEvict) {// 创建 SpEL 上下文EvaluationContext context = createEvaluationContext(joinPoint);String cachedManagerName = batchEvict.cacheManager();String keyExpr = batchEvict.key();String[] cacheNames = batchEvict.cacheNames();//获取缓存对象CacheManager cacheManager = getCacheManager(cachedManagerName);//解析key的值Object key = parser.parseExpression(keyExpr).getValue(context);if (!(key instanceof Collection)) {log.error("keyExpr 类型错误必须是Collection的子类");throw new BaseException(SystemResultEnum.INTERNAL_SERVER_ERROR);}for (String cacheName : cacheNames) {CacheDataUtils.batchEvict(cacheManager, cacheName, (Collection<?>) key);}}/*** 创建 SpEL 上下文** @param joinPoint 切入点* @return SpEL 上下文对象*/private EvaluationContext createEvaluationContext(ProceedingJoinPoint joinPoint) {MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 构建 SpEL 上下文（支持方法参数名解析）return new MethodBasedEvaluationContext(joinPoint.getTarget(),signature.getMethod(),joinPoint.getArgs(),parameterNameDiscoverer);}/*** 获取缓存管理器对象** @param cacheManagerName 缓存管理器名称* @return 缓存管理器对象*/private CacheManager getCacheManager(String cacheManagerName) {return StrUtil.isBlank(cacheManagerName) ?SpringUtil.getBean(CacheManager.class) :SpringUtil.getBean(cacheManagerName, CacheManager.class);}/*** 判断条件是否满足** @param joinPoint 切入点* @param condition 条件表达式* @return 是否满足条件*/private boolean isConditionPassed(ProceedingJoinPoint joinPoint, String condition) {return Boolean.TRUE.equals(parser.parseExpression(condition).getValue(createEvaluationContext(joinPoint), Boolean.class));}
}

使用

@Override
@Transactional(rollbackFor = {Exception.class})
@BatchCacheEvict(cacheNames = "sysTenant", key = "#idList")
public Boolean delByIds(List<Long> idList) {// 手动删除// CacheDataUtils.batchEvict(SpringUtil.getBean("defaultCacheManager", CacheManager.class),"sysTenant", idList);// 业务代码
}