netty服务端客户端启动流程分析
服务端启动流程
我们回顾前面讲解的netty启动流程，服务端这边有两个EventLoopGroup，一个专门用来处理连接，一个用来处理后续的io事件
服务端启动还是跟nio一样，绑定端口进行监听，我们先来看绑定流程
// 绑定端口并同步阻塞直到绑定结束 ChannelFuture cf = serverBootstrap.bind(8080).sync(); private ChannelFuture doBind(final SocketAddress localAddress) { // 注册一个NioServerScoketChannel final ChannelFuture regFuture = initAndRegister(); final Channel channel = regFuture.channel(); if (regFuture.cause() != null) { return regFuture; } if (regFuture.isDone()) { // 注册完成 进行端口绑定，并返回一个异步绑定结果 ChannelPromise promise = channel.newPromise(); // 绑定端口 doBind0(regFuture, channel, localAddress, promise); return promise; } else { // 未注册完成 返回带注册结果的promise final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel); // 添加一个注册异步监听器 但注册完成会进行绑定操作 regFuture.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { Throwable cause = future.cause(); if (cause != null) { // 注册时有发生异常 通知相关监听器 promise.setFailure(cause); } else { // 设置注册结果为true promise.registered(); // 绑定端口 doBind0(regFuture, channel, localAddress, promise); } } }); return promise; } } final ChannelFuture initAndRegister() { Channel channel = null; try { /** * 通过我们之前设置的socket类型进行实例化 * serverBootstrap.channel(NioServerSocketChannel.class) 会返回一个ReflectiveChannelFactory工厂 **/ channel = channelFactory.newChannel(); // 1 // 初始化channel init(channel); // 2 } catch (Throwable t) { if (channel != null) { // 发生异常 将内部nio中的channel进行关闭 channel.unsafe().closeForcibly(); // 返回一个结果失败的Promise return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t); } return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t); } // 将channel注册到bossEventLoopGroup上，里面会将channel注册到EventLoop中的selector ChannelFuture regFuture = config().group().register(channel); // 3 if (regFuture.cause() != null) { if (channel.isRegistered()) { channel.close(); } else { channel.unsafe().closeForcibly(); } } return regFuture; } private static void doBind0( final ChannelFuture regFuture, final Channel channel, final SocketAddress localAddress, final ChannelPromise promise) { // 添加一个异步绑定任务 channel.eventLoop().execute(new Runnable() { @Override public void run() { if (regFuture.isSuccess()) {
// 绑定！！！ channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE); // 4 } else { promise.setFailure(regFuture.cause()); } } }); }
对上述流程进行一个简单的说明: 先创建一个NioServerScoketChannel，然后进行初始化操作，然后注册到bossEventLoop中selector上，nio需要做的流程 netty都要做，然后进行绑定 返回一个绑定异步promise
绑定流程有4个比较重要的操作 我们来一一详解
1、实例化NioServerScoketChannel，内部会创建一个ServerSocketChannel 然后持有，同时创建unsafe和pipeline
/***********************NioServerSocketChannel**********************/ // selector提供者，提供创建selector、ServerSocketChannel、SocketChannel private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider(); public NioServerSocketChannel() { this(newSocket(DEFAULT_SELECTOR_PROVIDER)); } private static ServerSocketChannel newSocket(SelectorProvider provider) { try { // 返回一个nio中的ServerSocketChannel return provider.openServerSocketChannel(); } catch (IOException e) { throw new ChannelException( "Failed to open a server socket.", e); } } public NioServerSocketChannel(ServerSocketChannel channel) { // 调用父类构造 super(null, channel, SelectionKey.OP_ACCEPT); // NioServerSocketChannel配置类 config = new NioServerSocketChannelConfig(this, javaChannel().socket()); } /***********************AbstractNioChannel***********************/ protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) { super(parent); this.ch = ch; this.readInterestOp = readInterestOp; try { // 将ServerSocketChannel设置为非阻塞 ch.configureBlocking(false); } catch (IOException e) { try { ch.close(); } catch (IOException e2) { if (logger.isWarnEnabled()) { logger.warn( "Failed to close a partially initialized socket.", e2); } } throw new ChannelException("Failed to enter non-blocking mode.", e); } }
/***********************AbstractChannel*************************/ protected AbstractChannel(Channel parent) { this.parent = parent; id = newId(); // 创建一个unsafe 实例为NioMessageUnsafe类型 unsafe = newUnsafe(); // 创建pipeline,类型为DefaultChannelPipeline pipeline = newChannelPipeline(); } /***********************DefaultChannelPipeline*************************/ protected DefaultChannelPipeline(Channel channel) { this.channel = ObjectUtil.checkNotNull(channel, "channel"); succeededFuture = new SucceededChannelFuture(channel, null); voidPromise = new VoidChannelPromise(channel, true); tail = new TailContext(this); head = new HeadContext(this); head.next = tail; tail.prev = head; }
2、初始化NioServerScoketChannel
/***********************ServerBootstrap*************************/ void init(Channel channel) throws Exception { final Map<ChannelOption<?>, Object> options = options0(); // 设置我们之前设置的options serverBootstrap.option(ChannelOption<T> option, T value) synchronized (options) { setChannelOptions(channel, options, logger); } // 设置channel自定义属性 final Map<AttributeKey<?>, Object> attrs = attrs0(); synchronized (attrs) { for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) { @SuppressWarnings("unchecked") AttributeKey<Object> key = (AttributeKey<Object>) e.getKey(); channel.attr(key).set(e.getValue()); } } ChannelPipeline p = channel.pipeline(); final EventLoopGroup currentChildGroup = childGroup; final ChannelHandler currentChildHandler = childHandler; final Entry<ChannelOption<?>, Object>[] currentChildOptions; final Entry<AttributeKey<?>, Object>[] currentChildAttrs; synchronized (childOptions) { currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size())); } synchronized (childAttrs) { currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size())); } // 添加一个ChannelInitializer，用来注册后续的NioSocketChannel p.addLast(new ChannelInitializer<Channel>() { @Override public void initChannel(final Channel ch) throws Exception { final ChannelPipeline pipeline = ch.pipeline(); ChannelHandler handler = config.handler(); if (handler != null) { pipeline.addLast(handler); } ch.eventLoop().execute(new Runnable() { @Override public void run() { // 这个handler就是后续监听客户端连接事件后，会将创建的NioSocketChannel 在这里进行注册 pipeline.addLast(new ServerBootstrapAcceptor( ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); } }); } }); } private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter { ServerBootstrapAcceptor( final Channel channel, EventLoopGroup childGroup, ChannelHandler childHandler, Entry<ChannelOption<?>, Object>[] childOptions, Entry<AttributeKey<?>, Object>[] childAttrs) { this.childGroup = childGroup; this.childHandler = childHandler; this.childOptions = childOptions; this.childAttrs = childAttrs; enableAutoReadTask = new Runnable() { @Override public void run() { channel.config().setAutoRead(true); } }; } @Override @SuppressWarnings("unchecked") public void channelRead(ChannelHandlerContext ctx, Object msg) { // NioServerScoketChannel在监听accpet后会创建一个NioSocketChannel 然后调用handler将该channel传递进来,handler那边只是简单的创建 并没有完成注册 final Channel child = (Channel) msg; // 在serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>()添加的handler 加入到NioSocketChannel child.pipeline().addLast(childHandler); // 设置NioSocketChannel的Options setChannelOptions(child, childOptions, logger); // 设置NioSocketChannel的attr for (Entry<AttributeKey<?>, Object> e: childAttrs) { child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue()); } try { // 将NioSocketChannel注册到workerEventLoopGroup上 然后添加一个监听器 childGroup.register(child).addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { if (!future.isSuccess()) { forceClose(child, future.cause()); } } }); } catch (Throwable t) { forceClose(child, t); } } private static void forceClose(Channel child, Throwable t) { child.unsafe().closeForcibly(); logger.warn("Failed to register an accepted channel: {}", child, t); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { final ChannelConfig config = ctx.channel().config(); if (config.isAutoRead()) { // 将autoread设置为false，一秒后重新设置为true config.setAutoRead(false); ctx.channel().eventLoop().schedule(enableAutoReadTask, 1, TimeUnit.SECONDS); } ctx.fireExceptionCaught(cause); } }
上图大致流程：将之前在ServerBootstrap设置的属性在这里相应设置，然后给NioServerScoketChannel添加一个处理器，这个处理器用来接收accept请求时将后续的NioSocketChannel注册到对应的workerEventLoop中，后续的io事件就交给NioSocketChannel来完成
3、channel注册到EventLoop，其实就是将channel注册到EventLoop中的selector上
/************************MultithreadEventLoopGroup*********************/ public ChannelFuture register(Channel channel) { return next().register(channel); } /***********************MultithreadEventExecutorGroup**********************/ public EventExecutor next() { // 选择一个EventLoop return chooser.next(); } /***********************SingleThreadEventLoop**********************/ public ChannelFuture register(Channel channel) { return register(new DefaultChannelPromise(channel, this)); } public ChannelFuture register(final ChannelPromise promise) { // 拿到channel对应的Unsafe进行注册 promise.channel().unsafe().register(this, promise); return promise; } /***********************AbstractUnsafe**********************/ public final void register(EventLoop eventLoop, final ChannelPromise promise) { AbstractChannel.this.eventLoop = eventLoop; if (eventLoop.inEventLoop()) { register0(promise); } else { try { eventLoop.execute(new Runnable() { @Override public void run() { register0(promise); } }); } catch (Throwable t) { closeForcibly(); closeFuture.setClosed(); safeSetFailure(promise, t); } } } private void register0(ChannelPromise promise) { try { // 判断当前注册promise是否被取消或者channel通道是否还处于打开状态 if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } boolean firstRegistration = neverRegistered; // 进行nio注册 doRegister(); neverRegistered = false; registered = true; // 注册好后调用我们之前设置的channelInitializer.initChannel(channel) 方法 pipeline.invokeHandlerAddedIfNeeded(); // 设置状态成功 safeSetSuccess(promise); // 注册成功事件传播 pipeline.fireChannelRegistered(); // 完成注册正好是active状态 if (isActive()) { if (firstRegistration) { pipeline.fireChannelActive(); } else if (config().isAutoRead()) { beginRead(); } } } catch (Throwable t) { closeForcibly(); closeFuture.setClosed(); safeSetFailure(promise, t); } } /***********************AbstractNioUnsafe**********************/ protected void doRegister() throws Exception { boolean selected = false; for (;;) { try { // 将channel注册到EventLoop上的selector selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this); return; } catch (CancelledKeyException e) { if (!selected) { eventLoop().selectNow(); selected = true; } else { throw e; } } } }
4、绑定端口,通过pipeline.bind发起绑定，绑定端口是出站事件，由tail像前进行传递，直到执行到head的bind()方法，然后通过其中的unsafe调用NioServerScoketChannel的doBind()进行绑定
/************************tailHandler*********************/ public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) { final AbstractChannelHandlerContext next = findContextOutbound(); EventExecutor executor = next.executor(); if (executor.inEventLoop()) { next.invokeBind(localAddress, promise); } else { safeExecute(executor, new Runnable() { @Override public void run() { next.invokeBind(localAddress, promise); } }, promise, null); } return promise; } private void invokeBind(SocketAddress localAddress, ChannelPromise promise) { if (invokeHandler()) { try { ((ChannelOutboundHandler) handler()).bind(this, localAddress, promise); } catch (Throwable t) { notifyOutboundHandlerException(t, promise); } } else { bind(localAddress, promise); } } /************************headHandler*********************/ public void bind( ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) throws Exception { unsafe.bind(localAddress, promise); } /************************AbstractUnsafe*********************/ public final void bind(final SocketAddress localAddress, final ChannelPromise promise) { assertEventLoop(); if (!promise.setUncancellable() || !ensureOpen(promise)) { return; } boolean wasActive = isActive(); try { doBind(localAddress); } catch (Throwable t) { safeSetFailure(promise, t); closeIfClosed(); return; } if (!wasActive && isActive()) { invokeLater(new Runnable() { @Override public void run() { pipeline.fireChannelActive(); } }); } safeSetSuccess(promise); } /************************NioServerSocketChannel*********************/ protected void doBind(SocketAddress localAddress) throws Exception { if (PlatformDependent.javaVersion() >= 7) { javaChannel().bind(localAddress, config.getBacklog()); } else { javaChannel().socket().bind(localAddress, config.getBacklog()); } }
服务端的启动流程就讲的差不多了，对上述流程大致进行一个梳理，进行端口绑定时首先对创建一个NioServerScoketChannel 用来处理accpet，然后注册到BossEventLoop上，通过给NioServerScoketChannel添加一个处理器 将来发生accpet时，将生成的NioSocketChannel注册到WorkerEventLoop上，后续的io事件就在该NioSocketChannel完成
客户端启动流程
客户端这边启动流程和服务端大致类似，连接ip端口时，创建一个用来和服务端通信的NioSocketChannel（内部包裹着SocketChannel），然后注册到对应的EventLoop上的selector开启事件监听
ChannelFuture cf = bootstrap.connect("127.0.0.1", 8080).sync();
cf.channel().closeFuture().sync();
/************************Bootstrap*********************/
private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
// 创建一个NioSocketChannel然后进行注册，流程跟NioServerScoketChannel差不多，返回一个注册future
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
if (regFuture.isDone()) {
if (!regFuture.isSuccess()) {
return regFuture;
}
return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
} else {
// 还未注册完成 添加一个监听器 用作将来注册成功后进行连接操作
final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
regFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
Throwable cause = future.cause();
if (cause != null) {
promise.setFailure(cause);
} else {
promise.registered();
doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
}
}
});
return promise;
}
}
private ChannelFuture doResolveAndConnect0(final Channel channel, SocketAddress remoteAddress,
final SocketAddress localAddress, final ChannelPromise promise) {
try {
final EventLoop eventLoop = channel.eventLoop();
final AddressResolver<SocketAddress> resolver = this.resolver.getResolver(eventLoop);
//解析器无法解析ip地址或者已经被解析
if (!resolver.isSupported(remoteAddress) || resolver.isResolved(remoteAddress)) {
doConnect(remoteAddress, localAddress, promise);
return promise;
}
final Future<SocketAddress> resolveFuture = resolver.resolve(remoteAddress);
if (resolveFuture.isDone()) {
// 解析完成 进行连接
final Throwable resolveFailureCause = resolveFuture.cause();
if (resolveFailureCause != null) {
// Failed to resolve immediately
channel.close();
promise.setFailure(resolveFailureCause);
} else {
// Succeeded to resolve immediately; cached? (or did a blocking lookup)
doConnect(resolveFuture.getNow(), localAddress, promise);
}
return promise;
}
// 添加一个监听器用来将来地址解析成功然后进行连接
resolveFuture.addListener(new FutureListener<SocketAddress>() {
@Override
public void operationComplete(Future<SocketAddress> future) throws Exception {
if (future.cause() != null) {
channel.close();
promise.setFailure(future.cause());
} else {
doConnect(future.getNow(), localAddress, promise);
}
}
});
} catch (Throwable cause) {
promise.tryFailure(cause);
}
return promise;
}
private static void doConnect(
final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise connectPromise) {
final Channel channel = connectPromise.channel();
// 提交一个连接任务到EventLoop上
channel.eventLoop().execute(new Runnable() {
@Override
public void run() {
if (localAddress == null) {
channel.connect(remoteAddress, connectPromise);
} else {
channel.connect(remoteAddress, localAddress, connectPromise);
}
// 添加一个关闭或失败的监听器,会将channel进行关闭
connectPromise.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
}
});
}
// 设置channel的options和attrs
void init(Channel channel) throws Exception {
ChannelPipeline p = channel.pipeline();
p.addLast(config.handler());
final Map<ChannelOption<?>, Object> options = options0();
synchronized (options) {
setChannelOptions(channel, options, logger);
}
final Map<AttributeKey<?>, Object> attrs = attrs0();
synchronized (attrs) {
for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
channel.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
}
}
}
至此我们服务端和客户端的启动流程都分析完了，我们前面说过EventLoop可以当做一个线程来执行， channel.eventLoop().execute(new Runnable(），后续的io事件监听和自定义任务处理都在EventLoop内执行，我们下节就来剖析其内部实现
