SpringCache

2年前 (2022) 程序员胖胖胖虎阿

247 0 0

Spring 从3.1 开始定义了org.springframework.cache.Cache
和org.springframework.cache.CacheManager 接口来统一不同的缓存技术；
并支持使用JCache（JSR-107）注解简化我们开发；

Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合； Cache 接口下Spring 提供了各种xxxCache 的实现；
如RedisCache ， EhCacheCache , ConcurrentMapCache 等；

每次调用需要缓存功能的方法时，Spring 会检查检查指定参数的指定的目标方法是否已
经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓
存结果后返回给用户。下次调用直接从缓存中获取。

CacheManager 缓存管理器

public interface CacheManager {

	//根据缓存名字获取缓存
	@Nullable
	Cache getCache(String name);

	//获取管理的所有缓存的名字
	Collection<String> getCacheNames();

}

支持多种类型的缓存
SpringCache

整合SpringCache

<!--   引入spring-boot-starter-cache     -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

这里我们使用redis作为缓存

<!--    引入redis    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--   jedis不写版本springboot控制     -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

配置spring-boot-starter-cache

1.缓存的自动配置
CacheProperties封装了配置文件中可以配置的属性

@ConfigurationProperties(prefix = "spring.cache")
org.springframework.boot.autoconfigure.cache.CacheProperties

CacheConfiguration会根据缓存类型导入RedisCacheConfiguration

RedisCacheConfiguration自动配好了缓存管理器

@Bean
	public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
			ResourceLoader resourceLoader) {
		RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory)
				.cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
		List<String> cacheNames = this.cacheProperties.getCacheNames();
		if (!cacheNames.isEmpty()) {
			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
		}
		return this.customizerInvoker.customize(builder.build());
	}

手动配置

配置使用Redis作为缓存

  spring：
  	cache:
      #cache-names: 可以自动配置
      type: redis

测试使用缓存

常用注解
SpringCache

1.开启缓存功能 @Cacheable({"…"})

在启动类添加@EnableCaching 注解，不需要重复配Redis

@EnableCaching 注解

2.使用注解就能完成缓存操作

//每一个需要缓存的数据都需要指定要放到哪个名字的缓存，缓存的分区，按照业务类型分 
 @Cacheable({"categroy"})    //代表方法的结果需要缓存 ，如果缓存中有 方法都不用调用，如果缓存中没有，调用方法，将结果放入缓存
 @Override
 public List<CategoryEntity> getLevel1Categorys() {
     long l = System.currentTimeMillis();
     List<CategoryEntity> categoryEntityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
     System.out.println("消耗时间：" + (System.currentTimeMillis() - l));
     return categoryEntityList;
 }

使用@Cacheable 默认行为
如果缓存中有缓存方法都不用调用
key值自动生成
缓存的Value值默认使用JDK序列化机制，将序列化后的数据存到Redis
默认过期时间TTL -1 永不过去

应该要指定缓存存活时间 在配置文件中修改

  cache:
    #cache-names: 可以自动配置
    type: redis
    redis:
      time-to-live: 3600000  #设置存活时间毫秒
      key-prefix: CACHE_    #key前缀 如果制定了前缀就用指定的前缀，如果没有就默认使用缓存的名字作为前缀
      use-key-prefix: true  # 是否使用前缀
      cache-null-values: true # 是否缓存控制 解决缓存穿透

应该要指定缓存的Key 使用key属性接收SpEL表达式

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

@Cacheable(value = {"categroy"},key = "'name'")

SpEL语法
SpringCache

将数据保存为JSON格式

CacheConfiguration —> RedisCacheConfiguration —> 自动配置了RedisCacheManager —> 初始化所有的缓存 —> 每个缓存决定使用什么配置，配置有就用配置的，配置没有就用默认的（key的前缀等）—>想要修改配置只需要在容器中放一个RedisCacheConfiguration 即可 —> 这个容器就会应用到当前RedisCacheManager 管理的所有缓存分区中

package cn.cloud.xmall.product.config;


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;

/**
 * @Description: ···
 * @author: Freedom
 * @QQ: 1556507698
 * @date:2022/3/17 13:26
 */

@EnableCaching
@Configuration
public class MyCacheConfig {


    @Bean
    RedisCacheConfiguration redisCacheConfiguration(){

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

        //config = config.entryTtl();

        //key的序列化
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        //值的序列化
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        return config;
    };

}

问题：
配置文件中的东西没有用上
原因：
使用我们自己的配置不会从配置文件中取出来配置

package cn.cloud.xmall.product.config;


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;

/**
 * @Description: ···
 * @author: Freedom
 * @QQ: 1556507698
 * @date:2022/3/17 13:26
 */

@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class MyCacheConfig {

    // @Autowired
    // public CacheProperties cacheProperties;

    /**
     * 配置文件的配置没有用上
     * @return
     */
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // config = config.entryTtl();
        //设置Key的序列化方式
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        //设置值的序列化方式
        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.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;
    }

}

从缓存中删除数据 @CacheEvict 失效模式

 @CacheEvict(value = "category",key = "'getLevel1Categorys'")

分区value和key必须相同才可以删除

问题：
如果一个修改需要删除两个缓存？如何删除？
@CaChing 组合操作，同时进行多个缓存操作

    @Caching(evict = {
            @CacheEvict(value = "category",key = "'getLevel1Categorys'"),
            @CacheEvict(value = "category",key = "'getCatalogJson'")
    })
    @Transactional
    @Override
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        //更新关联表
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
    }

成功删除

第二种方式：
删除指定分区下所有的缓存，存储统一个类型的数据可以指定为同一个分区，分区名默认就是缓存前缀

@CacheEvict(value = {"category"},allEntries = true)

推荐使用@CaChing

@CaChePut 双写模式使用此注解（解决分布式缓存一致性问题）

Spring-Cache不足

读模式

缓存穿透：查询一个null数据
解决：缓存null数据，并设置短暂过期时间，
cache-null-values: true # 是否缓存控制解决缓存穿透, springcache解决方案

缓存击穿：大量并发进来同时查询一个正好过期的数据
解决：加锁？？？
默认情况下是没有加锁的
1.手写添加缓存方法使用Redisson作为分布式锁
2.@Cacheable(value = {“categroy”},key = “#root.method.name”,sync = true)，sync只有Cacheable有这个属性
会进入加锁的方法