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只是传入了一些配置信息，此时并没有创建连接。
// 使用默认的ClientResource
public static RedisClient create(String uri) {
LettuceAssert.notEmpty(uri, "URI must not be empty");
return new RedisClient(null, RedisURI.create(uri));
}
// ClientResources中包含了一些配置和线程池信息，是一个比较重的资源，多个RedisClient可以共享同一个ClientResource
protected 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、channelGroup
protected 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实际连接的等等会在后续的文章中介绍。