由 RedisTemplate 事务 enableTransactionSupport 引发的血案

转载已于 2024-04-14 11:58:15 修改 · 1.7k 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://carlzone.blog.youkuaiyun.com/article/details/108629864

文章标签：

#redis #缓存 #nosql

于 2022-01-07 21:13:13 首次发布

Spring 专栏收录该内容

55 篇文章

订阅专栏

转载自：https://carlzone.blog.youkuaiyun.com/article/details/108629864

在最近的项目当中因为使用了类似字典表的数据，所以使用的 Spring Farmework 当中的 Cache 抽象，通过 Redis 来做为缓存。
因为原有项目当中配置了 Redis，而且项目是基于 Spring Boot 构建的，并没有去除 Redis 的自动依赖(RedisAutoConfiguration)。导致有些 Redis 的有些类是基于项目中自己配置的 RedisTemplate，而有些又是引用的 Spring Boot 中 Redis 的自动配置生成的 RedisTemplate。所以就把 Spring Boot 中的 Redis 自动配置去除了。

去除 Spring Boot Redis 自动配置

@SpringBootApplication(exclude = {RedisAutoConfiguration.class})

上午进行项目发布，在下午的时候运维就找到说上午发布的项目 Redis 连接数一直在添加。而且服务当中也在报无法获取到 Redis 连接。

redis.clients.jedis.exceptions.JedisException: Could not get a resource from the pool

很明显就是 Redis 连接无法获取，并且设置的 Redis 的最大连接数是 1000，所以 Redis 的连接数一直在增加。当在网上搜索 Redis 的连接没有被释放的时候搜索到了 RedisTemplate 设置了支持事务(enableTransactionSupport) 为 true，那么这个 Redis 请求必须在 JDBC 的事务当中，要么就不会释放连接。
果然手动配置的 RedisTemplate 设置了支持事务(默认为 false，不支持)。

所以一直没有产生这种情况的原因是手动配置 Redis 配置文件并没有生效，使用的是 Spring Boot 的 Redis 的自动依赖。自动依赖并没有配置这个值为 true(默认为 false)，所以连接就会释放。RedisTemplate 使用 Redis 连接池释放连接的 2 种情况是：

RedisTemplate 不支持事务，当使用完连接之后就会释放连接到 Pool 当中
RedisTemplate 支持事务，并且必须和 JDBC 在一个事务当中，标注了 @Transactional注解

下面我们就通过源码来分析，RedisTemplate通过 opsForXXX 支持 Redis 中的各种数据操作，比如： opsForValue 操作 String 类型、opsForSet 操作 Set 类型等待。其实它最终会调用到：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 = getRequiredConnectionFactory();
		RedisConnection conn = null;
		try {
	
			if (enableTransactionSupport) {
				// only bind resources in case of potential transaction synchronization
				conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
			} else {
				conn = RedisConnectionUtils.getConnection(factory);
			}
	
			boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);
	
			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?
			return postProcessResult(result, connToUse, existingConnection);
		} finally {
			RedisConnectionUtils.releaseConnection(conn, factory);
		}
	}

上面代码的执行逻辑为：

获取 Redis 的连接工厂 RedisConnectionFactory
通过 boolean 类型值 enableTransactionSupport判断是否支持事务，如果支持事务通过方法RedisConnectionUtils.bindConnection获取并绑定 RedisConnectionHolder 到本地线程，如果不支持事务就通过方法 RedisConnectionUtils#getConnection 获取RedisConnectionHolder。
调用 RedisTemplate 的前置方法 RedisTemplate#preProcessConnection
判断 RedisTemplate 是否使用了 pipeline，如果使用了调用 RedisConnection#openPipeline
如果 exposeConnection 直接使用创建的 RedisConnection，否则创建代理对象 CloseSuppressingInvocationHandler
调用回调方法 RedisCallback#doInRedis 执行 Redis 命令
如果是 pipeline 就调用 RedisConnection#closePipeline关闭 pipeline。
最后在 finally 方法中调用 RedisConnectionUtils.releaseConnection 释放连接
RedisConnectionUtils#releaseConnection

	public static void releaseConnection(@Nullable 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();
		}
	}

上面的代码逻辑如下：

TransactionSynchronizationManager#getResource 获取 RedisConnectionHolder
如果 RedisConnectionHolder 不为空并在事务处理当中直接返回
如果传入的 RedisConnection 在事务当中，并且事务为只读就释放连接
如果传入的 RedisConnection不在事务当中，就调用 RedisConnection#close 释放连接

可以看到如果 Redis 里面没有事务的时候就会直接调用 RedisConnection#close 把连接释放掉。当配置 RedisTemplate 的时候我看网上很多就是说在上面的第三步释放连接，这个说法是错误的。我把事务的条件都满足了都不会进行到第三步。这个问题困扰了我很久。

后面我自己 debug 解决了这个问题，答案就是在绑定并获取连接的时候会添加一个事务完成的回调方法，在这个回调方法当中释放 Redis 连接。

在 RedisTemplate#execute 中，如果设置了 enableTransactionSupport 为 true，就会通过 RedisConnectionUtils#bindConnection 方法获取并绑定 Redis 连接。

	public static RedisConnection doGetConnection(RedisConnectionFactory factory, boolean allowCreate, boolean bind,
			boolean enableTransactionSupport) {
	
		Assert.notNull(factory, "No RedisConnectionFactory specified");
	
		RedisConnectionHolder connHolder = (RedisConnectionHolder) TransactionSynchronizationManager.getResource(factory);
	
		if (connHolder != null) {
			if (enableTransactionSupport) {
				potentiallyRegisterTransactionSynchronisation(connHolder, factory);
			}
			return connHolder.getConnection();
		}
	
		if (!allowCreate) {
			throw new IllegalArgumentException("No connection found and allowCreate = false");
		}
	
		if (log.isDebugEnabled()) {
			log.debug("Opening RedisConnection");
		}
	
		RedisConnection conn = factory.getConnection();
	
		if (bind) {
	
			RedisConnection connectionToBind = conn;
			if (enableTransactionSupport && isActualNonReadonlyTransactionActive()) {
				connectionToBind = createConnectionProxy(conn, factory);
			}
	
			connHolder = new RedisConnectionHolder(connectionToBind);
	
			TransactionSynchronizationManager.bindResource(factory, connHolder);
			if (enableTransactionSupport) {
				potentiallyRegisterTransactionSynchronisation(connHolder, factory);
			}
	
			return connHolder.getConnection();
		}
	
		return conn;
	}

最终会调用到方法 RedisConnectionUtils#potentiallyRegisterTransactionSynchronisation：

	private static void potentiallyRegisterTransactionSynchronisation(RedisConnectionHolder connHolder,
			final RedisConnectionFactory factory) {
	
		if (isActualNonReadonlyTransactionActive()) {
	
			if (!connHolder.isTransactionSyncronisationActive()) {
				connHolder.setTransactionSyncronisationActive(true);
	
				RedisConnection conn = connHolder.getConnection();
				conn.multi();
	
				TransactionSynchronizationManager
						.registerSynchronization(new RedisTransactionSynchronizer(connHolder, conn, factory));
			}
		}
	}

上面的代码逻辑如下：

判断当前方法是否在一个数据库 JDBC 事务当中
判断当前 Redis 连接是否新开启一个事务
调用 RedisConnection#multi标记一个 Redis 事务块的开始
注册添加一个事务回调类 RedisTransactionSynchronizer，它实现了TransactionSynchronization#afterCompletion 当数据库事务完成的时候会调用这个回调方法

TransactionSynchronization#afterCompletion

	@Override
	public void afterCompletion(int status) {
	
		try {
			switch (status) {
	
				case TransactionSynchronization.STATUS_COMMITTED:
					connection.exec();
					break;
	
				case TransactionSynchronization.STATUS_ROLLED_BACK:
				case TransactionSynchronization.STATUS_UNKNOWN:
				default:
					connection.discard();
			}
		} finally {
	
			if (log.isDebugEnabled()) {
				log.debug("Closing bound connection after transaction completed with " + status);
			}
	
			connHolder.setTransactionSyncronisationActive(false);
			connection.close();
			TransactionSynchronizationManager.unbindResource(factory);
		}
	}

当事务完成之后会调用 RedisConnection#exec()，用于执行所有事务块内的命令。
调用 RedisConnection#close 释放 Redis 连接
调用 TransactionSynchronizationManager.unbindResource 解绑 ThreadLocal中的 Redis 连接
下面就是我写的一个支持事务的 RedisTemplate，它必须和数据 JDBC 事务一起使用。

Redis 相关的配置：

@Configuration
public class RedisConfig {

    @Bean(name = "redisConnectionFactory")
    public RedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory(generatePoolConfig());
        factory.setHostName("localhost");
        factory.setPort(6379);
        factory.setUsePool(true);
        factory.setConvertPipelineAndTxResults(true);
        factory.afterPropertiesSet();
        return factory;
    }
    
    @Bean(name = "redisTemplate")
    public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setEnableTransactionSupport(true);
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(stringRedisSerializer);
        template.setDefaultSerializer(stringRedisSerializer);
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
    
    private JedisPoolConfig generatePoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(1000);
        poolConfig.setTestOnBorrow(true);
        return poolConfig;
    }

}

JDBC 与 Redis 事务使用：

@Service("userService")
public class UserServiceImpl implements UserService {

    @Resource(name = "redisTemplate")
    private RedisTemplate<String, String> redisTemplate;
    
    @Resource
    private JdbcTemplate jdbcTemplate;
    
    @Override
    @Transactional
    public void hello() {
        jdbcTemplate.execute("select 1");
        redisTemplate.opsForValue().get("test");
    }

}

必须满足以下几个条件：