聊聊redisTemplate对lettuce的封装

最新推荐文章于 2024-08-11 21:03:31 发布
最新推荐文章于 2024-08-11 21:03:31 发布
阅读量1.1k 收藏 1
点赞数
文章标签： 数据库 java
原文链接：https://juejin.im/post/5b9c6f706fb9a05d0b1424e7
版权

序

本文主要研究一下redisTemplate对lettuce的封装

RedisTemplate

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/core/RedisTemplate.java

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
	//......
	/**
	 * Executes the given action object within a connection that can be exposed or not. Additionally, the connection can
	 * be pipelined. Note the results of the pipeline are discarded (making it suitable for write-only scenarios).
	 *
	 * @param <T> return type
	 * @param action callback object to execute
	 * @param exposeConnection whether to enforce exposure of the native Redis Connection to callback code
	 * @param pipeline whether to pipeline or not the connection for the execution
	 * @return object returned by the action
	 */
	@Nullable
	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);
		}
	}

	//......
}
复制代码
  • redisTemplate内部有诸多方法，这里以execute(RedisCallback action, boolean exposeConnection, boolean pipeline)为例
  • 该方法内部是先获取RedisConnection，然后调用action.doInRedis方法
  • 默认这里的connection是DefaultStringRedisConnection
  • 最后这里还会调用RedisConnectionUtils.releaseConnection(conn, factory)来释放连接

RedisConnectionUtils.getConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/core/RedisConnectionUtils.java

	/**
	 * Gets a Redis connection from the given factory. Is aware of and will return any existing corresponding connections
	 * bound to the current thread, for example when using a transaction manager. Will always create a new connection
	 * otherwise.
	 *
	 * @param factory connection factory for creating the connection
	 * @return an active Redis connection without transaction management.
	 */
	public static RedisConnection getConnection(RedisConnectionFactory factory) {
		return getConnection(factory, false);
	}

	/**
	 * Gets a Redis connection. Is aware of and will return any existing corresponding connections bound to the current
	 * thread, for example when using a transaction manager. Will create a new Connection otherwise, if
	 * {@code allowCreate} is <tt>true</tt>.
	 *
	 * @param factory connection factory for creating the connection
	 * @param allowCreate whether a new (unbound) connection should be created when no connection can be found for the
	 *          current thread
	 * @param bind binds the connection to the thread, in case one was created
	 * @param enableTransactionSupport
	 * @return an active Redis connection
	 */
	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;
	}
复制代码
  • 通过factory.getConnection()获取conn

DefaultStringRedisConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/DefaultStringRedisConnection.java

public class DefaultStringRedisConnection implements StringRedisConnection, DecoratedRedisConnection {

	private static final byte[][] EMPTY_2D_BYTE_ARRAY = new byte[0][];

	private final Log log = LogFactory.getLog(DefaultStringRedisConnection.class);
	private final RedisConnection delegate;
	private final RedisSerializer<String> serializer;
	private Converter<byte[], String> bytesToString = new DeserializingConverter();
	private SetConverter<Tuple, StringTuple> tupleToStringTuple = new SetConverter<>(new TupleConverter());
	private SetConverter<StringTuple, Tuple> stringTupleToTuple = new SetConverter<>(new StringTupleConverter());
	private ListConverter<byte[], String> byteListToStringList = new ListConverter<>(bytesToString);
	private MapConverter<byte[], String> byteMapToStringMap = new MapConverter<>(bytesToString);
	private SetConverter<byte[], String> byteSetToStringSet = new SetConverter<>(bytesToString);
	private Converter<GeoResults<GeoLocation<byte[]>>, GeoResults<GeoLocation<String>>> byteGeoResultsToStringGeoResults;

	@SuppressWarnings("rawtypes") private Queue<Converter> pipelineConverters = new LinkedList<>();
	@SuppressWarnings("rawtypes") private Queue<Converter> txConverters = new LinkedList<>();
	private boolean deserializePipelineAndTxResults = false;
	private IdentityConverter<Object, ?> identityConverter = new IdentityConverter<>();

	//......
	@Override
	public Boolean set(byte[] key, byte[] value) {
		return convertAndReturn(delegate.set(key, value), identityConverter);
	}
	//......
}
复制代码
  • 该类实际是委托给RedisConnection delegate来执行
  • 对于lettuce的类库来说，这个delegate是LettuceConnection

LettuceConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceConnection.java

public class LettuceConnection extends AbstractRedisConnection {
	//......
	@Override
	@Deprecated
	default Boolean set(byte[] key, byte[] value) {
		return stringCommands().set(key, value);
	}

	@Override
	public RedisStringCommands stringCommands() {
		return new LettuceStringCommands(this);
	}

	//......
}
复制代码
  • 以set(byte[] key, byte[] value)方法为例，这是调用stringCommands().set方法

LettuceStringCommands

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceStringCommands.java

@RequiredArgsConstructor
class LettuceStringCommands implements RedisStringCommands {
	//......
	@Override
	public Boolean set(byte[] key, byte[] value) {

		Assert.notNull(key, "Key must not be null!");
		Assert.notNull(value, "Value must not be null!");

		try {
			if (isPipelined()) {
				pipeline(
						connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
				return null;
			}
			if (isQueueing()) {
				transaction(
						connection.newLettuceResult(getAsyncConnection().set(key, value), Converters.stringToBooleanConverter()));
				return null;
			}
			return Converters.stringToBoolean(getConnection().set(key, value));
		} catch (Exception ex) {
			throw convertLettuceAccessException(ex);
		}
	}

	public RedisClusterCommands<byte[], byte[]> getConnection() {
		return connection.getConnection();
	}
	//......
}
复制代码
  • 这里直接调用getConnection().set方法，这里的getConnection()，实际还是调用LettuceConnection的getConnection方法

LettuceConnection.getConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceConnection.java

public class LettuceConnection extends AbstractRedisConnection {
	//......
	protected RedisClusterCommands<byte[], byte[]> getConnection() {

		if (isQueueing()) {
			return getDedicatedConnection();
		}
		if (asyncSharedConn != null) {

			if (asyncSharedConn instanceof StatefulRedisConnection) {
				return ((StatefulRedisConnection<byte[], byte[]>) asyncSharedConn).sync();
			}
			if (asyncSharedConn instanceof StatefulRedisClusterConnection) {
				return ((StatefulRedisClusterConnection<byte[], byte[]>) asyncSharedConn).sync();
			}
		}
		return getDedicatedConnection();
	}

	RedisClusterCommands<byte[], byte[]> getDedicatedConnection() {

		if (asyncDedicatedConn == null) {

			asyncDedicatedConn = doGetAsyncDedicatedConnection();

			if (asyncDedicatedConn instanceof StatefulRedisConnection) {
				((StatefulRedisConnection<byte[], byte[]>) asyncDedicatedConn).sync().select(dbIndex);
			}
		}

		if (asyncDedicatedConn instanceof StatefulRedisConnection) {
			return ((StatefulRedisConnection<byte[], byte[]>) asyncDedicatedConn).sync();
		}
		if (asyncDedicatedConn instanceof StatefulRedisClusterConnection) {
			return ((StatefulRedisClusterConnection<byte[], byte[]>) asyncDedicatedConn).sync();
		}

		throw new IllegalStateException(
				String.format("%s is not a supported connection type.", asyncDedicatedConn.getClass().getName()));
	}

	protected StatefulConnection<byte[], byte[]> doGetAsyncDedicatedConnection() {
		return connectionProvider.getConnection(StatefulConnection.class);
	}
	//......
}
复制代码
  • asyncDedicatedConn为null的话，会调用doGetAsyncDedicatedConnection来获取StatefulConnection
  • connectionProvider.getConnection里头则封装了连接池相关的操作
  • 可以看到无论是StatefulRedisConnection还是StatefulRedisClusterConnection，都是调用async连接的sync方法转换为同步方法

RedisConnectionUtils.releaseConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/core/RedisConnectionUtils.java

	/**
	 * Closes the given connection, created via the given factory if not managed externally (i.e. not bound to the
	 * thread).
	 *
	 * @param conn the Redis connection to close.
	 * @param factory the Redis factory that the connection was created with.
	 */
	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();
		}
	}
复制代码
  • 这里调用的是lettuceConnection的close方法

LettuceConnection.close

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceConnection.java

	@Override
	public void close() throws DataAccessException {

		super.close();

		if (isClosed) {
			return;
		}

		isClosed = true;

		if (asyncDedicatedConn != null) {
			try {
				connectionProvider.release(asyncDedicatedConn);
			} catch (RuntimeException ex) {
				throw convertLettuceAccessException(ex);
			}
		}

		if (subscription != null) {
			if (subscription.isAlive()) {
				subscription.doClose();
			}
			subscription = null;
		}

		this.dbIndex = defaultDbIndex;
	}
复制代码
  • 可以看到这里仅仅是对于asyncDedicatedConn进行release操作，对于asyncSharedConn则不做任何操作

小结

  • lettuce是reactive的异步类库，spring-date-redis的redisTemplate对lettuce的封装底层是调用asynConn的sync方法来转换为同步方法的
  • 另外redisTemplate封装了connection的获取及释放，获取是调用RedisConnectionUtils.getConnection，释放是调用RedisConnectionUtils.releaseConnection
  • RedisConnectionUtils.getConnection底层是调用factory.getConnection()获取conn
  • RedisConnectionUtils.releaseConnection底层是调用LettuceConnection.close，这里仅仅对asyncDedicatedConn进行release操作

doc

weixin_34302798
关注
SpringBoot - 整合Redis：解析Lettuce与RedisTemplate封装
key_768的博客
07-11 4620
Lettuce与Jedis Redis和Mysql一样是数据库，Mysql有对应的JDBC连接，Redis也有对应的Java客户端开发包，集成了Redis的一些命令操作，封装了Redis的java客户端，类似与redis-cli 前面：SpringBoot - 整合Redis：使用Jedis客户端通过Jedis、JedisPool使SpringBoot连接Redis SpringBoot1.x的版本时默认使用的Jedis客户端，在SpringBoot2.x后，默认使用Lettuce Lettuce与Jedi
SpringBoot2.x中redis使用(lettuce)
wenkezhuangyuan的博客
08-08 480
Jedis-->进一步做了封装 -->RedisTemplate-->redis进行了进一步封装 （lettuce) maven配置 新建SpringBoot2.0.3的WEB工程，在MAVEN的pom.xml文件中加入如下依赖 <dependencies> <!--默认是lettuce客户端--> <dependency> <groupId>org.springframew...
【笔记】ReactiveRedisTemplate压测-单机20万QPS-实践
最新发布
Java程序员的知识博客
08-11 139
笔记】ReactiveRedisTemplate压测-单机20万QPS-实践
在RedisTemplate中使用scan代替keys指令
xiaolyuh的专栏
02-22 2508
SCAN 简介 SCAN 命令及其相关的 SSCAN 命令、 HSCAN 命令和 ZSCAN 命令都用于增量地迭代（incrementally iterate）一集元素（a collection of elements）： SCAN 命令用于迭代当前数据库中的数据库键。 SSCAN 命令用于迭代集合键中的元...
Redis 客户端之Lettuce配置使用（基于Spring Boot 2.x）
牧心人的专栏
11-02 2万+
开发环境：使用Intellij IDEA + Maven + Spring Boot 2.x + JDK 8 Spring Boot 从 2.0版本开始，将默认的Redis客户端Jedis替换问Lettuce，下面描述Lettuce的配置使用。 1.在项目的pom.xml文件下，引入Redis在Spring Boot 下的相关Jar包依赖。 properties&amp;amp;gt; &amp;amp;...
soul-网关实战（二）如何成为了Soul的贡献者
qq_37411444的博客
01-28 1748
soul-网关实战（二）如何成为了Soul的贡献者提交第一个PR发现issue提交issue提交PR踩坑（注意事项）结语 提交第一个PR 最近在做一个对外开放的openDataApi数据服务项目，说到对外开放，自然少不了要做一系列比如说：鉴权、防火墙、熔断/限流、负载均衡等等安全保障策略。那如何实现这些策略呢？哈哈哈，不用想看标题，当然是用soul啦~ 接下来，我就在实战项目中使用soul，从发现soul网关的bug，到报告bug，最后提交改进补丁等一些列操作进行一次经验分享，以及中间遇到的一些坑，为大家顺
RedisTemplate lettuce 实现分布式锁
xiehd313的博客
01-15 1万+
springboot2.x 以上使用redis时，默认使用了lettuce封装，比起jedis线程安全 import lombok.extern.slf4j.Slf4j; import org.springframework.data.redis.connection.RedisStringCommands; import org.springframework.data.redis.conn...
RedisTemplate 和lettuce的关系
03-28
RedisTemplate是Spring Data Redis提供的一个用于操作Redis的模板类，它封装了对Redis的常见操作，如存储、读取、删除等。而lettuce是一个高性能的Redis客户端库，它可以提供异步、非阻塞的操作方式，以及更好的集群...
Jedis，lettuce，RedisTemplate，Redission区别
QQQQQQQQYY的博客
01-16 4895
1.Jedis: Redis官方推荐使用Jedis操作Redis，Jedis的方法和Redis的指令一一对应。 Jedis和lettuce都是可以操作redis的平台 使用时： 导包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </depend
springboot2 用lettuce客户端配置多个redisTemplate
java的平凡之路
09-11 3330
MAVEN依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <dependency> &l...
SpringBoot第42讲：SpringBoot集成Redis - 基于RedisTemplate+Lettuce数据操作
Jet_qi的博客
08-19 242
在SpringBoot 2.x版本中Redis默认客户端是Lettuce，本文是SpringBoot第42讲，主要介绍SpringBoot 和默认的 Lettuce 是一个可伸缩线程安全的 Redis 客户端。多个线程可以共享同一个 RedisConnection。它利用优秀 netty NIO 框架来高效地管理多个连接。Github官网支持 同步、异步、响应式 的方式支持 Redis Sentinel支持 Redis Cluster支持 SSL 和 Unix Domain Socket 连接支持
redis分布式锁实现
一朵纯洁的小白花的博客
04-27 1296
单体应用多线程锁 使用synchronized关键字或ReentrantLock类来保证线程的顺序执行 个别场景使用JDK1.5之后提供的大量原子类AtomicInteger（基于CAS的乐观锁） 测试锁模拟并发可使用闭锁：CountDownLatch类对象模拟 ReentrantLock的公平锁和非公平锁机制 ReentrantLock有两个构造方法，默认的构造方法中，sync = new NonfairSync();我们可以从字面意思看出它是一个非公平锁。再看看第二个构造方...
Redis高级客户端Lettuce详解
weixin_30567225的博客
09-28 2271
前提 Lettuce是一个Redis的Java驱动包，初识她的时候是使用RedisTemplate的时候遇到点问题Debug到底层的一些源码，发现spring-data-redis的驱动包在某个版本之后替换为Lettuce。Lettuce翻译为生菜，没错，就是吃的那种生菜，所以它的Logo长这样： 既然能被Spring生态所认可，Lettuce想必有过人之处，于是笔者花时间阅读她的官方...
RedisTemplate 概述 与 操作 Redis 5 种数据类型、事务
蚩尤后裔-汪茂雄
01-03 1万+
目录 RedisTemplate 概述 与 redis 配置 RedisTemplate 使用演示 字符串(String) 列表(List) 哈希(Hash) 集合(Set) 有序集合(sorted set) RedisTemplate 概述 与 redis 配置 1、Redis 是一个缓存、消息代理和功能丰富的键值存储。Spring Boot 为 Lettuce 和 Jedis...
redis的两种集群模式
frcoder的博客
06-24 948
一、哨兵模式和集群模式 从节点 的区别 哨兵模式中的从节点默认是可读的。 集群模式中的从节点默认是不可读的，只是主节点的热备。 如果想要从集群模式中的从节点读取数据，需要客户端在建立连接之后先发送一个readonly命令。 二、lettuce中对集群模式的处理 建立连接后，先查询集群信息，缓存哈希分槽，以后如果没有拓扑刷新就直接使用缓存的哈希分槽定位机器，不会每次随便连一个，等着服务器重定向； 如果连接的是从节点，会先发送一个readonly命令，然后这个连接以后就可以从从节点读取数据了； 执行向re
SpringBoot2.X整合Redis(单机+集群+多数据源)-Lettuce版
lonely_bin的博客
08-29 9823
Redis 三大客户端 简介 Jedis：是Redis 老牌的Java实现客户端，提供了比较全面的Redis命令的支持， Redisson：实现了分布式和可扩展的Java数据结构。 Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。 优点： Jedis：比较全面的提供了Redis的操作特性 Redisson：促使使用者对Redis的关...
springboot整合redis
qq_39746820的博客
05-05 1694
springboot整合redis
Redis 高级 Java 客户端 Lettuce 的用法及踩坑经验
热门推荐
GitChat
07-01 4万+
如果你在网上搜索 Redis 的 Java 客户端，你会发现，大多数文献介绍的都是 Jedis，不可否认，Jedis 是一个优秀的基于 Java 语言的 Redis 客户端，但是，其不足也很明显：Jedis 在实现上是直接连接 Redis-Server，在多个线程间共享一个 Jedis 实例时是线程不安全的，如果想要在多线程场景下使用 Jedis，需要使用连接池，每个线程都使用自己的 Jedis ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值