Spring+Redis:缓存

发布于 2021-08-27  1536 次阅读

一、Spring Cache 注解

1. @EnableCaching 做了什么

@EnableCaching 注释触发后置处理器, 检查每一个Spring bean 的 public 方法是否存在缓存注解。如果找到这样的一个注释, 自动创建一个代理拦截方法调用和处理相应的缓存行为。

2. 常用缓存注解简述

2.1 @Cacheable

将方法的结果缓存，必须要指定一个 cacheName（缓存空间）

@Cacheable("books")
public Book findBook(ISBN isbn) {...}

默认 cache key

缓存的本质还是以 key-value 的形式存储的，默认情况下我们不指定key的时候 ，使用 SimpleKeyGenerator 作为key的生成策略

  • 如果没有给出参数，则返回SimpleKey.EMPTY。
  • 如果只给出一个Param，则返回该实例。
  • 如果给出了更多的Param，则返回包含所有参数的SimpleKey。

注意：当使用默认策略时，我们的参数需要有 有效的hashCode()和equals()方法

自定义 cache key

@Cacheable(cacheNames="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@Cacheable(cacheNames="books", key="#isbn.rawNumber")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

如上，配合Spring EL 使用，下文会详细介绍 Spring EL 对 Cache 的支持

  • 指定对象
  • 指定对象中的属性
  • 某个类的某个静态方法

自定义 keyGenerator

@Cacheable(cacheNames="books", keyGenerator="myKeyGenerator")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

实现 KeyGenerator接口可以自定义 cache key 的生成策略

自定义 cacheManager

@Cacheable(cacheNames="books", cacheManager="anotherCacheManager") 
public Book findBook(ISBN isbn) {...}

当我们的项目包含多个缓存管理器时，可以指定具体的缓存管理器，作为缓存解析

同步缓存

在多线程环境中，可能会出现相同的参数的请求并发调用方法的操作，默认情况下，spring cache 不会锁定任何东西，相同的值可能会被计算几次，这就违背了缓存的目的

对于这些特殊情况，可以使用sync属性。此时只有一个线程在处于计算，而其他线程则被阻塞，直到在缓存中更新条目为止。

@Cacheable(cacheNames="foos", sync=true) 
public Foo executeExpensiveOperation(String id) {...}

条件缓存

  • condition: 什么情况缓存，condition = true 时缓存，反之不缓存
  • unless: 什么情况不缓存，unless = true 时不缓存，反之缓存

@Cacheable(cacheNames="book", condition="#name.length() < 32") 
public Book findBook(String name)


@Cacheable(cacheNames="book", condition="#name.length() < 32", unless="#result?.hardback")
public Optional<Book> findBook(String name)

Spring EL 对 Cache 的支持

NameLocationDescriptionExample
methodNameRoot object被调用的方法的名称#root.methodName
methodRoot object被调用的方法#root.method.name
targetRoot object当前调用方法的对象#root.target
targetClassRoot object当前调用方法的类#root.targetClass
argsRoot object当前方法的参数#root.args[0]
cachesRoot object当前方法的缓存集合#root.caches[0].name
Argument nameEvaluation context当前方法的参数名称#iban or #a0 (you can also use #p0 or #p<#arg> notation as an alias).
resultEvaluation context方法返回的结果(要缓存的值)。只有在 unless 、@CachePut(用于计算键)或@CacheEvict(beforeInvocation=false)中才可用.对于支持的包装器(例如Optional)，#result引用的是实际对象，而不是包装器#result

2.2 @CachePut

这个注解和 @Cacheable 有点类似，都会将结果缓存，但是标记 @CachePut 的方法每次都会执行，目的在于更新缓存，所以两个注解的使用场景完全不同。@Cacheable 支持的所有配置选项，同样适用于@CachePut

@CachePut(cacheNames="book", key="#isbn")
public Book updateBook(ISBN isbn, BookDescriptor descriptor)
  • 需要注意的是，不要在一个方法上同时使用@Cacheable 和 @CachePut

2.3 @CacheEvict

用于移除缓存

  • 可以移除指定key
  • 声明 allEntries=true移除该CacheName下所有缓存
  • 声明beforeInvocation=true 在方法执行之前清除缓存，无论方法执行是否成功

@CacheEvict(cacheNames="book", key="#isbn")
public Book updateBook(ISBN isbn, BookDescriptor descriptor)


@CacheEvict(cacheNames="books", allEntries=true) 
public void loadBooks(InputStream batch)

2.4 @Caching

可以让你在一个方法上嵌套多个相同的Cache 注解（@Cacheable, @CachePut, @CacheEvict），分别指定不同的条件

@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
public Book importBooks(String deposit, Date date)

2.5 @CacheConfig

类级别注解，用于配置一些共同的选项（当方法注解声明的时候会被覆盖），例如 CacheName。

支持的选项如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheConfig {
    String[] cacheNames() default {};

    String keyGenerator() default "";

    String cacheManager() default "";

    String cacheResolver() default "";
}

二 、Spring 整合Redis

配置文件

#服务器端口
server.port=8083
#redis的ip端口密码
spring.redis.host=192.168.0.100
spring.redis.password=密码
spring.redis.port=6379
#告知spring不用本低缓存，使用redis缓存
spring.cache.type=redis
#redis的过期时间 在配置文件中配置后无效
spring.cache.redis.time-to-live=600000
#redis是否存储空值在配置文件中配置后无效
spring.cache.redis.cache-null-values=false

maven

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Redis配置文件

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /***
     * @Author 魏鹏 MAOSI-AMOR
     * @Description //RedisTemplate的配置
     * @Date 11:10 2021-08-27
     * @Param [factory]
     * @return org.springframework.data.redis.core.RedisTemplate<java.lang.String,java.lang.Object>
     **/
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer());
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    /***
     * @Author 魏鹏 MAOSI-AMOR
     * @Description //缓存管理器
     * @Date 11:11 2021-08-27
     * @Param [connectionFactory]
     * @return org.springframework.cache.CacheManager
     **/
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        //生成一个默认配置，通过config对象即可对缓存进行自定义配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        config = config
                // 设置 key为string序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value为json序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer() ))
                // 不缓存空值
                .disableCachingNullValues()
                // 设置缓存的默认过期时间 30分钟
                .entryTtl(Duration.ofMinutes(30L));

        //特殊缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> map = new HashMap<>();
        map.put("cacheNames1", config.entryTtl(Duration.ofMinutes(30L)));//cacheNames1缓存空间过期时间 30分钟
        map.put("cacheNames2", config.entryTtl(Duration.ofHours(1L)));//cacheNames2缓存空间过期时间 1小时

        //使用自定义的缓存配置初始化一个RedisCacheManager
        RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config) //默认配置
                .withInitialCacheConfigurations(map) //特殊缓存
                .transactionAware() //事务
                .build();

        return cacheManager;
    }

    /***
     * @Author 魏鹏 MAOSI-AMOR
     * @Description //json序列化
     * @Date 11:10 2021-08-27
     * @Param []
     * @return org.springframework.data.redis.serializer.RedisSerializer<java.lang.Object>
     **/
    public RedisSerializer<Object> jackson2JsonRedisSerializer() {
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        return serializer;
    }
}

注解

@EnableCaching
@Cacheable(cacheNames="redisCache",key = "'redisKey'+#id")

使用RestTemplate
//设置数据
redisTemplate.opsForValue().set("key","缓存方法返回值3", Duration.ofMinutes(30));

//获取数据
Long key = redisTemplate.getExpire("key");
System.out.println("剩余时间："+ key);

Github地址：https://github.com/MSamor/Springboot-Redis-Demo

参考：

注解详解：https://xie.infoq.cn/article/001e0f5ab65fa7dd1484c51e5

欢迎欢迎~热烈欢迎~