玩转Spring Cache --- 整合分布式缓存Redis Cache（使用Lettuce、使用Spring Data Redis）【享学Spring】

迈不过友情╰ 2021-12-14 05:53 511阅读 0赞

#### 每篇一句 ####

> 坚持以价值为导向的学习方式，扔掉低价值的知识（配置、调参、安装），聚焦高价值知识（结构、算法、优化）

#### 前言 ####

最近都在聊Spring的缓存抽象`Spring Cache`，上篇文章深入介绍了`Spring Cache`集成**进程缓存**的第三方组件如`Caffeine、Ehcache`，若对此篇文章感兴趣，可移步观看：[【小家Spring】玩转Spring Cache — 整合进程缓存之王Caffeine Cache和Ehcache3.x][Spring_Spring Cache _ _Caffeine Cache_Ehcache3.x]

我们知道现在的应用大都以微服务的方式进行**分布式部署**，因此如果仅仅使用本地缓存是 满足不了/难以满足 我们需求的（`Infinispan`这种基于本地内存实现的分布式缓存不在本文讨论范围~）。针对分布式场景下的缓存应用，我们急需要一个**高可用的、快速的、中心化的、分布式的**缓存产品。然后在众多此场景的实现产品中，`Redis`以它众多优秀的特性脱颖而出。

so，本文就以大伙**最关心、最熟悉**的`Redis`这个缓存产品为例，让它和`Spring Cache`集成，达到分布式中心缓存的效果（支持缓存直接直接操作）。

> Redis：一个基于键值对存储的NoSQL内存数据库，**可存储复杂的数据结构**，如List, Set, Hashes。  
> 关于Redis的单线程、数据结构、序列化、网络IO、高吞吐等高级特性，不是本文讨论的范围。本文只讨论集成注解缓存的**k-v结构**

## Spring Data Redis简介和使用示例 ##

`Spring`构建了自己庞大的生态，它对很多优秀的、流行的产品提供了一整套的整合、解决方案。`Redis`在缓存界这么广受欢迎，`Spring Data`工程中自然少不了它，它就是`Spring Data Redis`。

`Spring Data Redis`对`Redis`**底层开发包**（Jedis、Lettuce、JRedis、RJC）进行了高度封装。`RedisTemplate`封装提供了`redis`各种操作、异常处理及序列化，完全屏蔽里底层实现（使用者**面向Spring Data编程**即可，可完全不用关心底层到底使用的是**Jedis or Lettuce**）。

**`Spring Data Redis`这个Jar的依赖包如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]  
另外有个使用的Tips需要注意：**在`Spring Data Redis`的使用方面上，我们还需要重视版本的差异：**

> 其实我一直在强调版本意识，不管是在Spring上、JDK上，还是MyBatis，版本意识对你做架构都非常的重要

`Spring Data Redis1.x`截图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 1]  
`Spring Data Redis2.x`截图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 2]  
版本的差异从包结构上就能一目了然。具体到源码处，从`RedisConnectionFactory`接口的继承图也能看出差异：  
![在这里插入图片描述][20190708152515673.png]  
![在这里插入图片描述][20190708152549222.png]

由图可知，从2.x版本开始，Spring就只为我们保留了`jedis`和`lettuce`。  
`lettuce`是redis连接池未来的发展趋势，2.x开始已经**推荐使用**`lettuce`作为访问`redis`的client客户端。

> 不管用什么客户端，对使用者应该都是透明的，因为在开发过程中，没有极其特殊的情况，**应该规定只允许使用`RedisTemplate`来操作Redis。**

#### 使用`Jedis`作为Client操作Redis示例 ####

虽然说`Jedis`有多线程安全问题，并且它的性能也堪忧，**大有被淘汰的趋势**。但是，但是，但是毕竟它还仍旧还是当下的主流的Java访问`Redis`的客户端，所以本文也有必要把它的使用说一下，供以参考：

第一步：导包（本文以2.x为例）

<dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.10.2</version>
    </dependency>

第二步：准备Config配置文件

//@EnableCaching // 因为此处我没准备CacheManager，暂时关闭缓存注解
    @Configuration
    public class CacheConfig extends CachingConfigurerSupport { 
    
        @Bean
        public RedisConnectionFactory redisConnectionFactory() { 
            RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
            // 2.0后的写法
            configuration.setHostName("10.102.132.150");
            //configuration.setPassword(RedisPassword.of("123456"));
            configuration.setPort(6379);
            configuration.setDatabase(0);
    
    
            JedisConnectionFactory factory = new JedisConnectionFactory(configuration);
            // Spring Data Redis1.x这么来设置 2.0后建议使用RedisStandaloneConfiguration来取代
            //factory.setHostName("10.102.132.150");
            //factory.setPassword("123456");
            //factory.setPort(6379);
            //factory.setDatabase(0);
            return factory;
        }
    
        @Bean
        public RedisTemplate<String, String> stringRedisTemplate() { 
            RedisTemplate<String, String> redisTemplate = new StringRedisTemplate();
            redisTemplate.setConnectionFactory(redisConnectionFactory());
            return redisTemplate;
        }
    
    }

运行单元测试：

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = { RootConfig.class, CacheConfig.class})
    public class TestSpringBean { 
    
        @Autowired
        private RedisConnectionFactory redisConnectionFactory;
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        @Test
        public void test1() { 
            System.out.println(redisConnectionFactory);
            System.out.println(redisConnectionFactory.getConnection());
            //System.out.println(redisConnectionFactory.getClusterConnection()); //InvalidDataAccessApiUsageException: Cluster is not configured!
            //System.out.println(redisConnectionFactory.getSentinelConnection()); // InvalidDataAccessResourceUsageException: No Sentinels configured
    
            System.out.println(redisTemplate);
            redisTemplate.opsForValue().set("name", "fsx");
            System.out.println(redisTemplate.opsForValue().get("name"));
        }
    }

打印输出：

org.springframework.data.redis.connection.jedis.JedisConnectionFactory@238b521e
    org.springframework.data.redis.connection.jedis.JedisConnection@1cefc4b3
    org.springframework.data.redis.core.StringRedisTemplate@2b27cc70
    fsx

并且Redis Server端也能查看到key为“name”的值：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 3]  
由此证明我们的缓存配置都能正常work了，能够使用`RedisTempate`操作`Redis`了。部分很简单有木有，只需要简单的两步即可达到目的~

> 关于`Jedis`或者说`RedisTemplate`的详细使用，显然也不是本文的重点，有兴趣的可自行研究，或者出门左拐~

#### 使用`Lettuce`作为Client操作Redis示例 ####

`Lettuce`作为新时代的Redis客户端，它势必成为将来的主流（其实现在也很主流了，比如SpringBoot2.0后默认就使用它作为Redis的Client访问）。

第一步：同样的导包（此处导入lettuce作为客户端）

<dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
        <version>5.1.7.RELEASE</version>
    </dependency>

第二步：准备Config配置文件

//@EnableCaching
    @Configuration
    public class CacheConfig extends CachingConfigurerSupport { 
    
        @Bean
        public RedisConnectionFactory redisConnectionFactory() { 
            // RedisStandaloneConfiguration这个配置类是Spring Data Redis2.0后才有的~~~
            RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
            // 2.0后的写法
            configuration.setHostName("10.102.132.150");
            //configuration.setPassword(RedisPassword.of("123456"));
            configuration.setPort(6379);
            configuration.setDatabase(0);
    
    
            LettuceConnectionFactory factory = new LettuceConnectionFactory(configuration);
            // Spring Data Redis1.x这么来设置 2.0后建议使用RedisStandaloneConfiguration来取代
            //factory.setHostName("10.102.132.150");
            //factory.setPassword("123456");
            //factory.setPort(6379);
            //factory.setDatabase(0);
            return factory;
        }
    
        @Bean
        public RedisTemplate<String, String> stringRedisTemplate() { 
            RedisTemplate<String, String> redisTemplate = new StringRedisTemplate();
            redisTemplate.setConnectionFactory(redisConnectionFactory());
            return redisTemplate;
        }
    
    }

> 用上了Spring Data Redis2.0提供的`RedisStandaloneConfiguration`配置类后，配置步骤和Jedis的一毛一样

运行如上的单元测试，打印结果如下：

org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory@59942b48
    14:35:00.798 [main] INFO  io.lettuce.core.EpollProvider - Starting without optional epoll library
    14:35:00.800 [main] INFO  io.lettuce.core.KqueueProvider - Starting without optional kqueue library
    org.springframework.data.redis.connection.lettuce.LettuceConnection@3cf7298d
    org.springframework.data.redis.core.StringRedisTemplate@1ff55ff
    fsx

从日志中会发现多输出了两句info日志，结果都是ok的，能正常work。

> 说明：`SpringBoot1.x`最终依赖的是`Spring Data Redis 1.8.xx`，默认导入使用的是`Jedis`客户端，版本号为2.9.x（非最新的3.x，不兼容，慎用）  
> `SpringBoot2.0`开始，依赖的是`Spring Data Redis 2.x/x`，并且默认导入使用的是`Lettuce`客户端，版本号是从5.x.x开始  
> **当然，不管是Boot1.x或者2.x，都是允许你手动切换的（只是完全没有必要而已）。**

## Redis和Spring Cache整合 ##

Redis和Spring Cache整合，让能通过缓存注解优雅的操作`Redis`是本文的主菜。

因为`Redis`**分布式缓存**它是client/server模式，所以它的整合和前面整合Ehcache等还是有些不一样的地方的 。但在有了上篇文章做铺垫，加上上面介绍`Spring Data Redis`的使用之后，要集成它也是易如反掌之事。

#### RedisCacheManager ####

老规矩，整合前先看看`Redis`对`CacheManager`接口的实现`RedisCacheManager`：

> 说明：Spring Data Redis2.x对此类进行了大幅的重写，除了类名没变，内容完全重写了。  
> 此处我给出这张对比图，希望小伙伴们也能做到心中有数。（本文以2.x版本为例）  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 4]

// @since 2.0 这里面用到了2.0提供的 RedisCacheConfiguration和RedisCacheWriter等
    public class RedisCacheManager extends AbstractTransactionSupportingCacheManager { 
    	// 这两个哥们都是不能为null的~~~
    	private final RedisCacheWriter cacheWriter;
    	// 这个配置类非常重要。能配置ttl、CacheKeyPrefix、ConversionService等等等等
    	// 可以用链式操作进行构造~~~
    	private final RedisCacheConfiguration defaultCacheConfig;
    
    
    	private final Map<String, RedisCacheConfiguration> initialCacheConfiguration;、
    	// allow create unconfigured caches
    	private final boolean allowInFlightCacheCreation;
    
    	// 请注意：这个构造函数是私有的
    	private RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation) { 
    
    		Assert.notNull(cacheWriter, "CacheWriter must not be null!");
    		Assert.notNull(defaultCacheConfiguration, "DefaultCacheConfiguration must not be null!");
    
    		this.cacheWriter = cacheWriter;
    		this.defaultCacheConfig = defaultCacheConfiguration;
    		this.initialCacheConfiguration = new LinkedHashMap<>();
    		this.allowInFlightCacheCreation = allowInFlightCacheCreation;
    	}
    	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) { 
    		this(cacheWriter, defaultCacheConfiguration, true);
    	}
    	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, String... initialCacheNames) { 
    		this(cacheWriter, defaultCacheConfiguration, true, initialCacheNames);
    	}
    	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, String... initialCacheNames) { 
    		this(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation);
    
    		// 给每个Cache都放一个配置，默认都使用全局的defaultCacheConfiguration
    		// 可见：它是支持给不同的Cache，给出不同的配置的（比如过期时间，，，等等等）
    		for (String cacheName : initialCacheNames) { 
    			this.initialCacheConfiguration.put(cacheName, defaultCacheConfiguration);
    		}
    	}
    	// 这里也可以自己把initialCacheConfigurations这个Map传进来（完成完全个性化）
    	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) { 
    
    		this(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, true);
    	}
    	...
    
    
    	// 根据RedisConnectionFactory 直接new一个RedisCacheManager出来，都采用默认的方案
    	public static RedisCacheManager create(RedisConnectionFactory connectionFactory) { 
    
    		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
    		return new RedisCacheManager(new DefaultRedisCacheWriter(connectionFactory), RedisCacheConfiguration.defaultCacheConfig());
    	}
    
    
    	//builder默认来构造、设置更加详细的参数设置
    	// 注意这个builder，既能够根据RedisConnectionFactory生成，也能个根据`RedisCacheWriter`直接生成
    	public static RedisCacheManagerBuilder builder(RedisConnectionFactory connectionFactory) { 
    
    		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");
    
    		return RedisCacheManagerBuilder.fromConnectionFactory(connectionFactory);
    	}
    	public static RedisCacheManagerBuilder builder(RedisCacheWriter cacheWriter) { 
    
    		Assert.notNull(cacheWriter, "CacheWriter must not be null!");
    
    		return RedisCacheManagerBuilder.fromCacheWriter(cacheWriter);
    	}
    
    
    	// 实现抽象父类的抽象方法，把指定的缓存Cache都加载进来~ 
    	// 若没有指定，这里木有啦~
    	@Override
    	protected Collection<RedisCache> loadCaches() { 
    		List<RedisCache> caches = new LinkedList<>();
    		for (Map.Entry<String, RedisCacheConfiguration> entry : initialCacheConfiguration.entrySet()) { 
    			caches.add(createRedisCache(entry.getKey(), entry.getValue()));
    		}
    		return caches;
    	}
    	// 此处使用的是RedisCache，它其实里面依赖的是RedisCacheWriter（1.x版本传入的是RedisOperations，也就是RedisTemplate）
    	protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) { 
    		return new RedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
    	}
    
    	// 简单的说，默认下RedisCache也是允许动态生成的~~~~
    	// 显然，默认生成的（并非自己指定的），只能使用默认配置defaultCacheConfig了
    	@Override
    	protected RedisCache getMissingCache(String name) { 
    		return allowInFlightCacheCreation ? createRedisCache(name, defaultCacheConfig) : null;
    	}
    
    	public Map<String, RedisCacheConfiguration> getCacheConfigurations() { 
    	... // 获取到全部的Cache的配置（包括只传了CacheNames的情况） 它的key就是所有的cacheNames
    	}
    
    	// builder模式，详细代码省略~ 
    	public static class RedisCacheManagerBuilder { 
    		...
    		public RedisCacheManager build() { 
    			RedisCacheManager cm = new RedisCacheManager(cacheWriter, defaultCacheConfiguration, initialCaches, allowInFlightCacheCreation);
    			// 是否允许事务：默认是false
    			cm.setTransactionAware(enableTransactions);
    			return cm;
    		}
    	}
    }

这个实现看着还是非常简单的，因为它有2.0提供的两个新的类：`RedisCacheWriter`和`RedisCacheConfiguration`进行分而治之。

#### RedisCache ####

很显然，`RedisCache`是对`Cache`抽象的实现：

> 同样的，1.x和2.x对此类的实现完全不一样，此处就不贴图了~

// @since 2.0 请注意：这里也是以2.0版本的为准的
    public class RedisCache extends AbstractValueAdaptingCache { 
    
    	private static final byte[] BINARY_NULL_VALUE = RedisSerializer.java().serialize(NullValue.INSTANCE);
    
    	private final String name; // 缓存的名字
    	private final RedisCacheWriter cacheWriter; //最终操作是委托给它的
    	private final RedisCacheConfiguration cacheConfig; // cache的配置（因为每个Cache的配置可能不一样，即使来自于同一个CacheManager）
    	private final ConversionService conversionService; // 数据转换
    	
    	// 唯一构造函数，并且还是protected 的。可见我们自己并不能操控它
    	protected RedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) { 
    
    		super(cacheConfig.getAllowCacheNullValues());
    
    		Assert.notNull(name, "Name must not be null!");
    		Assert.notNull(cacheWriter, "CacheWriter must not be null!");
    		Assert.notNull(cacheConfig, "CacheConfig must not be null!");
    
    		this.name = name;
    		this.cacheWriter = cacheWriter;
    		this.cacheConfig = cacheConfig;
    		this.conversionService = cacheConfig.getConversionService();
    	}
    
    	@Override
    	public String getName() { 
    		return name;
    	}
    	@Override
    	public RedisCacheWriter getNativeCache() { 
    		return this.cacheWriter;
    	}
    
    	// cacheWriter会有网络访问请求~~~去访问服务器
    	@Override
    	protected Object lookup(Object key) { 
    		byte[] value = cacheWriter.get(name, createAndConvertCacheKey(key));
    		if (value == null) { 
    			return null;
    		}
    		return deserializeCacheValue(value);
    	}
    
    	@Override
    	@Nullable
    	public ValueWrapper get(Object key) { 
    		Object value = lookup(key);
    		return toValueWrapper(value);
    	}
    
    	// 请注意：这个方法因为它要保证同步性，所以使用了synchronized 
    	// 还记得我说过的sync=true这个属性吗，靠的就是它来保证的（当然在分布式情况下 不能百分百保证）
    	@Override
    	@SuppressWarnings("unchecked")
    	public synchronized <T> T get(Object key, Callable<T> valueLoader) { 
    		ValueWrapper result = get(key);
    		if (result != null) {  // 缓存里有，就直接返回吧
    			return (T) result.get();
    		}
    	
    		// 缓存里没有，那就从valueLoader里拿值，拿到后马上put进去
    		T value = valueFromLoader(key, valueLoader);
    		put(key, value); 
    		return value;
    	}
    
    
    	@Override
    	public void put(Object key, @Nullable Object value) { 
    		Object cacheValue = preProcessCacheValue(value);
    
    		// 对null值的判断，看看是否允许存储它呢~~~
    		if (!isAllowNullValues() && cacheValue == null) { 
    			throw new IllegalArgumentException(String.format("Cache '%s' does not allow 'null' values. Avoid storing null via '@Cacheable(unless=\"#result == null\")' or configure RedisCache to allow 'null' via RedisCacheConfiguration.", name));
    		}
    		cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTtl());
    	}
    
    	// @since 4.1
    	@Override
    	public ValueWrapper putIfAbsent(Object key, @Nullable Object value) { 
    	...
    	}
    
    	@Override
    	public void evict(Object key) { 
    		cacheWriter.remove(name, createAndConvertCacheKey(key));
    	}
    
    	// 清空：在redis中慎用。因为它是传一个*去 进行全部删除的。
    	@Override
    	public void clear() { 
    		byte[] pattern = conversionService.convert(createCacheKey("*"), byte[].class);
    		cacheWriter.clean(name, pattern);
    	}
    
    	public RedisCacheConfiguration getCacheConfiguration() { 
    		return cacheConfig;
    	}
    	// 序列化key、value ByteUtils为redis包的工具类，Data Redis 1.7
    	protected byte[] serializeCacheKey(String cacheKey) { 
    		return ByteUtils.getBytes(cacheConfig.getKeySerializationPair().write(cacheKey));
    	}
    	protected byte[] serializeCacheValue(Object value) { 
    		if (isAllowNullValues() && value instanceof NullValue) { 
    			return BINARY_NULL_VALUE;
    		}
    		return ByteUtils.getBytes(cacheConfig.getValueSerializationPair().write(value));
    	}
    
    
    	// 创建一个key，请注意这里prefixCacheKey() 前缀生效了~~~
    	protected String createCacheKey(Object key) { 
    
    		String convertedKey = convertKey(key);
    
    		if (!cacheConfig.usePrefix()) { 
    			return convertedKey;
    		}
    
    		return prefixCacheKey(convertedKey);
    	}
    	... 
    }

`RedisCache`它持有`RedisCacheWriter`的引用，所以的对Redis服务的操作都是委托给了它。同时它还持有`RedisCacheConfiguration`和`ConversionService`，证明即使是同一个`CacheManager`管理的缓存实例，配置都可能是不一样的，支持到了很强的个性化。

##### RedisCacheWriter #####

`RedisCacheWrite`它有Spring内建唯一实现类`DefaultRedisCacheWriter`，并且这个类是内建的非`public`的：

// @since 2.0
    public interface RedisCacheWriter { 
    	// 两个静态方法用于创建一个 有锁/无锁的RedisCacheWriter
    	// 它内部自己实现了一个分布式锁的效果~~~~ Duration可以在去获取锁没获取到的话，睡一会再去获取（避免了频繁对redis的无用访问）
    	static RedisCacheWriter nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory) { 
    		return new DefaultRedisCacheWriter(connectionFactory);
    	}
    	static RedisCacheWriter lockingRedisCacheWriter(RedisConnectionFactory connectionFactory) { 
    		return new DefaultRedisCacheWriter(connectionFactory, Duration.ofMillis(50));
    	}
    
    	@Nullable
    	byte[] get(String name, byte[] key);
    
    	// 注意：这两个put方法，都是带有TTL的，因为Redis是支持过期时间的嘛
    	// 多疑依托于此方法，我们其实最终可以定义出支持TTL的缓存注解，下篇博文见
    	void put(String name, byte[] key, byte[] value, @Nullable Duration ttl);
    	@Nullable
    	byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Duration ttl);
    
    	void remove(String name, byte[] key);
    	void clean(String name, byte[] pattern);
    }
    
    // @since 2.0
    class DefaultRedisCacheWriter implements RedisCacheWriter { 
    
    	// 一切远程操作的链接，都来自于链接工厂：RedisConnectionFactory 
    	private final RedisConnectionFactory connectionFactory;
    	private final Duration sleepTime;
    
    	DefaultRedisCacheWriter(RedisConnectionFactory connectionFactory) { 
    		this(connectionFactory, Duration.ZERO);
    	}
    	DefaultRedisCacheWriter(RedisConnectionFactory connectionFactory, Duration sleepTime) { 
    		this.connectionFactory = connectionFactory;
    		this.sleepTime = sleepTime;
    	}
    
    	// 拿到redis连接，执行命令。 当然执行之前，去获取锁
    	private <T> T execute(String name, Function<RedisConnection, T> callback) { 
    
    		RedisConnection connection = connectionFactory.getConnection();
    		try { 
    			checkAndPotentiallyWaitUntilUnlocked(name, connection);
    			return callback.apply(connection);
    		} finally { 
    			connection.close();
    		}
    	}
    
    	private void checkAndPotentiallyWaitUntilUnlocked(String name, RedisConnection connection) { 
    		if (!isLockingCacheWriter()) { 
    			return;
    		}
    		try { 
    			// 自旋：去查看锁 若为true（表示锁还cun'z）
    			while (doCheckLock(name, connection)) { 
    				Thread.sleep(sleepTime.toMillis());
    			}
    		} catch (InterruptedException ex) { 
    			// Re-interrupt current thread, to allow other participants to react.
    			Thread.currentThread().interrupt();
    			throw new PessimisticLockingFailureException(String.format("Interrupted while waiting to unlock cache %s", name), ex);
    		}
    	}
    	... // 关于它内部的lock、unlock处理，有兴趣的可以看看此类，因为不是本文重点，所以此处不说明了
    
    	// 其余方法，都是调用了execute方法
    	@Override
    	public void put(String name, byte[] key, byte[] value, @Nullable Duration ttl) { 
    		execute(name, connection -> { 
    			// 只有ttl合法才会执行。注意：单位MILLISECONDS 是毫秒值
    			if (shouldExpireWithin(ttl)) { 
    				connection.set(key, value, Expiration.from(ttl.toMillis(), TimeUnit.MILLISECONDS), SetOption.upsert());
    			} else { 
    				connection.set(key, value);
    			}
    
    			return "OK";
    		});
    	}
    	@Override
    	public byte[] get(String name, byte[] key) { 
    		return execute(name, connection -> connection.get(key));
    	}
    	// putIfAbsent是根据内部的分布式锁来实现的
    	@Override
    	public byte[] putIfAbsent(String name, byte[] key, byte[] value, @Nullable Duration ttl) {  
    		... 
    	}
    	@Override
    	public void remove(String name, byte[] key) { 
    		execute(name, connection -> connection.del(key));
    	}
    	// 注意批量删，第二参数是pattern
    	@Override
    	public void clean(String name, byte[] pattern) { 
    		...
    	}
    	...
    }

整体上看，`DefaultRedisCacheWriter`的实现还是比较复杂的，它是`2.x`重写的实现。  
1.x版本的`RedisCache`类的实现没有这么复杂，因为它依托于`RedisOperations`去实现，复杂度都在`RedisOperations`本身了。

> 2.x版本把`注解操作缓存`和`RedisTempate操作缓存`完全分离开了，也就是说注解缓存再也不用依赖于`RedisTempate`了~

###### 为何能使用`RedisCacheWriter`代替`RedisOperations` ######

使用过1.x版本的都知道，创建一个`RedisCacheManager`实例的时候，都必须想准备一个`RedisTempate`实例，因为它强依赖于它。  
但是如上2.0的配置可知，它现在只依赖于`RedisConnectionFactory`而不用再管`RedisOperations`了。

为何Spring要大费周章的重写一把呢？此处我可以大胆猜测一下：

1.  `Cache`抽象（缓存注解）只会操作k-v，不会涉足复杂的数据结构
2.  `RedisOperations`功能强大，能够操作任意类型。所以放在操作`Cache`上显得非常的笨重
3.  重写的`RedisCacheWriter`完全独立不依赖，运用在Cache上，能够使得缓存注解保持非常高的独立性。**并且此接口也非常的轻**

#### Demo示例 ####

说了这么多，是时候来些实战的代码了。这里我自己给出一个Demo供以参考：

@Service
    public class CacheDemoServiceImpl implements CacheDemoService { 
    
        @Cacheable(cacheNames = "demoCache", key = "#id")
        @Override
        public Object getFromDB(Integer id) { 
            System.out.println("模拟去db查询~~~" + id);
            return "hello cache...";
        }
    }
    
    
    @EnableCaching // 使用了CacheManager，别忘了开启它 否则无效
    @Configuration
    public class CacheConfig extends CachingConfigurerSupport { 
    
        // 配置一个CacheManager 来支持缓存注解
        @Bean
        public CacheManager cacheManager() { 
            // 1.x是这么配置的：仅供参考
            //RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
            //cacheManager.setDefaultExpiration(ONE_HOUR * HOURS_IN_ONE_DAY);
            //cacheManager.setUsePrefix(true);
    
            // --------------2.x的配置方式--------------
            // 方式一：直接create
            //RedisCacheManager redisCacheManager = RedisCacheManager.create(redisConnectionFactory());
            // 方式二：builder方式（推荐）
    
            RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofDays(1)) //Duration.ZERO表示永不过期（此值一般建议必须设置）
                    //.disableKeyPrefix() // 禁用key的前缀
                    //.disableCachingNullValues() //禁止缓存null值
    
                    //=== 前缀我个人觉得是非常重要的，建议约定：注解缓存一个统一前缀、RedisTemplate直接操作的缓存一个统一前缀===
                    //.prefixKeysWith("baidu:") // 底层其实调用的还是computePrefixWith() 方法，只是它的前缀是固定的（默认前缀是cacheName，此方法是把它固定住，一般不建议使用固定的）
                    //.computePrefixWith(CacheKeyPrefix.simple()); // 使用内置的实现
                    .computePrefixWith(cacheName -> "caching:" + cacheName) // 自己实现，建议这么使用(cacheName也保留下来了)
                    ;
    
            RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory())
                    // .disableCreateOnMissingCache() // 关闭动态创建Cache
                    //.initialCacheNames() // 初始化时候就放进去的cacheNames（若关闭了动态创建，这个就是必须的）
                    .cacheDefaults(configuration) // 默认配置（强烈建议配置上）。 比如动态创建出来的都会走此默认配置
                    //.withInitialCacheConfigurations() // 个性化配置 可以提供一个Map，针对每个Cache都进行个性化的配置（否则是默认配置）
                    //.transactionAware() // 支持事务
                    .build();
            return redisCacheManager;
        }

配置好后，运行单测：

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = { RootConfig.class, CacheConfig.class})
    public class TestSpringBean { 
        @Autowired
        private CacheDemoService cacheDemoService;
        @Autowired
        private CacheManager cacheManager;
    
    
        @Test
        public void test1() { 
            cacheDemoService.getFromDB(1);
            cacheDemoService.getFromDB(1);
    
            System.out.println("----------验证缓存是否生效----------");
            Cache cache = cacheManager.getCache("demoCache");
            System.out.println(cache);
            System.out.println(cache.get(1, String.class));
        }
    }

打印结果如下：

模拟去db查询~~~1
    ----------验证缓存是否生效----------
    org.springframework.data.redis.cache.RedisCache@788ddc1f
    hello cache...

并且缓存中有值如下（**注意key有统一前缀**）：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 5]  
就这样非常简单的，`Redis`分布式缓存就和`Spring Cache`完成了集成，可以优雅的使用三大缓存注解去操作了。对你有所帮助

> 备注：`DefaultRedisCacheWriter`使用的写入都是操作的Bytes，所以不会存在乱码问题~

#### 总结 ####

`Redis`作为当下互联网应用中使用最为广泛、最为流行的**分布式缓存产品**，相信本文叙述的应该是绝大多数小伙伴的场景吧。既然它使用得这么普遍，你是否想过怎么和你的同事拉开差距呢？

**其实我这里有个不太成熟的小建议：盘它**。只有你踩的坑多了，碰到的事多了，你才有足够的资本说你比你的同事懂得多，熟练得多，能够解决他们解决不了的问题。  
至于有的小伙伴提到的想让每一个缓存注解也支持自定义过期时间，我觉得能有这个想法是很不错的，**至于如何实现，请待下文分解~**

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[Spring_Spring Cache _ _Caffeine Cache_Ehcache3.x]: https://blog.csdn.net/f641385712/article/details/94982916
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70]: /images/20211213/a6149e8fce3e4ce7b6f780a86f53a79f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 1]: /images/20211213/c40b876995674da4822b75fe4cbdbf5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 2]: /images/20211213/b37358b26a46467093b8e0903c46ab4a.png
[20190708152515673.png]: /images/20211213/c232d94a54a945fc85c4fabc7b40101f.png
[20190708152549222.png]: /images/20211213/7da20862d6804b7e92c0ab8c7cd7a25a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 3]: /images/20211213/2ea6d0ed3d574f5fb3d32e47bc1d09b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 4]: /images/20211213/39e0670549a645ff9c405edda3cd278c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI_size_16_color_FFFFFF_t_70 5]: /images/20211213/54adad18d47440f9bb2501afdea483a8.png
[BAT]: /images/20211213/c7c0bc29d76b45fe800314a5323a51d2.png