netty源码学习之服务端客户端初始化
文章目录
-
- 1. AbstractBootstrap类简介
-
- 1.1. 核心方法
- 2. netty服务端创建
-
- 2.1. 服务端启动入口
- 2.2. doBind()方法
- 2.3. netty服务初始化
-
- 2.3.1. initAndRegister()方法
- 2.3.2. init()方法
- 2.3.3. ServerBootstrapAcceptor作用
- 2.3.4. register()方法
-
- netty线程安全的特性
- register0方法
- 2.4. nety服务端口绑定
-
- 2.4.1 doBind0()方法
- 2.4.2 bind()方法
- 2.4.3. fireChannelActive()
- 3. netty客户端连接
-
- 3.1. netty客户端入口
- 3.2. doConnect()方法
- 3.3 doConnect0()
- 3.4. unsafe.connect
- 3.5. NioSocketChannel.doConnect()方法
- 4、netty一次请求响应过程总结
在之前的文章中我们学习了 netty的io模型、netty的使用分析、netty线程模型、netty的ChannelPipeline类学习、netty的ChannelPromise类学习。下面我们从使用netty例子出发探究一下netty的工作流程（其中包括服务端和客户端的创建、一次完整的请求和响应）。
1. AbstractBootstrap类简介
在探究netty一次请求的完整流程之前我们先来了解一下XXXBootstrap组件。 它是netty为我们提供的便于我们使用的工具启动类。他以builder的模式让我们可以简单设置例如channel、TCP参数、相关处理器。其中客户端使用Bootstrap类，服务端使用ServerBootstrap类两者的基类为AbstractBootstrap类。
1.1. 核心方法
AbstractBootstrap的
- bind()：netty服务端的与端口绑定,也是建立netty服务端的核心方法
Bootstrap的
- connect()：netty客户端与服务端进行连接，也是建立netty客户端的核心方法
补充说明：netty服务底层是使用NIO原理实现的，所以此处分析netty相关源码我们也分析到NIO层，至于NIO的底层原理实现请期待笔者后续的博文。
2. netty服务端创建
2.1. 服务端启动入口
netty服务端创建相关代码如下，服务端创建是使用bind()核心方法，下面来分析bind方法
//一、netty 服务端启动
//.......省略ServerBootstrap构建过程
//绑定端口 netty服务端创建
ChannelFuture sync = serverBootstrap.bind(port).sync();
//服务监听端口关闭
sync.channel().closeFuture().sync();
bind()方法最终调用io.netty.bootstrap.AbstractBootstrap#doBind()方法,下面我们来分析netty服务端启动方法。
2.2. doBind()方法
private ChannelFuture doBind(final SocketAddress localAddress) {
//正如其方法名一样 初始化channel,并进行channel和selector（多路复用器的注册绑定）
//其返回值是netty自己封装的异步结果接口ChannelFuture
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
//如果异步结果中有异常则直接返回 此时：netty服务端初始化失败
if (regFuture.cause() != null) {
return regFuture;
}
final ChannelPromise promise;
//上述的initAndRegister的结果是异步通知的 所有此处需要进行条件分支判断
//如果上述操作已经完成(通道初始化完成)则直接进行doBind0()方法
if (regFuture.isDone()) {
promise = channel.newPromise();
//channel和端口进行绑定操作
doBind0(regFuture, channel, localAddress, promise);
} else {
//一般情况下initAndRegister会很快完成并给出结果 但是万一呢？
promise = new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE);
//此处针对如果上述未完成 添加一个事件监听，待上述操作完成后触发doBind0()
regFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
doBind0(regFuture, channel, localAddress, promise);
}
});
}
return promise;
}
netty服务端启动和绑定过程并不复杂主要分成了两部分（两个核心方法）
- 初始化： initAndRegister方法，该方法主要功能是创建Channel对象(网络请求的数据流通道)，并整合ServerBootstrap相关配置比如工作线程(NioEventLoopGroup)、option(参数配置)、attr(属性)、添加相关处理器(ChannelHandler)，最后将多路复用器Selector注册到Channel。
- 端口绑定：doBind0方法，该方法主要将端口和channel进行绑定。
2.3. netty服务初始化
2.3.1. initAndRegister()方法
final ChannelFuture initAndRegister() {
Channel channel;
try {
//1、创建网络通道Channel
channel = createChannel();
} catch (Throwable t) {
return VoidChannel.INSTANCE.newFailedFuture(t);
}
try {
//2、为channel配置 线程、option、attr、事件处理器ChannelHandler
init(channel);
} catch (Throwable t) {
channel.unsafe().closeForcibly();
return channel.newFailedFuture(t);
}
ChannelPromise regFuture = channel.newPromise();
//channel注册多路复用器selector
channel.unsafe().register(regFuture);
if (regFuture.cause() != null) {
if (channel.isRegistered()) {
channel.close();
} else {
channel.unsafe().closeForcibly();
}
}
return regFuture;
}
netty服务端初始化也可以分成三部分
- 创建netty的channel对象，因为我们在构建的ServerBootstrap对象的时候调用了channel方法传入NioServerSocketChannel.class
//调用channel(NioServerSocketChannel.class)方法 会创建ServerBootstrapChannelFactory
return channelFactory(new ServerBootstrapChannelFactory<ServerChannel>(channelClass));
createChannel方法调用ServerBootstrapChannelFactory的newChannel()，通过反射调用NioServerSocketChannel的构造函数
//构建函数
public NioServerSocketChannel(EventLoop eventLoop, EventLoopGroup childGroup) {
//父构造函数 newSocket()创建一个NIO的ServerSocketChannel 和eventLoop线程以及工作线程childGroup
//包装成NioServerSocketChannel
super(null, eventLoop, childGroup, newSocket(), SelectionKey.OP_ACCEPT);
config = new DefaultServerSocketChannelConfig(this, javaChannel().socket());
}
- 初始化channel配置：init()方法整合ServerBootstrap相关配置比如工作线程(NioEventLoopGroup)、option(参数配置)、attr(属性)、添加相关处理器(ChannelHandler)并配置childHandler、currentChildOptions、currentChildAttrs包装成ServerBootstrapAcceptor
- channel注册selector:通过channel的unsafe对象(io.netty.channel.AbstractChannel.AbstractUnsafe)的register方法。
2.3.2. init()方法
在上述方法的第二部分init()方法初始化channel配置最终实现类为io.netty.bootstrap.ServerBootstrap#init。
void init(Channel channel) throws Exception {
//获取AbstractBootstrap的options(TCP配置信息) 设置到ChannelConfig中
final Map<ChannelOption<?>, Object> options = options();
synchronized (options) {
channel.config().setOptions(options);
}
//获取AbstractBootstrap的attr属性 设置到Attribute中
final Map<AttributeKey<?>, Object> attrs = attrs();
synchronized (attrs) {
for (Map.Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
@SuppressWarnings("unchecked")
AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
channel.attr(key).set(e.getValue());
}
}
//获取AbstractBootstrap的ChannelHandler 添加到ChannelHandlerPipline中
ChannelPipeline p = channel.pipeline();
if (handler() != null) {
p.addLast(handler());
}
//子类型的Handler、options、attrs (用户一般使用会创建ChannelInitializer 并通过initChannel
// 添加自定义的ChannelHandler)
final ChannelHandler currentChildHandler = childHandler;
final Map.Entry<ChannelOption<?>, Object>[] currentChildOptions;
final Map.Entry<AttributeKey<?>, Object>[] currentChildAttrs;
synchronized (childOptions) {
currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
}
synchronized (childAttrs) {
currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}
//将在ServerBootstrap通过childHandler()、childOptions()、childAttrs()等方法
// childHandler、currentChildOptions、currentChildAttrs 包装成ServerBootstrapAcceptor使用
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
//ServerBootstrapAcceptor
ch.pipeline().addLast(new ServerBootstrapAcceptor(currentChildHandler, currentChildOptions,
currentChildAttrs));
}
});
}
init()方法的分析可以分成如下部分，
-
options:通过ServerBootstrap设置的options添加到channel的ChannelConfig实例中（DefaultServerSocketChannelConfig实现类在createChannel方法中实现的）
-
attrs:通过ServerBootstrap设置的attrs添加到channel的Attribute中。
-
handler:过ServerBootstrap设置的handler添加到ChannelHandlerPipline中。
-
为通道添加一个ChannelInitializer实现类，该类是一个继承ChannelHandlerAdapter的抽象类，其只重写了channelRegistered事件，当channel通过后面的方法 channel.unsafe().register(regFuture) 注册后会触发其中的channelRegistered方法。
-
当前的channel进行注册成功后会将childHandler、currentChildOptions、currentChildAttrs 包装成ServerBootstrapAcceptor使用,ServerBootstrapAcceptor是一个特殊的ChannelHandler,该类也是继承了ChannelHandlerAdapter，其重写了channelRead事件,每当有一个客户端连接进来后，会先进入到ServerBootstrapAcceptor的channelRead()。
补充： channelRegistered事件：channel和selector注册后会触发该方法
channelRead事件：每当有一个客户端连接进来后，会先进入到ServerBootstrapAcceptor的channelRead(）
上述的4和5步骤我们需要了解ChannelInitializer实现，同时对ServerBootstrapAcceptor类作用进行介绍。
2.3.3. ServerBootstrapAcceptor作用
p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
//Channel添加ServerBootstrapAcceptor
ch.pipeline().addLast(new ServerBootstrapAcceptor(currentChildHandler, currentChildOptions,
currentChildAttrs));
}
});
在上述init()方法中最终在ChannelPipline通过addLast方法 添加了一个匿名实现ChannelInitializer
public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {
ChannelPipeline pipeline = ctx.pipeline();
boolean success = false;
try {
//提供的抽象方法 用于自定义实现
initChannel((C) ctx.channel());
//将其从ChannelPipline中移除
pipeline.remove(this);
//将channelRegistered事件透传到别的ChannelHandler
ctx.fireChannelRegistered();
success = true;
} catch (Throwable t) {
//异常处理
} finally {
}
}
ChannelInitializer类的作用是处理channelRegistered事件，主要是执行initChannel，然后移除本匿名ChannelInitializer实现类。结合上述netty源码，这里就是往pipline中添加ServerBootstrapAcceptor对象同时移除这里的ChannelInitializer实现类。
在之前的博文中netty的 线程模型 Reactor多线程模型中 netty会通过注册一个Acceptor事件处理器到mainReactor中，Acceptor事件处理器所关注的事件是ACCEPT事件，这样mainReactor会监听客户端向服务器端发起的连接请求事件(ACCEPT事件)，Acceptor会将客户端的I/O事件分发到sub Reactor线程池。 ServerBootstrapAcceptor对象的作用是那个所谓的Acceptor事件处理器，其重写了channelRead方法。
//该方法触发条件是 每一个客户端与服务端建立连接后都会调用该方法
public void channelRead(ChannelHandlerContext ctx, Object msg) {
//msg是客户端连接服务端创建的Channel(NioSocketChannel) 强转为Channel
Channel child = (Channel) msg;
//为ChannelPipeline添加childHandler（通过ServerBootstrap的childHandler()方法设置的）
child.pipeline().addLast(childHandler);
//childOptions配置到客户端Channel的ChannelConfig中
for (Entry<ChannelOption<?>, Object> e: childOptions) {
try {
if (!child.config().setOption((ChannelOption<Object>) e.getKey(), e.getValue())) {
logger.warn("Unknown channel option: " + e);
}
} catch (Throwable t) {
logger.warn("Failed to set a channel option: " + child, t);
}
}
//childOptions配置到客户端Channel的attr中
for (Entry<AttributeKey<?>, Object> e: childAttrs) {
child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
}
//客户端Channel进行注册
child.unsafe().register(child.newPromise());
}
这个方法和我们上面的init方法的Channel的注册逻辑相似。这里需要补充说明一下：Channel注册分为ServerSocketChannel和SockerChannel注册，服务端启动的时候会先进行ServerSocketChannel的注册，启动完成后，每当有一个客户端连接过来，会进行一次SocketChannel注册。所以之前的init方法注册的是netty服务端的channel而这里的注册是netty客户端的channel。
2.3.4. register()方法
下面我们继续来分析initAndRegister方法的第三部分注册，其调用不是由channel直接调用而是使用channel的工具类Unsafe类的register()方法去执行真正的注册逻辑。
public final void register(final ChannelPromise promise) {
//netty使用这种机制保证线程安全
//如果调用和eventloop是同一个线程 则直接调用
if (eventLoop.inEventLoop()) {
register0(promise);
} else {
try {
//否则将调用包装成任务交由eventloop
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
//异常处理
}
}
}
netty线程安全的特性
1.一个EventLoopGroup当中包含一个或多个EventLoop
2.一个EventLoop在其生命周期内只和唯一的一个Thread线程绑定（即一个io线程）
3.所有由EventLoop处理的各种io事件都将在其所关联的io线程上执行，因为是单线程保证了线程安全
4.一个Channel在其生命周期内只会注册在一个EventLoop（selector）上
5.运行期间，一个EventLoop会被分配给一个或多个channel
register0方法
private void register0(ChannelPromise promise) {
try {
//注册之前确保channel通道是打开状态
if (!ensureOpen(promise)) {
return;
}
//调用底层NIO的将Channel注册到selector(多路复用器)
doRegister();
registered = true;
promise.setSuccess();
//将channelRegistered事件透传（事件往后传递让别的对该事件感兴趣的
// ChannelHandler处理器进行处理） (这里我们所有实现了channelRegistered都有可能接受到该事件 调用自己initChannel方法)
pipeline.fireChannelRegistered();
//javaChannel().socket().isBound()
//isBound() 方法判断 ServerSocket 是否已经与一个端口绑定 此时应该没有绑定
if (isActive()) {
//产生一个channelActive事件 放入pipeline中
pipeline.fireChannelActive();
}
} catch (Throwable t) {
//异常处理
}
}
该方法主要分成三个部分
-
调用java底层的NIO的api将channel注册到eventLoop的selector（一个selector可以轮询处理多个线程，所以一个eventLoop可以和多个channel进行绑定），eventLoop的selector是创建EventLoopGroup的子EventLoop初始化的。 ops为0表明此处只简单的注册不对任何事件感兴趣。
-
fireChannelRegistered ：将channelRegistered事件透传（事件往后传递让别的对该事件感兴趣的ChannelHandler处理器进行处理）。
-
ServerSocket 如果和一个端口绑定了就产生一个channelActive事件 放入pipeline中。
2.4. nety服务端口绑定
2.4.1 doBind0()方法
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
//在触发channelRegistered()之前调用此方法。给用户处理程序一个设置的机会
channel.eventLoop().execute(new Runnable() {
@Override
public void run() {
//上述的initAndRegister()方法处理完成且成功
if (regFuture.isSuccess()) {
//服务端Channel进行端口绑定，并添加异步结果监听（绑定结果失败的话关闭channel）
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
//失败设置失败信息
promise.setFailure(regFuture.cause());
}
}
});
}
不解释，直接看channel的bind方法
2.4.2 bind()方法
//调用pipeline的bind方法
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
return pipeline.bind(localAddress, promise);
}
//调用pipeline管理的chanelHandler列表
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
return tail.bind(localAddress, promise);
}
//从tail往前查找对bind事件刚兴趣的ChannelHandler
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
DefaultChannelHandlerContext next = findContextOutbound(MASK_BIND);
next.invoker.invokeBind(next, localAddress, promise);
return promise;
}
//通过调用其运行环境invoker中的invokeBindNow方法
ctx.handler().bind(ctx, localAddress, promise);
//最终查找到header
public void bind(
ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
unsafe.bind(localAddress, promise);
}
调用链如下：
channel.bind()
-->pipeline.bind()
-->next.invoker.invokeBind()
-->header.bind()
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
//确保
if (!ensureOpen(promise)) {
return;
}
//端口绑定之前 wasActive 为false
//调用方法isBound() 方法判断 ServerSocket 是否已经与一个端口绑定
boolean wasActive = isActive();
try {
//最终调用java原生NIO api进行端口绑定
doBind(localAddress);
} catch (Throwable t) {
}
//端口绑定后isActive() 为true 则此时产生一个channelActive事件
if (!wasActive && isActive()) {
invokeLater(new Runnable() {
@Override
public void run() {
//产生channelActive事件放入管道 同时selector监听ON_ACCEPT事件
pipeline.fireChannelActive();
}
});
}
//成功异步操作标识
promise.setSuccess();
}
两部分
- 调用java原生NIO api进行端口绑定。
- 产生channelActive事件放入管道。同时该方法还会给多路复用器添加一个ON_ACCEPT事件，服务端准备就绪可以接收客户端的连接请求。
2.4.3. fireChannelActive()
上述服务端创建过程以经接近尾声，channel完成了初始化、同时注册了多路复用器(监听的事件是0)不对任何事件感兴趣，这里是有点疑问，后续客户端连接和读写事件怎么处理？别着急这里为多路复用器添加感兴趣的事件在fireChannelActive方法中 下面我们来看看该方法逻辑
public ChannelPipeline fireChannelActive() {
//触发pipeline中ChannelHandler的channelActive事件
head.fireChannelActive();
//调用chanel的read(autoRead属性默认为true)
if (channel.config().isAutoRead()) {
//调用链如下：
// channel.read()
// -----> pipeline.read
// ------>tail.read() 从tail往上查找符合MASK_READ的ChannelHandler 这里找到的是headHandler
// ------>unsafe.beginRead(); 调用channel的unsafe
//。 ------> unsafe.doBeginRead();找到最终调用，我们分析一下该方法
channel.read();
}
return this;
}
protected void doBeginRead() throws Exception {
if (inputShutdown) {
return;
}
//获取当前channel感兴趣的SelectionKey（java的NIO四种事件集合）
final SelectionKey selectionKey = this.selectionKey;
if (!selectionKey.isValid()) {
return;
}
final int interestOps = selectionKey.interestOps();
//readInterestOp是该channel在初始化阶段传入的ON_ACCEPT事件
//所以此处将channel的interestOps为0 添加监听ON_ACCEPT事件
if ((interestOps & readInterestOp) == 0) {
selectionKey.interestOps(interestOps | readInterestOp);
}
netty服务端经历了Channel的初始化、注册多路复用器、绑定端口、添加对客户端连接事件的监听分析到这里有关netty服务端创建过程完成。贴一个完成的流程图
3. netty客户端连接
3.1. netty客户端入口
netty客户端创建相关代码如下，服务端创建是使用bind()核心方法，下面来分析bind方法
//一、netty 客户端启动
//.......省略Bootstrap构建过程
//发起异步连接请求
ChannelFuture sync = bootstrap.connect(host,port).sync();
//客户端监听端口关闭
sync.channel().closeFuture().sync();
connect()方法最终调用io.netty.bootstrap.AbstractBootstrap#doConnect()方法,下面我们来分析netty客户端连接方法。其实netty客户端建立连接的过程和netty服务端启动过程类似，这里我们也只对区别说明。
3.2. doConnect()方法
private ChannelFuture doConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
//netty客户端初始化类似netty服务端类似
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
if (regFuture.cause() != null) {
return regFuture;
}
final ChannelPromise promise = channel.newPromise();
//此处不再是doBind0方法而是doConnect0方法
if (regFuture.isDone()) {
doConnect0(regFuture, channel, remoteAddress, localAddress, promise);
} else {
regFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
doConnect0(regFuture, channel, remoteAddress, localAddress, promise);
}
});
}
return promise;
}
netty服务端启动和绑定过程并不复杂主要分成了两部分（两个核心方法）
-
初始化： initAndRegister方法，该方法主要功能是创建Channel对象(网络请求的数据流通道)，
-
createChannel方法netty客户端是通过BootstrapChannelFactory对象创建的是NioSocketChannel实例，netty服务端是通过ServerBootstrapChannelFactory对象创建NioServerSocketChannel。
-
init（Bootstrap实现）方法只是添加handler、options、attr,netty服务端init(ServerBootstrap) 还会将child相关配置包装成ServerBootstrapAcceptor。
-
register0实现方式两者一致
-
-
连接建立：doConnect0方法，该方法绑定客户端channel并和netty服务端建立连接。着重描述。
3.3 doConnect0()
private static void doConnect0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
channel.eventLoop().execute(new Runnable() {
@Override
public void run() {
if (regFuture.isSuccess()) {
//客户端连接建立
if (localAddress == null) {
channel.connect(remoteAddress, promise);
} else {
channel.connect(remoteAddress, localAddress, promise);
}
//连接建立失败监听 关键channel
promise.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
promise.setFailure(regFuture.cause());
}
}
});
}
调用链如下：
pipeline.connect(remoteAddress, localAddress, promise)
--------->tail.connect(remoteAddress, localAddress, promise)
---------->findContextOutbound //从tail往前查找对connect感兴趣的HeadHandler
---------->unsafe.connect(remoteAddress, localAddress, promise) //最终调用unsafe.connect
3.4. unsafe.connect
connect实际调用的是AbstractNioUnsafe的connect方法
public void connect(
final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
if (!ensureOpen(promise)) {
return;
}
try {
if (connectPromise != null) {
throw new IllegalStateException("connection attempt already made");
}
boolean wasActive = isActive();
//调用Java原生API 与服务端建立连接。
//连接立即建立的话直接调用fulfillConnectPromise(作用是连接建立完成触发channelActive和channel的read方法，
//表示通道中已经有了可读的数据，可以执行读操作了)
if (doConnect(remoteAddress, localAddress)) {
fulfillConnectPromise(promise, wasActive);
} else {
//否则异步处理连接请求
connectPromise = promise;
requestedRemoteAddress = remoteAddress;
//如果设置了超时事件则创建一个延时任务（延时事件即为超时时间，里面用来处理超时连接的问题）
int connectTimeoutMillis = config().getConnectTimeoutMillis();
if (connectTimeoutMillis > 0) {
connectTimeoutFuture = eventLoop().schedule(new Runnable() {
@Override
public void run() {
ChannelPromise connectPromise = AbstractNioChannel.this.connectPromise;
ConnectTimeoutException cause =
new ConnectTimeoutException("connection timed out: " + remoteAddress);
if (connectPromise != null && connectPromise.tryFailure(cause)) {
close(voidPromise());
}
}
}, connectTimeoutMillis, TimeUnit.MILLISECONDS);
}
//注册一个连接完成的监听 如果完成说明异步连接成功 则取消之前超时处理延迟任务
promise.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isCancelled()) {
if (connectTimeoutFuture != null) {
connectTimeoutFuture.cancel(false);
}
connectPromise = null;
close(voidPromise());
}
}
});
}
} catch (Throwable t) {
//省略异常处理
}
}
方法逻辑如下：
1. doConnect 调用原生java API 进行和服务端建立连接
2. 连接立即建立：接着调用fulfillConnectPromise 触发客户端的读请求 发送数据到channel
3. 连接异步建立：设置超时任务处理连接（连接成功后该Channel注册在NioEventLoop上selector会轮循所有的事件进行处理）可以进行后续的读请求处理。
3.5. NioSocketChannel.doConnect()方法
@Override
protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
if (localAddress != null) {
//调用原生java NIO 客户端socket绑定端口
javaChannel().socket().bind(localAddress);
}
boolean success = false;
try {
//调用原生java NIO 客户端socket发起服务端建立连接
//此时客户端会在服务端channel ON_ACCEPT事件 此时服务端添加的ServerBootstrapAcceptor对象的
//channelRead方法为服务端处理请求添加业务自定义的ChannelHandler。
boolean connected = javaChannel().connect(remoteAddress);
if (!connected) {
//连接建立是异步的
//所以此处该channel还需要监听 服务端建立完连接的ON_CONNECT事件
selectionKey().interestOps(SelectionKey.OP_CONNECT);
}
success = true;
return connected;
} finally {
if (!success) {
doClose();
}
}
}
4、netty一次请求响应过程总结
