SpringBoot通过CacheManager集成redis做缓存

# SpringBoot通过CacheManager集成redis做缓存

SpringBoot如何通过 CacheManager 集成 redis做缓存

SpringBoot在annotation的层面实现了数据缓存的功能，基于Spring的AOP技术。所有的缓存配置只是在annotation层面配置，像声明式事务一样。

Spring定义了CacheManager 和Cache接口统一不同的缓存技术。其中CacheManager 是Spring提供的各种缓存技术的抽象接口。而Cache接口包含缓存的各种操作。

# 1. 添加依赖

引入springboot-cache和 spring-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>

1
2
3
4
5
6
7
8
9
10

# 2. application配置

此处我选择使用 .yml 文件配置

spring:
  # 缓存设置
  cache:
    # redis缓存
    type: redis
    redis:
    	# 缓存超时默认时间，此处设置为一天
      time-to-live: 1d
      # 是否启用缓存key统一前缀，默认为true
      use-key-prefix: true
      # 是否保存null值，默认为true
      cache-null-values: true
      # 设置缓存key前缀
      key-prefix: cache.
  redis:
    database: 0
    host: 192.168.4.119
    port: 6379
    password:
    lettuce:
      pool:
        # 连接池中的最大空闲连接 默认8
        max-idle: 8
        # 连接池中的最小空闲连接 默认0
        min-idle: 0
        # 连接池最大连接数 默认8 ，负数表示没有限制
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
        max-wait: -1
    timeout: 30000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 3.入口类配置

加入注解 @EnableCaching

@SpringBootApplication
@EnableCaching
public class DemoApplication {
}

1
2
3
4

# 4.redis配置类

@Configuration
public class RedisConfig {

    /**
     * springboot2.x 使用LettuceConnectionFactory 代替 RedisConnectionFactory
     * application.yml配置基本信息后,springboot2.x  RedisAutoConfiguration能够自动装配
     * LettuceConnectionFactory 和 RedisConnectionFactory 及其 RedisTemplate
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 5.使用Cache

注入SpringBoot自动配置的bean，org.springframework.cache.CacheManager。一个简单的测试类：

package com.bbf.frame.test;

import com.bbf.frame.Application;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.MOCK)
public class TestCache {
  @Resource
  private CacheManager cacheManager;

  @Test
  public void cacheTest() {
    // 显示所有的Cache空间
    System.out.println(StringUtils.join(cacheManager.getCacheNames(), ","));
    Cache cache = cacheManager.getCache("userCache");
    cache.put("key", "123");
    System.out.println("缓存成功");
    String res = cache.get("key", String.class);
    System.out.println(res);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# CacheManager转换

    // 获取EhCache的管理器
    org.springframework.cache.ehcache.EhCacheCacheManager cacheCacheManager = (EhCacheCacheManager) cacheManager;
    net.sf.ehcache.CacheManager ehCacheManager = cacheCacheManager.getCacheManager();
    net.sf.ehcache.Cache ehCache = ehCacheManager.getCache("userCache");