缓存常见问题+spring cache使用
缓存问题：
1.缓存穿透：客户查不存在的数据，那么就不会经过缓存，查完值为null，不会把值保存到缓存中，下次查还是查数据库
2.缓存雪崩：多个缓存同时过期，刚好过期的时刻有大量请求，请求不经缓存，数据库压力过大奔溃
3.缓存击穿：大量请求访问同一资源，刚好缓存过期，大量请求经数据库，压力过大
4.缓存一致性：请求修改了数据库，缓存还是原数据
解决办法：
1、解决缓存穿透：空结果缓存，这样就不会一直访问数据库了
2、解决缓存雪崩：设置过期时间（加随机值)，1~5分钟，不会造成缓存大面积过期
3、解决缓存击穿：加锁，只让一人访问数据库，得到的结果放缓存，其他人访问缓存
4、解决缓存一致性：大部分修改较少的业务，设置过期时间即可，少部分加读写锁 或者 cannal订阅binlog【数据库一修改，就让缓存同步修改】
也可以选择采用两种模式：双写模式（修改数据库之后修改缓存），失效模式（修改数据库之后让缓存失效）
【但也有问题，双写模式：如果先修改的修改慢，后修改的修改快，缓存先经过后面修改的再经过前面修改的，导致缓存只被前者修改。
失效模式：第一次修改，把缓存删除。第二次修改，修改速度慢，还没改完数据库就有读的请求过来。这个请求获取到的是第一次修改后的数据。这时第二次修改把缓存失效，读的请求把数据写入缓存，缓存仍然是第一次修改的。
可以延迟几百毫秒，再写入redis中，那么上面的问题就可以解决！
所以，要么加锁，要么不用缓存，但是加锁的效率很低，还不如直接查数据库】
我们系统的一致性解决方案：
1、缓存的所有数据都有过期时间，数据过期下一次查询触发主动更新
2、读写数据的时候，加上分布式的读写锁。
【面试题答案】
spring cache
sring cashe对缓存各种问题的解决：
1.缓存穿透：查询一个nulL数据。解决：缓存空数据；【配置：spring.cache.redis.cache-null-values=true】
2.缓存击穿：大量并发进来同时查询一个正好过期的数据。解决：加锁；【默认不加。可以用：@Cacheable(value = {“”} , key = “”,sync = true)】【前面加本地锁】
3.缓存雪崩：大量的key同时过期。解决：加随机时间。其实加上过期时间就足够了。【配置：spring.cache.redis.time-to-live=3600000】
默认行为：
1.如果缓存中没有，不会调用方法
2.默认生成的key结构： 缓存分区的名字：：simpleKey[] （自主生成的key值）【如果指定了前缀，那么就不会用缓存分区的名字，而是用前缀】
【最好不用前缀】
3.缓存的key值：默认使用jdk序列化机制，将序列化后的数据存到redis（不是json格式）
4.默认ttl时间：-1 （永远不过期）
自定义：
1.指定缓存用的key：key属性指定，使用spel表达式，如：
@Cacheable(value = {“category”} , key = “‘aaa’”) 字符串需要用单引号圈起来，redis中的key为：category：：aaa
@Cacheable(value = {“category”} , key = “#root.methodName”) 使用方法名作为key
2.指定缓存的存活时间：配置文件：
spring.cache.redis.time-to-live=3600000 单位毫秒
3.将数据保存为json格式：
加配置类
导入spring cache 和 redis 依赖
org.springframework.boot
spring-boot-starter-cache
org.springframework.boot
spring-boot-starter-data-redis
写配置文件
# 缓存类型
spring.cache.type=redis
# 缓存过期时间
spring.cache.redis.time-to-live=3600000
# 前缀，便于与redis中存的其他东西区分 【如果指定了前缀，那么就不会用缓存分区的名字，而是用前缀】
# spring.cache.redis.key-prefix=CACHE_
# 是否使用前缀 默认true
# spring.cache.redis.use-key-prefix=true
# 是否缓存空值，防止缓存击穿
spring.cache.redis.cache-null-values=true
# redis配置
spring.redis.host=192.168.190.150
spring.redis.port=6379
缓存配置类
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
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.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
// 绑定配置文件？
@EnableConfigurationProperties(CacheProperties.class)
@Configuration
// 开启缓存注解
@EnableCaching
public class MyCacheConfig {
@Bean
// 可以直接通过参数传入配置类
RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
// key还是用jdk字符串存
config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
// value用json字符串
config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
// 将配置文件中的所有配置生效
CacheProperties.Redis redisProperties = cacheProperties.getRedis();
if (redisProperties.getTimeToLive() != null) {
config = config.entryTtl(redisProperties.getTimeToLive());
}
if (redisProperties.getKeyPrefix() != null) {
config = config.prefixCacheNameWith(redisProperties.getKeyPrefix());
}
if (!redisProperties.isCacheNullValues()) {
config = config.disableCachingNullValues();
}
if (!redisProperties.isUseKeyPrefix()) {
config = config.disableKeyPrefix();
}
return config;
}
}
使用缓存
@Cacheable:Triggers cache population.,:触发将数据保存到缓存的操作
@CacheEvict:Triggers cache eviction,:触发将数据从缓存删除的操作【配合上一个，配在写方法上，失效模式】
@CachePut:Updates the cache without interfering with the method execution,:不影响方法执行更新鍰存【配合上一个，配在写方法上，双写模式】
@Caching:Regroups multiple cache operations to beapplied on a method.:组合以上多个操作
@CacheConfig:Shares some common cache-relatedings at class-Level,:在类级别共享缓存的相同配置
大坑！！！：http://t.csdn.cn/ovrrk
类调用本类加缓存的方法不走缓存！！！、
解决办法：
0）、导入 spring-boot-starter-aop 依赖
org.springframework.boot
spring-boot-starter-aop
1）、启动类加注解：
@EnableTransactionManagement(proxyTargetClass = true)
@EnableAspectJAutoProxy(exposeProxy=true)
3）、使用 AopContext.currentProxy() 生成当前类的代理对象，再调用本类方法
ProductServiceIml o = (ProductServiceIml)AopContext.currentProxy ();
o.getFirPageProductVo (1,pageSize);
@Cacheable
// 每一个需要缓存数据我们都要指定放到哪个分区【按照业务类型分】
//代表当前的方法需要缓存。如果有缓存则不进行操作，没有缓存，会调用方法，将结果放到缓存中
// 可以写多个分区的名字，表示在这些分区都缓存一份
@Cacheable(value = {"category"} , key = "#root.methodName")
@Override
public List getLevel1Categorys() {
List selectList = baseMapper.selectList(new QueryWrapper().eq("parent_cid",0));
return selectList;
}
加本地锁，解决缓存击穿 【sync = true】
@Cacheable(value = {"category"} , key = "#root.Method",sync = true)
@CacheEvict 【配合上面那个，构成失效模式】【要注意有没有加前缀，没测试这种情况】
@CacheEvict(value = {"category"} , key = "'getLevel1Categorys'") // 注意字符串要加单引号
@Transactional
@Override
public void updateCascade(CategoryEntity category) {
this.updateById(category);
categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
}
（删除整个缓存分区下的数据）
@CacheEvict(value = {"category"} , allEntries = true)
@Caching 【批量操作】
@Caching(evict = {
@CacheEvict(value = {"category"} , key = "'getLevel1Categorys'"),
@CacheEvict(value = {"category"} , key = "'getDataFromDb'")
})
@Transactional
@Override
public void updateCascade(CategoryEntity category) {
this.updateById(category);
categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
}
自定义缓存注解【可能是spring cache的简单实现】
定义注解
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Cache {
long expire() default 1*60*1000;
// 缓存标志 key
String name() default "";
}
注解aop实现
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xxxx.blog.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.time.Duration;
//aop 定义一个切面，切面定义了切点和通知的关系
@Aspect
@Component
@Slf4j
public class CacheAspect {
private static final ObjectMapper objectMapper = new ObjectMapper();
@Autowired
private RedisTemplate redisTemplate;
@Pointcut("@annotation(com.xxxx.blog.common.cache.Cache)")
public void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp){
try {
Signature signature = pjp.getSignature();
//类名
String className = pjp.getTarget().getClass().getSimpleName();
//调用的方法名
String methodName = signature.getName();
Class[] parameterTypes = new Class[pjp.getArgs().length];
Object[] args = pjp.getArgs();
//参数
String params = "";
for(int i=0; i 使用缓存
// redis缓存
@Cache(expire = 5 * 60 * 1000,name = "listArticle")
public Result listArticle(@RequestBody PageParams params){
return articleService.listArticle(params);
}