Spring Cache和redis结合使用

1 、简介
Spring 定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术,并支持使用注解简化我们开发;
Cache 接口为缓存的组件规范定义,包含缓存的各种操作集合;
Cache 接 口 下 Spring 提 供 了 各 种 xxxCache 的 实 现 ; 如 RedisCache EhCacheCache , ConcurrentMapCache 等;
每次调用需要缓存功能的方法时, Spring 会检查检查指定参数的指定的目标方法是否已经被调用过;如果有就直接从缓存中获取方法调用后的结果,如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。
使用 Spring 缓存抽象时需要关注以下两点:确定方法需要被缓存以及他们的缓存策略,从缓存中读取之前缓存存储的数据。
2、相关操作
2.1引入相关依赖
        
            org.springframework.boot
            spring-boot-starter-cache
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        

2.2配置文件application.properties

#名字可以自动配置
#spring.cache.cache-names=qq
spring.cache.type=redis
#设定数据存活时间1小时
spring.cache.redis.time-to-live=3600000
#key的前缀
spring.cache.redis.key-prefix=CACHE_
#key是否用前缀
spring.cache.redis.use-key-prefix=false
#是否缓存空值,防止缓存穿透
spring.cache.redis.cache-null-values=true

2.3自行配置RedisCacheConfiguration(如果不配置需要将@EnableCaching放到启动类上)

package com.atguigu.gulimall.product.config;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
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.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用string类型保存,value用json格式保存
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericFastJsonRedisSerializer()));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        //使配置文件中所有的配置都生效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;
    }
}

2.4使用注解操作

    /**
     * 每一个需要缓存的数据都要指定要放到哪个名字的缓存。【缓存的分区(按照业务类型分)】
     * 代表当前方法的结果需要缓存,如果缓存中有,方法不会调用,如果缓存中没有,会调用方法。并将方法的结果放入缓存
     * 默认行为
     *      1)如果缓存中有,方法不再调用
     *      2)key是默认生成的:缓存的名字::SimpleKey::[](自动生成key值)
     *      3)缓存的value值,默认使用jdk序列化机制,将序列化的数据存到redis中
     *      4)默认ttl时间是 -1:
     *
     *   用户自行操作:key的生成
     *      1)指定生成缓存的key:key属性可以指定,接收一个Spel
     *      2)指定缓存的数据的存活时间:配置文档中修改存活时间
     *      3)将数据保存为json格式
     *          CacheAutoConfiguration->RedisCacheConfiguration->自动配置了RedisCacheManager->初始化所有的缓存
     *          -》每个缓存决定使用什么配置->如果redisCacheConfiguration有就用已有的,没有就用默认的配置->想改缓存配置,只需给容器
     *          中放一个RedisCacheConfiguration即可->就会应用到当前RedisCacheManager管理的所有缓存分区中
     *
     */
    @Cacheable(value={"category"},key="#root.method.name",sync = true)
    @Override
    public List getLevel1Categorys() {
        return this.baseMapper.selectList(new QueryWrapper().eq("parent_cid",0));
    }

2.5访问redis数据库

Spring Cache和redis结合使用_第1张图片

2.6再添加两个方法

    @Cacheable(value = "category",key="#root.methodName")
    @Override
    public Map> getCatelogJson() {
        //业务操作。。。
    }
    //多项操作时用@Caching
    @Caching(evict = {
            @CacheEvict(value = "category",key="'getLevelCategorys'"),
            @CacheEvict(value = "category",key="'getCatelogJson'")
    })
    @Transactional
    @Override
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        System.out.println(category.getCatId());
        System.out.println(category.getName());
        categoryBrandRelationService.updateCatelog(category.getCatId(),category.getName());
    }

2.7运行测试

先执行getLevel1Categorys()和getCatelogJson()两个方法,可以看到redis数据库里存了它们缓存的数据

Spring Cache和redis结合使用_第2张图片

接着运行 updateCascade()方法,则数据消失了。@Caching可同时进行多项操作,@CacheEvict可以删除指定的缓存。

补充:将

@Caching(evict = {
        @CacheEvict(value = "category",key="'getLevelCategorys'"),
        @CacheEvict(value = "category",key="'getCatelogJson'")
})

替换成

@CacheEvict(value = "category",allEntries = true) //删除某个分区下的所有数据

可以获得同样的效果。

同时,将配置文件替换成:

#名字可以自动配置
#spring.cache.cache-names=qq
spring.cache.type=redis
#设定数据存活时间1小时
spring.cache.redis.time-to-live=3600000
#key的前缀
#spring.cache.redis.key-prefix=CACHE_
#key是否用前缀
spring.cache.redis.use-key-prefix=true
#是否缓存空值,防止缓存穿透
spring.cache.redis.cache-null-values=true

执行执行getLevel1Categorys()和getCatelogJson()两个方法,可以看到数据库里两个缓存数据归类到category下面:

Spring Cache和redis结合使用_第3张图片

 3、SpringCache的不足之处

1)、读模式
缓存穿透:查询一个null数据。解决方案:缓存空数据。

spring.cache.redis.cache-null-values=true

缓存击穿:大量并发进来同时查询一个正好过期的数据。解决方案:加锁 ? 默认是无加锁的;使用sync = true来解决击穿问题。

@Cacheable(value={"category"},key="#root.method.name",sync = true)

缓存雪崩:大量的key同时过期。解决:加随机时间。加上过期时间。

spring.cache.redis.time-to-live=3600000

2)、写模式:(缓存与数据库一致)
读写加锁。
引入Canal,感知到MySQL的更新去更新Redis
读多写多,直接去数据库查询就行

4、总结

常规数据(读多写少,即时性,一致性要求不高的数据,完全可以使用Spring-Cache):写模式(只要缓存的数据有过期时间就足够了)

原理:CacheManager(RedisCacheManager)->Cache(RedisCache)->Cache负责缓存的读写

你可能感兴趣的:(spring,java,缓存,redis)