SpringBoot 缓存 – Redis

引入依赖

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

缓存配置

spring:  
  redis:    # 配置REDIS 信息
    host: 127.0.0.1  # 配置 redis host
    port: 6379  # 配置 redis 端口
    lettuce:   # 配置 lettuce 连接池
      pool:
        max-active: 10   # 最大连接数
        max-idle: 10   # 连接池最大空闲连接
        min-idle: 1  # 连接池最小空闲连接
  cache:
    type: REDIS   # 配置缓存使用redis

启用缓存

修改项目启动类，增加注解@EnableCaching，开启缓存功能，如下：

@SpringBootApplication
@EnableCaching
public class CacheApplication {
		
  	@Bean
    public static void main(String[] args) {
        SpringApplication.run(CacheApplication.class, args);
    }

}

配置缓存类

新建Redis缓存配置类RedisConfig，如下：

@Configuration
public class RedisConfig {
		
    // 缓存管理器
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory){
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        return RedisCacheManager.builder(factory).cacheDefaults(redisCacheConfiguration).build();
    }
}

添加缓存@Cacheable

@Cacheable注解会先查询是否已经有缓存，有会使用缓存，没有则会执行方法并将结果进行缓存。案例如下：

@Cacheable(value = "student", key = "#id")  // 设置缓存
public Student getById(Long id) {
    Student student = studentMapper.selectById(id);
    return student;
}

然后我们可以到Redis客户端中查看是否缓存数据成功到Redis中，如下：

根据Redis中存储的数据，说明缓存信息已经成功存进了redis中。

@Cacheable解析

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {

    // 为缓存进行命名，类似于命名空间，与value二选一
    @AliasFor("cacheNames")
    String[] value() default {};

    // 为缓存进行命名，类似于命名空间，与cacheNames二选一
    @AliasFor("value")
    String[] cacheNames() default {};

    // key的生成器，为缓存指定一个主键，后续可根据主键进行操作,可以为空，如果指定要按照 		// SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
    String key() default "";

		// key的生成器，为缓存指定一个主键，后续可根据主键进行操作
    String keyGenerator() default "";

    // 指定缓存管理器
    String cacheManager() default "";
    
    // 指定缓存获取解析器
    String cacheResolver() default "";

    // 条件判定，如果条件为真则进行缓存
    String condition() default "";
    
    // 条件判定，条件符合则不缓存
    String unless() default "";
    
    // 是否使用异步模式
    boolean sync() default false;
}

缓存更新@CachePut

@CachePut注解的作用主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用。简单来说就是用户更新缓存数据。但需要注意的是该注解的value 和 key 必须与要更新的缓存相同，也就是与@Cacheable 相同。

@CachePut(value = "student", key = "#student.id")  // 更新缓存
public Student updateStudent(Student student) {
   studentMapper.updateById(student);
   return student;
}

@CachePut解析

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CachePut {
  
    // 为缓存进行命名，类似于命名空间，与value二选一
    @AliasFor("cacheNames")
    String[] value() default {};

    // 为缓存进行命名，类似于命名空间，与cacheNames二选一
    @AliasFor("value")
    String[] cacheNames() default {};

    // key的生成器，为缓存指定一个主键，后续可根据主键进行操作,可以为空，如果指定要按照    SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
    String key() default "";

    // key的生成器，为缓存指定一个主键，后续可根据主键进行操作
    String keyGenerator() default "";

   // 指定缓存管理器
    String cacheManager() default "";
    
    // 指定缓存获取解析器
    String cacheResolver() default "";
  
    // 条件判定，如果条件为真则进行缓存
    String condition() default "";

    // 条件判定，条件符合则不缓存
    String unless() default "";
}

缓存清除@CacheEvict

@CachEvict 的作用主要针对方法配置，能够根据一定的条件对缓存进行清空。

// 清除一条缓存，key为要清空的数据
@CacheEvict(value = "student", key = "#id")
public void delStudent(Long id){
  System.out.println("进行缓存清除操作");
}

//方法调用前清空所有缓存
@CacheEvict(value = "student", beforeInvocation = true)
public void delBefore() {
  System.out.println("方法调用前清空所有缓存");
}

//方法调用后清空所有缓存
@CacheEvict(value = "student", allEntries = true)
public void delAfter() {
  System.out.println("方法调用后清空所有缓存");
}

@CacheEvict解析

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheEvict {
  
    // 为缓存进行命名，类似于命名空间，与cacheNames二选一
    @AliasFor("cacheNames")
    String[] value() default {};
  
    // 为缓存进行命名，类似于命名空间，与value二选一
    @AliasFor("value")
    String[] cacheNames() default {};

  	// key的生成器，为缓存指定一个主键，后续可根据主键进行操作,可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合
    String key() default "";

    // key的生成器，为缓存指定一个主键，后续可根据主键进行操作
    String keyGenerator() default "";

    // 指定缓存管理器
    String cacheManager() default "";

    // 指定缓存获取解析器
    String cacheResolver() default "";
  
    // 条件判定，如果条件为真则进行缓存
    String condition() default "";

    // 是否清空所有缓存，默认为false，如果指定为true，则在方法调用后将立即清空所有缓存
    boolean allEntries() default false;
    
    // 是否在方法执行前就清空，默认为false，如果指定为true
    boolean beforeInvocation() default false;
}

@CacheConfig 配置

当我们需要缓存的地方越来越多，你可以使用@CacheConfig(cacheNames = {"myCache"})注解来统一指定value的值，这时可省略value，如果你在你的方法依旧写上了value，那么依然以方法的value值为准。

@Service
@CacheConfig(cacheNames = {"student"})
public class CacheServiceImpl implements CacheService {


    @Resource
    private StudentMapper studentMapper;

    @Override
    @Cacheable(key = "#id")  // 设置缓存，此时没有设置value值
    public Student getById(Long id) {
        Student student = studentMapper.selectById(id);
        return student;
    }
}

@CacheConfig解析

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheConfig {
  
    // 为缓存进行命名，类似于命名空间
    String[] cacheNames() default {};

    // key生成器
    String keyGenerator() default "";

    // 指定缓存管理器
    String cacheManager() default "";

    // 指定缓存获取解析器
    String cacheResolver() default "";
}

组合@Caching

有时候我们可能组合多个Cache注解使用，此时就需要@Caching组合多个注解标签了。

@Caching(
    cacheable = {
      @Cacheable(value = "student", key = "#id")
    },
    put = {
      @CachePut(value = "student", key="#id")
    },
    evict = {
      @CacheEvict(value = "student", key="#id")
    }
)
public Student cacheGroup(Long id) {
  return null;
}

原创文章，作者：jiafegn，如若转载，请注明出处：https://www.techlearn.cn/archives/502