lettuce-core版本: 5.1.7.RELEASE
先看一下Lettuce的基本使用方法，使用Lettuce大概分为如下几步：
- 基于Redis连接信息创建RedisClient
- 基于RedisClient创建StatefulRedisConnection
- 从Connection中获取Command，基于Command执行Redis命令操作。
/** * @author xiaobing * @date 2019/12/20 */public class LettuceSimpleUse { private void testLettuce() throws ExecutionException, InterruptedException { //构建RedisClient对象，RedisClient包含了Redis的基本配置信息，可以基于RedisClient创建RedisConnection RedisClient client = RedisClient.create("redis://localhost"); //创建一个线程安全的StatefulRedisConnection，可以多线程并发对该connection操作,底层只有一个物理连接. StatefulRedisConnection connection = client.connect(); //获取SyncCommand。Lettuce支持SyncCommand、AsyncCommands、ActiveCommand三种command RedisStringCommands sync = connection.sync(); String value = sync.get("key"); System.out.println("get redis value with lettuce sync command, value is :" + value); //获取SyncCommand。Lettuce支持SyncCommand、AsyncCommands、ActiveCommand三种command RedisAsyncCommands async = connection.async(); RedisFuture getFuture = async.get("key"); value = getFuture.get(); System.out.println("get redis value with lettuce async command, value is :" + value); } public static void main(String[] args) throws ExecutionException, InterruptedException { new LettuceSimpleUse().testLettuce(); }}先看一张建立连接的时序图，有一个直观的印象。
lettuce源码--建立redis连接
RedisClient
一个可扩展、线程安全的RedisClient，支持sync、async、reactor执行模式。
RedisClient.create只是传入了一些配置信息，此时并没有创建连接。
// 使用默认的ClientResourcepublic static RedisClient create(String uri) { LettuceAssert.notEmpty(uri, "URI must not be empty"); return new RedisClient(null, RedisURI.create(uri));}// ClientResources中包含了一些配置和线程池信息，是一个比较重的资源，多个RedisClient可以共享同一个ClientResourceprotected RedisClient(ClientResources clientResources, RedisURI redisURI) { super(clientResources); assertNotNull(redisURI); this.redisURI = redisURI; setDefaultTimeout(redisURI.getTimeout()); }RedisClient.connnect
可以看到connect方法有一些重载方法，默认的是用UTF8 String对key和value序列化，通过传入RedisCodec支持自定义的对Key和Value的序列化方式。
public StatefulRedisConnection connect() { return connect(newStringStringCodec()); } public StatefulRedisConnection connect(RedisCodec codec) { checkForRedisURI(); //connectStandaloneAsync是异步创建connection，返回的是Future对象，通过getConnection转为同步操作 return getConnection(connectStandaloneAsync(codec, this.redisURI, timeout)); } //异步转同步操作 protected T getConnection(ConnectionFuture connectionFuture) { try { return connectionFuture.get(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw RedisConnectionException.create(connectionFuture.getRemoteAddress(), e); } catch (Exception e) { if (e instanceof ExecutionException) { throw RedisConnectionException.create(connectionFuture.getRemoteAddress(), e.getCause()); } throw RedisConnectionException.create(connectionFuture.getRemoteAddress(), e); } }RedisClient.connectStandaloneAsync
private ConnectionFuture> connectStandaloneAsync(RedisCodec codec, RedisURI redisURI, Duration timeout) { assertNotNull(codec); checkValidRedisURI(redisURI); logger.debug("Trying to get a Redis connection for: " + redisURI); //创建一个有状态的EndPoint用于抽象底层channel的实现，DefaultEndpoint内部封装断线重连、重连后成功后回放连接失败期间的command。同时封装了AT_MOST_ONCE、AT_LEAST_ONCE的可靠性实现(该逻辑是基于内存的，所以并不可靠)。 DefaultEndpoint endpoint = new DefaultEndpoint(clientOptions, clientResources); RedisChannelWriter writer = endpoint; //进一步封装，添加支持过期时间的执行命令 if (CommandExpiryWriter.isSupported(clientOptions)) { writer = new CommandExpiryWriter(writer, clientOptions, clientResources); } //创建StatefulRedisConnectionImpl对象，StatefulRedisConnectionImpl对外提供RedisCommand对象，内部基于writer发送命令。此时并没有真正的创建物理连接，该类本身是无状态、线程安全的。 StatefulRedisConnectionImpl connection = newStatefulRedisConnection(writer, codec, timeout); //异步创建Redis物理连接，返回future对象。后面可以看到future中返回的对象其实还是上面的connection ConnectionFuture> future = connectStatefulAsync(connection, codec, endpoint, redisURI, () -> new CommandHandler(clientOptions, clientResources, endpoint)); future.whenComplete((channelHandler, throwable) -> { if (throwable != null) { connection.close(); } }); return future; } //StatefulRedisConnectionImpl的构造函数，此时已经创建了sync、async、reactive三种类型的RedisCommand。基于RedisCodec对key和value序列化，通过write把命令真正的发出去。 public StatefulRedisConnectionImpl(RedisChannelWriter writer, RedisCodec codec, Duration timeout) { super(writer, timeout); this.codec = codec; this.async = newRedisAsyncCommandsImpl(); this.sync = newRedisSyncCommandsImpl(); this.reactive = newRedisReactiveCommandsImpl(); }RedisClient.connectStatefulAsync
private ConnectionFuture connectStatefulAsync(StatefulRedisConnectionImpl connection, RedisCodec codec, Endpoint endpoint, RedisURI redisURI, Supplier commandHandlerSupplier) { //构建ConnectionBuidler，通过ConnectionBuilder来创建connection ConnectionBuilder connectionBuilder; if (redisURI.isSsl()) { SslConnectionBuilder sslConnectionBuilder = SslConnectionBuilder.sslConnectionBuilder(); sslConnectionBuilder.ssl(redisURI); connectionBuilder = sslConnectionBuilder; } else { connectionBuilder = ConnectionBuilder.connectionBuilder(); } //填充StatefulRedisConnectionImpl connectionBuilder.connection(connection); //控制RedisClient行为的一些配置参数 connectionBuilder.clientOptions(clientOptions); //ClientResource包含了一些EventLoopGroup信息 connectionBuilder.clientResources(clientResources); //配置commandHandlerSupplier，这个commandHandler很重要，是实现StatefulRedisConnectionImpl线程安全的关键，后面会详细讲。 connectionBuilder.commandHandler(commandHandlerSupplier).endpoint(endpoint); //connectionBuilder填充Bootstrap等更多的信息 //getSocketAddressSupplier是根据redisURI获取真正的Redis连接信息，如：sentinel模式下，需要从sentinel获取到真实的redis连接地址 connectionBuilder(getSocketAddressSupplier(redisURI), connectionBuilder, redisURI); //配置netty的channeltype channelType(connectionBuilder, redisURI); if (clientOptions.isPingBeforeActivateConnection()) { if (hasPassword(redisURI)) { connectionBuilder.enableAuthPingBeforeConnect(); } else { connectionBuilder.enablePingBeforeConnect(); } } //初始化channel，在这一步才真正的异步的去创建物理连接 ConnectionFuture> future = initializeChannelAsync(connectionBuilder); ConnectionFuture> sync = future; if (!clientOptions.isPingBeforeActivateConnection() && hasPassword(redisURI)) { //连接成功之后发送auth命令，做密码的验证 sync = sync.thenCompose(channelHandler -> { CommandArgs args = new CommandArgs<>(codec).add(redisURI.getPassword()); return connection.async().dispatch(CommandType.AUTH, new StatusOutput<>(codec), args); }); } //设置clientName，从Redis服务端执行client list可以看到clientname if (LettuceStrings.isNotEmpty(redisURI.getClientName())) { sync = sync.thenApply(channelHandler -> { connection.setClientName(redisURI.getClientName()); return channelHandler; }); } //选择db if (redisURI.getDatabase() != 0) { sync = sync.thenCompose(channelHandler -> { CommandArgs args = new CommandArgs<>(codec).add(redisURI.getDatabase()); return connection.async().dispatch(CommandType.SELECT, new StatusOutput<>(codec), args); }); } //返回connection对象 return sync.thenApply(channelHandler -> (S) connection); }RedisClient.connectionBuilder
//为ConnectionBuidler填充更多的信息，如Bootstrap、channelGroupprotected void connectionBuilder(Mono socketAddressSupplier, ConnectionBuilder connectionBuilder, RedisURI redisURI) { //创建Netty客户端的Bootstrap对象 Bootstrap redisBootstrap = new Bootstrap(); //Bootstrap的一些配置参数，具体可以参考Netty的相关书籍(Netty权威指南) redisBootstrap.option(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, 32 * 1024); redisBootstrap.option(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, 8 * 1024); redisBootstrap.option(ChannelOption.ALLOCATOR, BUF_ALLOCATOR); SocketOptions socketOptions = getOptions().getSocketOptions(); redisBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(socketOptions.getConnectTimeout().toMillis())); if (LettuceStrings.isEmpty(redisURI.getSocket())) { //keepAlive参数，默认为true redisBootstrap.option(ChannelOption.SO_KEEPALIVE, socketOptions.isKeepAlive()); //tcp_nodelay参数，默认为true redisBootstrap.option(ChannelOption.TCP_NODELAY, socketOptions.isTcpNoDelay()); } connectionBuilder.timeout(redisURI.getTimeout()); connectionBuilder.password(redisURI.getPassword()); //把构建出来的bootStrap对象赋值给connectionBuidler，由connectionBuilder创建连接 connectionBuilder.bootstrap(redisBootstrap); //Netty的相关参数配置，待研究 connectionBuilder.channelGroup(channels).connectionEvents(connectionEvents).timer(timer); //配置socket地址提供者 connectionBuilder.socketAddressSupplier(socketAddressSupplier); }RedisClient.initializeChannelAsync
//初始化redis连接，返回ChannelFuture对象protected > ConnectionFuture initializeChannelAsync( ConnectionBuilder connectionBuilder) { Mono socketAddressSupplier = connectionBuilder.socketAddress(); if (clientResources.eventExecutorGroup().isShuttingDown()) { throw new IllegalStateException("Cannot connect, Event executor group is terminated."); } //创建socketAddressFuture 对象，当socketAddressSupplier异步获取SocketAddress成功之后会把SocketAddress数据放入该对象中 CompletableFuture socketAddressFuture = new CompletableFuture<>(); //创建channelReadyFuture，当连接建立成功之后会把Channel对象放入该对象中 CompletableFuture channelReadyFuture = new CompletableFuture<>(); //配置获取SocketAddress异步操作之后的操作： //1. 把SocketAddress对象放入socketAddressFuture中 //2. 基于SocketAddress调用initializeChannelAsync0方法真正去建立连接 socketAddressSupplier.doOnError(socketAddressFuture::completeExceptionally).doOnNext(socketAddressFuture::complete) .subscribe(redisAddress -> { if (channelReadyFuture.isCancelled()) { return; } //异步建立真正的连接，如果建立成功会把生产的Channel对象放入channelReadyFuture中 initializeChannelAsync0(connectionBuilder, channelReadyFuture, redisAddress); }, channelReadyFuture::completeExceptionally); //建立连接成功之后返回的还是connectionBuilder的connection对象，即StatefulRedisConnectionImpl return new DefaultConnectionFuture<>(socketAddressFuture, channelReadyFuture.thenApply(channel -> (T) connectionBuilder .connection())); }RedisClient.initializeChannelAsync0
//真正的去建立Redis物理连接，这里面有很多基于Future的异步操作，如果看不太懂，建议先看看Future的相关知识，多看几遍。private void initializeChannelAsync0(ConnectionBuilder connectionBuilder, CompletableFuture channelReadyFuture, SocketAddress redisAddress) { logger.debug("Connecting to Redis at {}", redisAddress); Bootstrap redisBootstrap = connectionBuilder.bootstrap(); //创建PlainChannelInitializer对象，PlainChannelIntializer对象会在Channel初始化的时候添加很多Handlers(Netty的Handler概念可以参考Netty权威指南)，如：CommandEncoder、CommandHandler(非常重要的Handler)、ConnectionWatchdog(实现断线重连) RedisChannelInitializer initializer = connectionBuilder.build(); //RedisChannelInitializer配置到Bootstrap中 redisBootstrap.handler(initializer); //调用一些通过ClientResources自定义的回调函数 clientResources.nettyCustomizer().afterBootstrapInitialized(redisBootstrap); //获取initFuture 对象，如果Channel初始化完成，可以通过该对象获取到初始化的结果 CompletableFuture initFuture = initializer.channelInitialized(); //真正的通过Netty异步的方式去建立物理连接，返回ChannelFuture对象 ChannelFuture connectFuture = redisBootstrap.connect(redisAddress); //配置异常处理 channelReadyFuture.whenComplete((c, t) -> { if (t instanceof CancellationException) { connectFuture.cancel(true); initFuture.cancel(true); } }); connectFuture.addListener(future -> { //异常处理 if (!future.isSuccess()) { logger.debug("Connecting to Redis at {}: {}", redisAddress, future.cause()); connectionBuilder.endpoint().initialState(); //赋值channelReadyFuture告知出现异常了 channelReadyFuture.completeExceptionally(future.cause()); return; } //当Channel初始化完成之后，根据初始化的结果做判断 initFuture.whenComplete((success, throwable) -> { //如果异常为空，则初始化成功。 if (throwable == null) { logger.debug("Connecting to Redis at {}: Success", redisAddress); RedisChannelHandler, ?> connection = connectionBuilder.connection(); connection.registerCloseables(closeableResources, connection); //把成功之后的结果赋值给channelReadyFuture对象 channelReadyFuture.complete(connectFuture.channel()); return; } //如果初始化Channel的过程中出现异常的处理逻辑 logger.debug("Connecting to Redis at {}, initialization: {}", redisAddress, throwable); connectionBuilder.endpoint().initialState(); Throwable failure; if (throwable instanceof RedisConnectionException) { failure = throwable; } else if (throwable instanceof TimeoutException) { failure = new RedisConnectionException("Could not initialize channel within " + connectionBuilder.getTimeout(), throwable); } else { failure = throwable; } //赋值channelReadyFuture告知出现异常了 channelReadyFuture.completeExceptionally(failure); }); }); }至此，Redis的Connection的建立连接的主流程就结束了，具体的一些逻辑如：断线重连是如何实现的，Redis模式下是怎么基于Sentinel获取Redis实际连接的等等会在后续的文章中介绍。
1398
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
