13 KiB
相对于服务端，Netty客户端 的创建更加复杂，除了要考虑线程模型、异步连接、客户端连接超时等因素外，还需要对连接过程中的各种异常进行考虑。本章将对 Netty客户端 创建的关键流程和源码进行分析，以期读者能够了解客户端创建的细节。
基于 Netty 创建客户端的流程分析
Netty 为了向使用者屏蔽 NIO通信 的底层细节，在和用户交互的边界做了封装，目的就是为了减少用户开发工作量，降低开发难度。Bootstrap 是 Socket 客户端创建工具类，用户通过 Bootstrap 可以方便地创建 Netty 的客户端并发起 异步TCP连接操作。
基于 Netty 创建客户端 时序图
Netty 创建客户端 流程分析
- 用户线程创建 Bootstrap实例，通过 API 设置客户端相关的参数，异步发起客户端连接；
- 创建处理客户端连接、I/O 读写的 Reactor线程组 NioEventLoopGroup。可以通过构造函数指定 IO线程 的个数，默认为 CPU 内核数的 2 倍；
- 通过 Bootstrap 的 ChannelFactory 和用户指定的 Channel类型 创建用于客户端连接的 NioSocketChannel，它的功能类似于 JDK NIO类库 提供的 SocketChannel；
- 创建默认的 Channel、Handler、Pipeline，用于调度和执行网络事件；
- 异步发起 TCP连接，判断连接是否成功。如果成功，则直接将 NioSocketChannel 注册到多路复用器上，监听读操作位，用于数据报读取和消息发送；如果没有立即连接成功，则注册连接监听位到多路复用器，等待连接结果；
- 注册对应的网络监听状态位到多路复用器；
- 由多路复用器在 IO 现场中轮询各 Channel，处理连接结果；
- 如果连接成功，设置 Future结果，发送连接成功事件，触发 ChanneIPipeline 执行；
- 由 ChannelPipeline 调度执行系统和用户的 ChannelHandler，执行业务逻辑。
Netty 客户端创建源码分析
Netty客户端 的创建流程比较繁琐，下面我们针对关键步骤和代码进行分析，通过梳理关键流程来掌握客户端创建的原理。
客户端连接辅助类 BootStrap
Bootstrap 是 Netty 提供的客户端连接工具类，主要用于简化客户端的创建，下面我们对它的 主要API 进行讲解。
设置 lO线程组：NIO的特点就是，一个多路复用器可以同时处理上干条链路，这就意味着，NIO模式中 一个线程可以处理多个 TCP连接。考虑到 lO线程 的处理性能，大多数 NIO框架 都采用线程池的方式处理 IO读写，Netty 也不例外。客户端相对于服务端，只需要一个处理 IO读写 的线程组即可，因为 Bootstrap 提供了 设置IO线程组 的接口，代码如下。
public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
volatile EventLoopGroup group;
public B group(EventLoopGroup group) {
if (group == null) {
throw new NullPointerException("group");
} else if (this.group != null) {
throw new IllegalStateException("group set already");
} else {
this.group = group;
return this;
}
}
}
由于 Netty 的 NIO线程组 默认采用 EventLoopGroup接口，因此线程组参数使用 EventLoopGroup。
TCP参数设置接口：无论是 NIO，还是 BIO，创建客户端套接字的时候通常都会设置连接参数，例如接收和发送缓冲区大小、连接超时时间等。Bootstrap 也提供了客户端 TCP参数设置接口，代码如下。
public <T> B option(ChannelOption<T> option, T value) {
if (option == null) {
throw new NullPointerException("option");
} else {
if (value == null) {
synchronized(this.options) {
this.options.remove(option);
}
} else {
synchronized(this.options) {
this.options.put(option, value);
}
}
return this;
}
}
Netty 提供的 主要TCP参数 如下。
1、SO_TIMEOUT：控制读取操作将阻塞多少毫秒。如果返回值为0，计时器就被禁止了，该线程将无限期阻塞； 2、SO_SNDBUF：套接字使用的发送缓冲区大小； 3、SO_RCVBUF：套接字使用的接收缓冲区大小； 4、SO_REUSEADDR：用于决定 如果网络上仍然有数据向旧的 ServerSocket 传输数据，是否允许新的 ServerSocket 绑定到与旧的 ServerSocket 同样的端口上。SO_REUSEADDR选项 的默认值与操作系统有关，在某些操作系统中，允许重用端口，而在某些操作系统中不允许重用端口； 5、CONNECT_TIMEOUT_MILLIS：客户端连接超时时间，由于 NIO原生的客户端 并不提供设置连接超时的接口，因此，Netty 采用的是自定义连接超时定时器负责检测和超时控制；
Channel接口：用于指定客户端使用的 Channel接口，对于 TCP客户端连接，默认使用 NioSocketChannel，代码如下。
public B channel(Class<? extends C> channelClass) {
if (channelClass == null) {
throw new NullPointerException("channelClass");
} else {
return this.channelFactory((io.netty.channel.ChannelFactory)(new ReflectiveChannelFactory(channelClass)));
}
}
BootstrapChannelFactory 利用 参数channelClass，通过反射机制创建 NioSocketChannel对象。
设置 Handler接口：Bootstrap 为了简化 Handler 的编排，提供了 Channellnitializer，它继承了 ChannelHandlerAdapter，当 TCP链路 注册成功之后，调用 initChannel 接口，用于设置用户 ChanneIHandler。它的代码如下。
public abstract class ChannelInitializer<C extends Channel> extends ChannelInboundHandlerAdapter {
public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {
if (this.initChannel(ctx)) {
ctx.pipeline().fireChannelRegistered();
} else {
ctx.fireChannelRegistered();
}
}
}
最后一个比较重要的接口就是发起客户端连接，代码如下。
ChannelFuture f = b.connect(host, port).sync();
客户端连接操作
首先要创建和初始化 NioSocketChannel，代码如下。
public class Bootstrap extends AbstractBootstrap<Bootstrap, Channel> {
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
if (remoteAddress == null) {
throw new NullPointerException("remoteAddress");
} else {
this.validate();
return this.doResolveAndConnect(remoteAddress, localAddress);
}
}
private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
// 首先要创建和初始化 NioSocketChannel
ChannelFuture regFuture = this.initAndRegister();
final Channel channel = regFuture.channel();
if (regFuture.isDone()) {
// 初始化 Channel 之后，将其注册到 Selector 上
return !regFuture.isSuccess() ? regFuture : this.doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
} else {
final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
regFuture.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
Throwable cause = future.cause();
if (cause != null) {
promise.setFailure(cause);
} else {
promise.registered();
Bootstrap.this.doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
}
}
});
return promise;
}
}
private ChannelFuture doResolveAndConnect0(final Channel channel, SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
try {
EventLoop eventLoop = channel.eventLoop();
AddressResolver<SocketAddress> resolver = this.resolver.getResolver(eventLoop);
if (!resolver.isSupported(remoteAddress) || resolver.isResolved(remoteAddress)) {
doConnect(remoteAddress, localAddress, promise);
return promise;
}
Future<SocketAddress> resolveFuture = resolver.resolve(remoteAddress);
if (resolveFuture.isDone()) {
Throwable resolveFailureCause = resolveFuture.cause();
if (resolveFailureCause != null) {
channel.close();
promise.setFailure(resolveFailureCause);
} else {
doConnect((SocketAddress)resolveFuture.getNow(), localAddress, promise);
}
return promise;
}
resolveFuture.addListener(new FutureListener<SocketAddress>() {
public void operationComplete(Future<SocketAddress> future) throws Exception {
if (future.cause() != null) {
channel.close();
promise.setFailure(future.cause());
} else {
Bootstrap.doConnect((SocketAddress)future.getNow(), localAddress, promise);
}
}
});
} catch (Throwable var9) {
promise.tryFailure(var9);
}
return promise;
}
private static void doConnect(final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise connectPromise) {
final Channel channel = connectPromise.channel();
channel.eventLoop().execute(new Runnable() {
public void run() {
if (localAddress == null) {
channel.connect(remoteAddress, connectPromise);
} else {
channel.connect(remoteAddress, localAddress, connectPromise);
}
connectPromise.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
}
});
}
}
需要注意的是，SocketChannel 执行 connect() 操作后有以下三种结果。
- 连接成功，返回True；
- 暂时没有连接上，服务端没有返回 ACK应答，连接结果不确定，返回False；
- 连接失败，直接抛出 IO异常。
如果是第二种结果，需要将 NioSocketChannel 中的 selectionKey 设置为 OP_CONNECT，监听连接结果。异步连接返回之后，需要判断连接结果，如果连接成功，则触发 ChannelActive 事件。ChannelActive事件 最终会将 NioSocketChannel 中的 selectionKey 设置为 SelectionKey.OP_READ，用于监听网络读操作。如果没有立即连接上服务端，则注册 SelectionKey.OP_CONNECT 到多路复用器。如果连接过程发生异常，则关闭链路，进入连接失败处理流程。
异步连接结果通知
NioEventLoop 的 Selector 轮询 客户端连接Channel，当服务端返回握手应答之后，对连接结果进行判断，代码如下。
if ((readyOps & 8) != 0) {
int ops = k.interestOps();
ops &= -9;
k.interestOps(ops);
unsafe.finishConnect();
}
下面对 finishConnect()方法 进行分析，代码如下。
try {
boolean wasActive = AbstractNioChannel.this.isActive();
AbstractNioChannel.this.doFinishConnect();
this.fulfillConnectPromise(AbstractNioChannel.this.connectPromise, wasActive);
} catch (Throwable var5) {
......
}
doFinishConnect()方法 用于判断 JDK 的 SocketChannel 的连接结果，如果未出错 表示连接成功，其他值或者发生异常表示连接失败。
protected void doFinishConnect() throws Exception {
if (!this.javaChannel().finishConnect()) {
throw new Error();
}
}
连接成功之后，调用 fufillConectPromise()方法，触发链路激活事件，该事件由 ChannelPipeline 进行传播。
客户端连接超时机制
对于SocketChannel接口，JDK并没有提供连接超时机制，需要NIO框架或者用户自己扩展实现。Netty利用定时器提供了客户端连接超时控制功能，下面我们对该功能进行详细讲解。
首先,用户在创建Netty 客户端的时候，可以通过ChannelOption.CONNECT_TIMEOUT_MILLIS配置项设置连接超时时间，代码如下。
Bootstrap b = new Bootstrap();
b.group(workerGroup);
b.channel(NioSocketChannel.class);
b.option(ChannelOption.SO_KEEPALIVE, true);
b.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000);