每一秒钟的时间都值得铭记

0%

SpringBoot Cache 整合 Redis 缓存框架

发表于 分类于
本文字数： 4.5k 阅读时长 ≈ 4 分钟

SpringBoot 提供了 SpringBootCache 框架作为 SpringBoot 的缓存统一框架，使用 SpringBootCache ，我们可以使用注解的方式使用缓存，从而避免了写一些重复代码的问题。

引入依赖

首先我们需要引入相关的依赖，Cache 是缓存框架的核心依赖，不过该框架只提供了各种操作的接口集合，并没有具体的实现。

而接口之外，SpringBoot 提供了各种具体的实现，比如：RedisCache,EhCache,ConcurrentMapCache等等。

Redis 依赖是为了使用 Redis 作为缓存而引入的，如果不使用 Redis 作为缓存，也可以将 Redis 的依赖替换为其他实现。

Jackson 是作为序列化工具。

  • Maven
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>
  • Gradle
1
2
3
4
5
6
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-cache:2.7.3'
    implementation 'org.springframework.boot:spring-boot-starter-data-redis:2.7.3'
    implementation 'org.springframework.boot:spring-boot-starter-test:2.7.3'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'
}

配置 Redis

因为我们引入了 SpringBootRedis 的依赖，Spring 会默认使用 Redis 作为我们的缓存，所以需要配置 Redis 的信息。

  • application.yaml
1
2
3
4
spring:
  redis:
    host: 127.0.0.1
    port: 6379
  • RedisCacheManager
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    @Configuration
    public class RedisCacheConfig {

        @Bean
        public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            // 使用缓存的默认配置
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            // 使用 GenericJackson2JsonRedisSerializer 作为序列化器
            config = config.serializeValuesWith(
                    RedisSerializationContext.SerializationPair.fromSerializer(
                            new GenericJackson2JsonRedisSerializer()));
            RedisCacheManager.RedisCacheManagerBuilder builder =
                    RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config);
            return builder.build();
        }
    }

启动类注解

使用 SpringBootCache 作为缓存框架，我们需要在 SpringBoot 的启动类上添加 @EnableCaching 注解，这样才能够启用缓存框架。

1
2
3
4
5
6
7
@EnableCaching
@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

注解开发

我们只需要在方法上面添加相关的注解，即可使用缓存逻辑，从而提升服务性能。

@Cacheable

该注解可以注解在方法和类上，当被注解的类下的方法或者被注解的方法被调用时，会先去缓存中查看是否有缓存数据，有缓存数据则直接返回缓存数据，无缓存数据则调用该方法，获取该方法的返回值，并将该返回值存入缓存中。

@CachePut

该注解可以注解在方法和类上，当被注解的类下的方法或者被注解的方法被调用时，不管缓存中是否有对应的缓存数据，都会将该方法的返回值更新（插入或覆盖）到缓存中。

@CacheEvict

该注解可以注解在方法和类上，当被注解的类下的方法或者被注解的方法被调用时，会直接删除缓存中的缓存数据。

注解属性

@Cacheable,@CachePut,@CacheEvict三个注解都有一些属性。

cacheNames/value

用来指定缓存组件的名字。

1
2
3
4
@Cacheable(cacheNames = "user")
public User selectById(Integer id) {
	return new User(id);
}

key

缓存数据时使用的 key，可以用它来指定。默认是使用方法参数的值。（这个 key 你必须使用 spEL 表达式来编写）

1
2
3
4
@Cacheable(cacheNames = "user", key = "#id")
public User selectById(Integer id) {
    return new User(id);
}

使用以上的配置，如果入参的 id 值为 1，Redis 会存入一个 key 为 user::1 数据。

1
2
3
4
@Cacheable(cacheNames = "user", key = "#root.methodName")
public User selectById(Integer id) {
    return new User(id);
}

使用以上的配置，如果入参的 id 值为 1，Redis 会存入一个 key 为 user::selectById 数据。

keyGenerator

key 的生成器。 key 和 keyGenerator 二选一使用。

1
2
3
4
@Bean
public KeyGenerator keyGenerator() {
    return (target, method, params) -> Arrays.asList(params).toString();
}

使用以上的配置，如果入参的 id 值为 1，Redis 会存入一个 key 为 user::[1] 数据。

condition

可以用来指定符合条件的情况下才缓存。

1
2
3
4
@Cacheable(cacheNames = "user", key = "#id", condition = "#id > 1")
public User selectById(Integer id) {
    return new User(id);
}

unless

否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。当然你也可以获取到结果进行判断。（通过 #result 获取方法结果）

该属性相当于!condition 属性。

1
2
3
4
@Cacheable(cacheNames = "user", key = "#id", unless = "#id > 1")
public User selectById(Integer id) {
    return new User(id);
}

cacheManager

可以用来指定缓存管理器。从哪个缓存管理器里面获取缓存。

sync

是否使用异步模式。

SpEL 表达式

名字 位置 描述 示例
methodName root object 当前被调用的方法名 #root.methodName
method root object 当前被调用的方法 #root.method.name
target root object 当前被调用的目标对象 #root.target
targetClass root object 当前被调用的目标对象类 #root.targetClass
args root object 当前被调用的方法的参数列表 #root.args[0]
caches root object 当前方法调用使用的缓存列表(如 @Cacheable(value=[“cache1”,”cache2J)，则有两个 cache) #root.caches[0].name
argument name evaluation context 方法参数的名字，可以直接使用 #参数名，也可以使用 #p0 或 #a0 的形式，0代表参数的索引。 #a0
result evaluation context 方法执行后的返回值 (仅当方法执行后的判断有效) #result
坚持原创技术分享，您的支持将鼓励我继续创作！
-------------这是我的底线^_^-------------