SpringCache整合SpringDataRedis

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

负责注册必要的Spring组件，这些组件可以为注释驱动的缓存管理提供支持，例如CacheInterceptor以及基于代理或基于AspectJ的建议将调用@Cacheable方法时，拦截器将进入调用堆栈。如果存在JSR-107 API和Spring的JCache实现，则还将注册用于管理标准缓存注释的必要组件。 这将创建基于代理或基于AspectJ的建议，当调用以CacheResult ， CachePut ， CacheRemove或CacheRemoveAll注释的方法时，将拦截器编织到调用堆栈中。
必须注册CacheManager类型的Bean ，因为没有合理的默认值可以将该框架用作约定。 尽管<cache:annotation-driven>元素假定一个名为“ cacheManager”的bean，但@EnableCaching按类型搜索一个cache manager bean。 因此，高速缓存管理器bean方法的命名并不重要。
对于那些希望在@EnableCaching和要使用的确切缓存管理器bean之间建立更直接关系的@EnableCaching ，可以实现CachingConfigurer回调接口

public class CachingConfigurerSupport implements CachingConfigurer {

    /**
    * 返回高速缓存管理器bean，以用于注释驱动的高速缓存管理。 默认的CacheResolver将使用此缓存管理器在后台初始化。 
    * 为了更精细地管理缓存分辨率，请考虑直接设置CacheResolver， 实现必须显式声明@Bean 
    */
	@Override
	@Nullable
	public CacheManager cacheManager() {
		return null;
	}
   /**
    * 返回CacheResolver bean，用于解析注释驱动的缓存管理的常规缓存。这是指定要使用的CacheManager的替代方法，且
    * 功能更强大。如果同时设置了cacheManager()和#cacheResolver() ，则忽略缓存管理器。实现必须显式声明@Bean 
    */
	@Override
	@Nullable
	public CacheResolver cacheResolver() {
		return null;
	}
   /**
    * 返回密钥生成器Bean，以用于注释驱动的缓存管理。 实现必须显式声明@Bean 
    */
	@Override
	@Nullable
	public KeyGenerator keyGenerator() {
		return null;
	}
   /**
    * 返回CacheErrorHandler以用于处理与缓存相关的错误。默认情况下，
    * 使用org.springframework.cache.interceptor.SimpleCacheErrorHandler ，
    * 并且仅将异常抛出回客户端。实现必须显式声明@Bean 
    */
	@Override
	@Nullable
	public CacheErrorHandler errorHandler() {
		return null;
	}

}

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 自定义实现 缓存处理器 将redis修改为默认的缓存处理器
     *
     * @return
     * @see org.springframework.cache.CacheManager
     */
    @Bean
    @Override
    public CacheManager cacheManager() {
        return super.cacheManager();
    }

    /**
     * 实现自定义的密钥
     * (如果没有自定义实现这个方法会出现什么情况，自定义生成的 redis 键 会像这样 SimpleKey [])
     *
     * @return
     * @see org.springframework.cache.interceptor.KeyGenerator
     */
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return super.keyGenerator();
    }
}

/**
 * 创建新RedisCacheManager使用给定RedisCacheWriter和默认RedisCacheConfiguration 。
 */
public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
	this(cacheWriter, defaultCacheConfiguration, true);
}

/**
 * 创建没有锁定行为的新RedisCacheWriter 
 */
static RedisCacheWriter nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
	Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
	return new DefaultRedisCacheWriter(connectionFactory);
}

/**
 * 创建有锁定行为的新RedisCacheWriter 
 */
static RedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectionFactory) {
	Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
	return new DefaultRedisCacheWriter(connectionFactory, Duration.ofMillis(50));
}

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.0</version>
</dependency>

 /**
 * Redis服务器地址
 */
@Value("${spring.redis.host}")
private String host;

/**
 * Redis服务端口
 */
@Value("${spring.redis.port}")
private int port;

/**
 * Redis服务密码
 */
@Value("${spring.redis.password}")
private String password;

/**
 * Redis服务器地址
 */
@Value("${spring.redis.database}")
private int database;

/**
 * redis 连接工厂 必须注册为 Bean
 *
 * @return
 */
@Bean
public JedisConnectionFactory redisConnectionFactory() {
    RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(host, port);
    config.setDatabase(database);
    config.setPassword(password);
    return new JedisConnectionFactory(config);
}

RedisCacheConfiguration.defaultCacheConfig();

/**
 * 自定义实现 缓存处理器 将redis修改为默认的缓存处理器
 *
 * @return
 * @see org.springframework.data.redis.cache.RedisCacheManager
 */
@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.lockingRedisCacheWriter(redisConnectionFactory), redisCacheConfiguration());
}