Spring集成Spring-data-redis RedisCacheManager缓存源码分析

在项目中，一般我们会把服务层（service）的一些查询结果和一些数据进行缓存。缓存的种类有很多。这里进行redis作为缓存框架，进行一个缓存的配置。配置前需要先了解一些基本的知识

在Spring中缓存主要有一个缓存接口（Cache）与缓存管理接口（CacheManager）。可以通过扩展这两个接口实现对应的缓存管理。redis就是这样。当然还有很多比如Guava等都对其进行了扩展。这里只看redis的缓存基本架构：

//首先加载缓存。loadCaches是一个模板方法，具体怎么加载子类决定。
Collection<? extends Cache> caches = loadCaches();

synchronized (this.cacheMap) {
//每次初始化都创建一个新的缓存名称Set。代码最后一行，把这个set集合变成只读
this.cacheNames = Collections.emptySet();
//清空缓存Map  ConcurrentHashMap
this.cacheMap.clear();
//初始化 cacheNames
//1. 循环遍历子类加载的caches
Set<String> cacheNames = new LinkedHashSet<String>(caches.size());
for (Cache cache : caches) {
String name = cache.getName();
//加入到缓存map集合中，在加入前要进行对缓存进行装配 decorateCache(cache)
//decorateCache 这个方法本身就是返回cache。但是子类
//AbstractTransactionSupportingCacheManager 重写它。这个类从名字可以看出
//是支持事务。它有一个属性transactionAware默认为false. 如果配置了支持事务，
//就会把当前cache装配成支持事物的cache 所以后面会有支持事务的配置，配置的就是
//transactionAware 这个属性为true
//TransactionAwareCacheDecorator
this.cacheMap.put(name, decorateCache(cache));
//2. 把cache的name加入到name集合中
cacheNames.add(name);
}
//set变成只读
this.cacheNames = Collections.unmodifiableSet(cacheNames);
}
}

public Cache getCache(String name) {
//根据缓存name直接从自己的cache map中获取
Cache cache = this.cacheMap.get(name);
if (cache != null) {
return cache;
}
else {
//如果没有，那么就同步创建
synchronized (this.cacheMap) {
//这里再一次获取，避免在同步前，有线程已经添加进去了。
cache = this.cacheMap.get(name);
if (cache == null) {
//如果还没有，就调用getMissingCache方法获取。
//这个方法可以看作一个模板方法，只不过自己实现了返回null
//也就是说默认不创建。子类可以通过重写这个方法进行创建。
cache = getMissingCache(name);
if (cache != null) {
//对创建的cache进行装配
cache = decorateCache(cache);
//放入缓存 map中
this.cacheMap.put(name, cache);
//更新缓存名称集合。 上面我们知道缓存名称集合被修改成只读，
//所以更新方法里面是创建一个新的，然后size进行加1，再把前面的
//添加进去，然后加入新建的这个，再修改成只读
updateCacheNames(name);
}
}
return cache;
}
}
}

//final类型。子类不可重写
protected final Cache lookupCache(String name) {
return this.cacheMap.get(name);
}

//RedisCacheManager的基本属性
@SuppressWarnings("rawtypes") //
//配置redisTemplate 通过构造函数
private final RedisOperations redisOperations;
//是否使用前缀
private boolean usePrefix = false;
//默认前缀 为":"。使用前缀可以对缓存进行分组，避免缓存的冲突
private RedisCachePrefix cachePrefix = new DefaultRedisCachePrefix();
//远程加载缓存
private boolean loadRemoteCachesOnStartup = false;
//是否动态生成缓存。默认为true。这个就是上面如果缓存不存在，则创建
//是通过这个属性进行配置。配置为false则不会去创建缓存
private boolean dynamic = true;

// 过期时间 0为永不过期
private long defaultExpiration = 0;
//可以配置指定key的过期时间 可以通过定制化配置过期时间
private Map<String, Long> expires = null;
//配置缓存名称集合
private Set<String> configuredCacheNames;
//缓存是否可以为null
private final boolean cacheNullValues;

@Override
protected Collection<? extends Cache> loadCaches() {
//首先我们必须配置了redisOperations。因为没有redisTemplate我们就无法操作redis
Assert.notNull(this.redisOperations, "A redis template is required in order to interact with data store");
//首先看是否需要远程加载缓存
//如果配置是，那么久执行  loadAndInitRemoteCaches（）方法进行加载
//这个远程加载比较容易。就是用redisTemplate去加载后缀~keys的key.
//后缀为~keys是因为在创建的时候加上了这个后缀。具体可以查看redis的静态内部类
//RedisCacheMetadata 的构造方法。
Set<Cache> caches = new LinkedHashSet<Cache>(
loadRemoteCachesOnStartup ? loadAndInitRemoteCaches() : new ArrayList<Cache>());
//加载我们配置的缓存名称集合 上面属性有介绍
Set<String> cachesToLoad = new LinkedHashSet<String>(this.configuredCacheNames);
//加载当前已经缓存名称集合 volatile类型。所以对于当前线程是可见的
cachesToLoad.addAll(this.getCacheNames());

if (!CollectionUtils.isEmpty(cachesToLoad)) {
//如果不为空则循环创建缓存 并加入缓存集合中
//这个缓存为redisCache.创建就是根据我们配置的如过期时间，是否允许为null,序列化（默认为
//jdk序列化）等属性创建一个redisCache
for (String cacheName : cachesToLoad) {
caches.add(createCache(cacheName));
}
}

return caches;
}

protected Cache getMissingCache(String name) {
根据我们配置的dynamic属性决定是否创建新的缓存
return this.dynamic ? createCache(name) : null;
}

@Override
protected Cache decorateCache(Cache cache) {

if (isCacheAlreadyDecorated(cache)) {
return cache;
}

return super.decorateCache(cache);
}

protected boolean isCacheAlreadyDecorated(Cache cache) {
return isTransactionAware() && cache instanceof TransactionAwareCacheDecorator;
}

@SuppressWarnings("unchecked")
protected RedisCache createCache(String cacheName) {
long expiration = computeExpiration(cacheName);
return new RedisCache(cacheName, (usePrefix ? cachePrefix.prefix(cacheName) : null), redisOperations, expiration,
cacheNullValues);
}

到这里spring-data-redis集成spring的一个基本原理与源码分析差不多了，了解一些基本属性，与执行原理与顺序。然后就可以进行基本配置了。具体配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:cache="http://www.springframework.org/schema/cache"
xsi:schemaLocation=" http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"
default-lazy-init="false">

<!-- 不使用就需要注解掉，如果配置了启用注解注释，就必须要配置cacheManager 否则就会启动报错。因为配置了这个缓存拦截器就会去注入cacheManager -->
<cache:annotation-driven />
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:dbconfig.properties</value>
<value>classpath:redis.properties</value>
</list>
</property>
</bean>

<!-- 连接池配置. -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 连接池中最大连接数。高版本：maxTotal，低版本：maxActive -->
<property name="maxTotal" value="8" />
<!-- 连接池中最大空闲的连接数. -->
<property name="maxIdle" value="8" />
<!-- 连接池中最少空闲的连接数. -->
<property name="minIdle" value="${redis.minIdle}" />
<!-- 当连接池资源耗尽时，调用者最大阻塞的时间，超时将跑出异常。单位，毫秒数;默认为-1.表示永不超时。高版本：maxWaitMillis，低版本：maxWait -->
<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
<!-- 连接空闲的最小时间，达到此值后空闲连接将可能会被移除。负值(-1)表示不移除. -->
<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
<!-- 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3 -->

e094
<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
<!-- “空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1. -->
<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
<!-- testOnBorrow:向调用者输出“链接”资源时，是否检测是有有效，如果无效则从连接池中移除，并尝试获取继续获取。默认为false。建议保持默认值. -->
<!-- testOnReturn:向连接池“归还”链接时，是否检测“链接”对象的有效性。默认为false。建议保持默认值. -->
<!-- testWhileIdle:向调用者输出“链接”对象时，是否检测它的空闲超时；默认为false。如果“链接”空闲超时，将会被移除。建议保持默认值. -->
<!-- whenExhaustedAction:当“连接池”中active数量达到阀值时，即“链接”资源耗尽时，连接池需要采取的手段, 默认为1(0:抛出异常。1:阻塞，直到有可用链接资源。2:强制创建新的链接资源) -->
</bean>
<!-- Spring提供的Redis连接工厂 -->
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
destroy-method="destroy">
<!--    连接池配置. -->
<property name="poolConfig" ref="jedisPoolConfig" />
<!-- Redis服务主机. -->
<property name="hostName" value="${redis.hostName}" />
<!-- Redis服务端口号. -->
<property name="port" value="${redis.port}" />
<!-- Redis服务连接密码. -->
<!--    <property name="password" value="${redis.password}" /> -->
<!-- 连超时设置. -->
<property name="timeout" value="${redis.timeout}" />
<!-- 是否使用连接池. -->
<property name="usePool" value="${redis.usePool}" />
</bean>
<!-- Spring提供的访问Redis类. -->
<bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<!-- 开启事务 -->
<property name="enableTransactionSupport" value="true"></property>
<property name="keySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>

<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
<!-- <bean class="com.pdz.util.ApiRedisSerializa"/>
<bean class="com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer"/>
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer" /> -->
</property>

<property name="hashKeySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>

<!-- <property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"
/> </property> -->
<property name="hashValueSerializer">
<bean class="com.pdz.util.ApiRedisSerializa" />
</property>

</bean>

<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<!-- 开启事务 -->
<property name="enableTransactionSupport" value="true"></property>
</bean>
<!-- <bean id="cacheManager" 这里面可以配置上面分析的各种字段属性-- >
class="org.springframework.data.redis.cache.RedisCacheManager">
<!--配置 redisTemplate-->
<constructor-arg index = "0" type="RedisOperations">
<ref bean="jedisTemplate" />
</constructor-arg>
<!-- 过期时间 -->
<property name="defaultExpiration" value="300000"/>
<!--    支持事务 -->
<property name="transactionAware" value = "true"/>
</bean>