上一篇中虽然解决了，单例RedisTemplate在事务和非事务中混用的问题，但是这两天又发现如果设置了RedisTemplate启用事务（设置 redisTemplate.setEnableTransactionSupport(true)）时，如果在使用中不加@Transaction注解，会造成Redis连接不会释放的问题。
再来看一下RedisTemplate中的execute方法：
public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
Assert.isTrue(initialized, "template not initialized; call afterPropertiesSet() before using it");
Assert.notNull(action, "Callback object must not be null");
RedisConnectionFactory factory = getConnectionFactory();
RedisConnection conn = null;
try {
if (enableTransactionSupport) {
// only bind resources in case of potential transaction synchronization
//如果设置了启用事务，则调用bindConnection
conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
} else {
conn = RedisConnectionUtils.getConnection(factory);
}
boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);
//预留钩子函数可在执行具体操作前对connection做一些处理
RedisConnection connToUse = preProcessConnection(conn, existingConnection);
boolean pipelineStatus = connToUse.isPipelined();
if (pipeline && !pipelineStatus) {
connToUse.openPipeline();
}
RedisConnection connToExpose = (exposeConnection ? connToUse : createRedisConnectionProxy(connToUse));
T result = action.doInRedis(connToExpose);
// close pipeline
if (pipeline && !pipelineStatus) {
connToUse.closePipeline();
}
// TODO: any other connection processing?
//预留钩子函数可在执行具体操作后对connection做一些处理
return postProcessResult(result, connToUse, existingConnection);
} finally {
RedisConnectionUtils.releaseConnection(conn, factory);
}
}
从源码中可以看出在最后会调用 RedisConnectionUtils.releaseConnection来释放连接
public static void releaseConnection(RedisConnection conn, RedisConnectionFactory factory) {
if (conn == null) {
return;
}
RedisConnectionHolder connHolder = (RedisConnectionHolder) TransactionSynchronizationManager.getResource(factory);
if (connHolder != null && connHolder.isTransactionSyncronisationActive()) {
if (log.isDebugEnabled()) {
log.debug("Redis Connection will be closed when transaction finished.");
}
return;
}
// release transactional/read-only and non-transactional/non-bound connections.
// transactional connections for read-only transactions get no synchronizer registered
if (isConnectionTransactional(conn, factory)
&& TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
unbindConnection(factory);
} else if (!isConnectionTransactional(conn, factory)) {
if (log.isDebugEnabled()) {
log.debug("Closing Redis Connection");
}
conn.close();
}
}
//判断在当前线程中是否能取得连接
public static boolean isConnectionTransactional(RedisConnection conn, RedisConnectionFactory connFactory) {
if (connFactory == null) {
return false;
}
RedisConnectionHolder connHolder = (RedisConnectionHolder) TransactionSynchronizationManager
.getResource(connFactory);
return (connHolder != null && conn == connHolder.getConnection());
}
释放连接的代码中有两种情况会释放连接
- 如果当前线程中取到连接并且当前事务不是只读的
- 如果当前线程中没有取到连接
isConnectionTransaction（conn,factory）是判断当前线程中有没有绑定连接
TransactionSynchronizationManager.isCurrentTransactionReadOnly() 是判断当前事务是不是只读的
RedisTemplate的execute方法中可以看出，只要enableTransactionSupport设置为true，都会把连接绑定到当前线程中，我在配置时设置了true。所以isConnectionTransaction（conn,factory）一直是true
第一个判断 isConnectionTransaction(conn,factory) 返回true，
TransactionSynchronizationManager.isCurrentTransactionReadOnly() 如果我在业务方法上没有加@Transactional注解，这里会返回false
所以第一个if是进不去的
第二个判断 !isConnectionTransactional(conn, factory) 返回false,所以这个if也进不去。
因此这种情况下会造成连接不能释放
这里大概能看出来只要设置了enableTransactionSupport=true，任何调用RedisTemplate的方法，都必须放在事务中（也不值得算不算一个bug）
所以如果想要在非事务中用RedisTemplate必须设置enableTransactionSupport=false，才能释放连接。
由于现在的代码中事务和非事务的方法用的都是同一个开启的事务支持的RedisTemplate，要改的地方比较多，并且在使用如果还要考虑是否是在事务中执行比较麻烦并且容易出错。
我这里的解决方案是：使用两个RedisTemplate来解决此问题
1.创建了一个RedisTemplateDelegate 继承自RedisTemplate, 这个类开启事务支持，此类还用于代理所有与enableTransactionSupport属性相关的方法
2.这个类中有个属性notSupportTransactionRedisTemplate，需要注入一个没有开启事务支持的RedisTemplate。
3.RedisTemplateDelegate 中重写了所有跟 enableTransactionSupport 属性有关的方法。
4.通过TransactionSynchronizationManager.isActualTransactionActive()判断 是否在事务环境中运行（是否添加了@Transactional注解）来确定使用哪个RedisTemplate来执行redis操作
具体代码如下：
public class RedisTemplateDelegate<K, V> extends RedisTemplate<K, V> {
@Resource(name = "notSupportTransactionRedisTemplate")
private RedisTemplate<K, V> notSupportTransactionRedisTemplate;
@Override
public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
//判断是否有@Transactional注解，如果有就用支持事务的RedisTemplate
if (TransactionSynchronizationManager.isActualTransactionActive()) {
return super.execute(action, exposeConnection, pipeline);
} else {
return notSupportTransactionRedisTemplate.execute(action, exposeConnection, pipeline);
}
}
@Override
public <T> T execute(SessionCallback<T> session) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
return super.execute(session);
} else {
return notSupportTransactionRedisTemplate.execute(session);
}
}
@Override
public List<Object> executePipelined(final SessionCallback<?> session, final RedisSerializer<?> resultSerializer) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
return super.executePipelined(session, resultSerializer);
} else {
return notSupportTransactionRedisTemplate.executePipelined(session, resultSerializer);
}
}
}
Spring boot中的配置
通过此方案同样也解决了上篇中存在的问题，并且更代码更清晰点了。
