Netty源码学习系列之4-ServerBootstrap的bind方法
前言
今天研究ServerBootstrap的bind方法,该方法可以说是netty的重中之重、核心中的核心。前两节的NioEventLoopGroup和ServerBootstrap的初始化就是为bind做准备。照例粘贴一下这个三朝元老的demo,开始本文内容。
public class NettyDemo1 { // netty服务端的一般性写法 public static void main(String[] args) { EventLoopGroup boss = new NioEventLoopGroup(1); EventLoopGroup worker = new NioEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(boss, worker).channel(NioServerSocketChannel.class) .option(ChannelOption.SO_BACKLOG, 100) .handler(new NettyServerHandler()) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { ChannelPipeline pipeline = socketChannel.pipeline(); pipeline.addLast(new StringDecoder()); pipeline.addLast(new StringEncoder()); pipeline.addLast(new NettyServerHandler()); } }); ChannelFuture channelFuture = bootstrap.bind(90); channelFuture.channel().closeFuture().sync(); } catch (Exception e) { e.printStackTrace(); } finally { boss.shutdownGracefully(); worker.shutdownGracefully(); } } }
一、bind及doBind方法
1.ServerBootstrap.bind方法
该方法有多个重载方法,但核心作用只有一个,就是将参数转为InetSocketAddress对象传给 --->
public ChannelFuture bind(int inetPort) { return bind(new InetSocketAddress(inetPort)); }
public ChannelFuture bind(String inetHost, int inetPort) { return bind(SocketUtils.socketAddress(inetHost, inetPort)); }
public ChannelFuture bind(InetAddress inetHost, int inetPort) { return bind(new InetSocketAddress(inetHost, inetPort)); }
下面这个bind方法,在该方法中调用了doBind方法。
public ChannelFuture bind(SocketAddress localAddress) { validate(); return doBind(ObjectUtil.checkNotNull(localAddress, "localAddress")); }
2、ServerBootstrap的doBind方法
doBind方法位于父类AbstractBootstrap中,它有两大功能,均在下面代码中标识了出来,它们分别对应通过原生nio进行server端初始化时的两个功能,第1步对应将channel注册到selector上;第2步对应将server地址绑定到channel上。
private ChannelFuture doBind(final SocketAddress localAddress) { final ChannelFuture regFuture = initAndRegister(); // 1)、初始化和注册,重要*** final Channel channel = regFuture.channel(); if (regFuture.cause() != null) { return regFuture; } if (regFuture.isDone()) { // At this point we know that the registration was complete and successful. ChannelPromise promise = channel.newPromise(); doBind0(regFuture, channel, localAddress, promise); // 2)、将SocketAddress和channel绑定起来,最终执行的是nio中的功能,重要** return promise; } else { // 省略异常判断、添加监听器和异步调用doBind0方法 } }
为方便关联对照,下面再粘贴一个简单的原生NIO编程的服务端初始化方法,其实doBind方法的逻辑基本就是对下面这个方法的封装,只是增加了很多附加功能。
因为上述两步都有些复杂,所以此处分两部分进行追踪。
二、AbstractBootstrap的initAndRegister方法
该方法代码如下所示,一共有三个核心方法,逻辑比较清晰,将channel new出来,初始化它,然后注册到selector上。下面我们各个击破。
final ChannelFuture initAndRegister() { Channel channel = null; try { // 1)、实例化channel,作为服务端初始化的是NioServerSocketChannel channel = channelFactory.newChannel(); init(channel); // 2)、初始化channel,即给channel中的属性赋值 } catch (Throwable t) { if (channel != null) { channel.unsafe().closeForcibly(); return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t); } return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t); } // 3)、注册,即最终是将channel 注册到selector上 ChannelFuture regFuture = config().group().register(channel); if (regFuture.cause() != null) { if (channel.isRegistered()) { channel.close(); } else { channel.unsafe().closeForcibly(); } } return regFuture; }
1、channelFactory.newChannel()方法
@Override public T newChannel() { try { return constructor.newInstance(); } catch (Throwable t) { throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t); } }
该方法完成了channel的实例化,channelFactory的赋值可参见上一篇博文【Netty源码学习系列之3-ServerBootstrap的初始化】(地址 https://www.geek-share.com/detail/2802012500.html),对服务端来说,这里channelFactory值为ReflectiveChannelFactory,且其内部的constructor是NioServerSocketChannel的无参构造器,下面追踪NioServerSocketChannel的无参构造方法。
1.1)、new NioServerSocketChannel()
public NioServerSocketChannel() { this(newSocket(DEFAULT_SELECTOR_PROVIDER)); }
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider(); private static ServerSocketChannel newSocket(SelectorProvider provider) { try { return provider.openServerSocketChannel(); } catch (IOException e) { throw new ChannelException( "Failed to open a server socket.", e); } }
可见,它先通过newSocket方法获取nio原生的ServerSocketChannel,然后传给了重载构造器,如下,其中第三行是对NioServerSocketChannelConfig config进行了赋值,逻辑比较简单,下面主要看对父类构造方法的调用。
public NioServerSocketChannel(ServerSocketChannel channel) { super(null, channel, SelectionKey.OP_ACCEPT); config = new NioServerSocketChannelConfig(this, javaChannel().socket()); }
1.2)、对NioServerSocketChannel父类构造方法的调用
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) { super(parent); this.ch = ch; this.readInterestOp = readInterestOp; try { 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); } }
中间经过了AbstractNioMessageChannel,然后调到下面AbstractNioChannel的构造方法。此时parent为null,ch为上面获取到的nio原生ServerSocketChannel,readInterestOp为SelectionKey的Accept事件(值为16)。可以看到,将原生渠道ch赋值、感兴趣的事件readInterestOp赋值、设置非阻塞。然后重点看对父类构造器的调用。
1.3)、AbstractChannel构造器
protected AbstractChannel(Channel parent) { this.parent = parent; id = newId(); unsafe = newUnsafe(); pipeline = newChannelPipeline(); }
可以看到,此构造方法只是给四个属性进行了赋值,我们挨个看下这四个属性。
第一个属性是this.parent,类型为io.netty.channel.Channel,但此时值为null;
第二个属性id类型为io.netty.channel.ChannelId,就是一个id生成器,值为new DefaultChannelId();
第三个属性unsafe类型为io.netty.channel.Channel.Unsafe,该属性很重要,封装了对事件的处理逻辑,最终调用的是AbstractNioMessageChannel中的newUnsafe方法,赋的值为new NioMessageUnsafe();
第四个属性pipeline类型为io.netty.channel.DefaultChannelPipeline,该属性很重要,封装了handler处理器的逻辑,赋的值为 new DefaultChannelPipeline(this) this即当前的NioServerSocketChannel对象。
其中DefaultChannelPipeline的构造器需要额外看一下,如下,将NioServerSocketChannel对象存入channel属性,然后初始化了tail、head两个成员变量,且对应的前后指针指向对方。TailContext和HeadContext都继承了AbstractChannelHandlerContext,在这个父类里面维护了next和prev两个双向指针,看到这里有经验的园友应该一下子就能看出来,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; }
至此,完成了上面initAndRegister方法中的第一个功能:channel的实例化。此时NioServerSocketChannel的几个父类属性快照图如下所示:
2、init(channel)方法
init(channel)方法位于ServerBootstrap中(因为这里是通过ServerBootstrap过来的,如果是通过Bootstrap进入的这里则调用的就是Bootstrap中的init方法),主要功能如下注释所示。本质都是针对channel进行初始化,初始化channel中的option、attr和pipeline。
void init(Channel channel) throws Exception { // 1、获取AbstractBootstrap中的options属性,与channel进行关联 final Map<ChannelOption<?>, Object> options = options0(); synchronized (options) { setChannelOptions(channel, options, logger); } // 2、获取AbstractBootstrap中的attr属性,与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()); } } // 3、获取pipeline,并将一个匿名handler对象添加进去,重要*** 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(0)); } synchronized (childAttrs) { currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0)); } 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() { pipeline.addLast(new ServerBootstrapAcceptor( ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); } }); } }); }
1跟2的功能都比较容易理解,功能3是init的核心,虽然代码不少但很容易理解,它就是往channel中的pipeline里添加了一个匿名handler对象,其initChannel方法只有在有客户端连接接入时才会调用,initChannel方法的功能是什么呢?可以看到,它就是往入参channel中的eventLoop里添加了一个任务,这个任务的功能就是往pipeline中再添加一个handler,最后添加的这个handler就不是匿名的了,它是ServerBootstrapAcceptor对象。因为这里的initChannel方法和后面的run方法都是有客户端接入时才会调用的,所以这里只是提一下,后面会详述。至此完成init方法,下面进入register。
3、config().group().register(channel)方法
3.1)、config().group()方法
由前面可以知道,config().group().register(channel)这行代码位于AbstractBootstrap类中的initAndRegister方法中,但由于当前对象是ServerBootstrap,故此处config()方法实际调用的都是ServerBootstrap中重写的方法,得到了ServerBootstrapConfig。
ServerBootstrapConfig的group方法如下,调用的是它的父类AbstractBootstrapConfig中的方法。通过类名就能知道,ServerBootstrapConfig中的方法是获取ServerBootstrap中的属性,而AbstractBootstrapConfig中的方法是获取AbstractBootstrap中的属性,两两对应。故此处获取的EventLoopGroup就是AbstractBootstrap中存放的group,即文章开头demo中的boss对象。
public final EventLoopGroup group() { return bootstrap.group(); }
获取到了名叫boss的这个NioEventLoopGroup对象,下面追踪NioEventLoopGroup.register(channel)方法
3.2)、 NioEventLoopGroup.register(channel)方法
该方法是对之前初始化属性的应用,需结合NioEventLoopGroup的初始化流程看,详见【Netty源码学习系列之2-NioEventLoopGroup的初始化】(链接【https://www.geek-share.com/detail/2801985140.html】)一文,此处就不赘述了,下面把该类的继承类图粘贴出来,以便有个整体认识。
3.2.1)、next()方法
下面的register方法位于MultithreadEventLoopGroup类中,是NioEventLoopGroup的直接父类,如下:
public ChannelFuture register(Channel channel) { return next().register(channel); }
next方法如下,调用了父类的next方法,下面的就是父类MultithreadEventExecutorGroup中的next实现,可以看到调用的是chooser的next方法。通过初始化流程可知,此处boss的线程数是1,是2的n次方,所以chooser就是PowerOfTwoEventExecutorChooser,通过next方法从EventExecutor[]中选择一个对象。需要注意的是chooser.next()通过轮询的方式选择的对象。
public EventLoop next() { return (EventLoop) super.next(); }
public EventExecutor next() { return chooser.next(); }
3.2.2)、NioEventLoop.register方法
next之后是register方法,中间将NioServerSocketChannel和当前的NioEventLoop封装成一个DefaultChannelPromise对象往下传递,在下面第二个register方法中可以看到,实际上调用的是NioServerSocketChannel中的unsafe属性的register方法。
public ChannelFuture register(Channel channel) { return register(new DefaultChannelPromise(channel, this)); }
public ChannelFuture register(final ChannelPromise promise) { ObjectUtil.checkNotNull(promise, "promise"); promise.channel().unsafe().register(this, promise); return promise; }
3.2.3)、NioMessageUnsafe的register方法
通过本文第一部分中第1步中的1.3)可以知道,NioServerSocketChannel中的unsafe是NioMessageUnsafe对象,下面继续追踪其register方法:
public final void register(EventLoop eventLoop, final ChannelPromise promise) { if (eventLoop == null) {// 判断非空 throw new NullPointerException("eventLoop"); } if (isRegistered()) {// 判断是否注册 promise.setFailure(new IllegalStateException("registered to an event loop already")); return; } if (!isCompatible(eventLoop)) {// 判断eventLoop类型是否匹配 promise.setFailure( new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName())); return; } // 完成eventLoop属性的赋值 AbstractChannel.this.eventLoop = eventLoop; // 判断eventLoop中的Reactor线程是不是当前线程 ***重要1 if (eventLoop.inEventLoop()) { register0(promise); // 进行注册 } else { try {// 不是当前线程则将register0任务放入eventLoop队列中让Reactor线程执行(如果Reactor线程未初始化还要将其初始化) ***重要2 eventLoop.execute(new Runnable() { @Override public void run() { register0(promise);// 注册逻辑 ***重要3 } }); } catch (Throwable t) { // 省略异常处理 } } }
该方法位于io.netty.channel.AbstractChannel.AbstractUnsafe中(它是NioMessageUnsafe的父类),根据注释能了解每一步做了什么,但如果要理解代码逻辑意图则需要结合netty的串行无锁化(串行无锁化参见博主的netty系列第一篇文章https://www.cnblogs.com/zzq6032010/p/12872993.html)。它实际就是让每一个NioEventLoop对象的thread属性记录一条线程,用来循环执行NioEventLoop的run方法,后续这个channel上的所有事件都由这一条线程来执行,如果当前线程不是Reactor线程,则会将任务放入队列中,Reactor线程会不断从队列中获取任务执行。这样以来,所有事件都由一条线程顺序处理,线程安全,也就不需要加锁了。
说完整体思路,再来结合代码看看。上述代码中标识【***重要1】的地方就是通过inEventLoop方法判断eventLoop中的thread属性记录的线程是不是当前线程:
先调到父类AbstractEventExecutor中,获取了当前线程:
public boolean inEventLoop() { return inEventLoop(Thread.currentThread()); }
然后调到SingleThreadEventExecutor类中的方法,如下,比对thread与当前线程是否是同一个:
public boolean inEventLoop(Thread thread) { return thread == this.thread; }
此时thread未初始化,所以肯定返回false,则进入【***重点2】的逻辑,将register放入run方法中封装成一个Runnable任务,然后执行execute方法,如下,该方法位于SingleThreadEventExecutor中:
public void execute(Runnable task) { if (task == null) { throw new NullPointerException("task"); } boolean inEventLoop = inEventLoop(); addTask(task); //将任务放入队列中 ***重要a if (!inEventLoop) { startThread(); //判断当前线程不是thread线程,则调用该方法 ***重要b if (isShutdown()) { boolean reject = false; try { if (removeTask(task)) { reject = true; } } catch (UnsupportedOperationException e) { // 省略注释 } if (reject) { reject(); } } } if (!addTaskWakesUp && wakesUpForTask(task)) { wakeup(inEventLoop); } }
有两个重要的逻辑,已经在上面代码中标出,先看看【***重要a】,如下,可见最终就是往SingleThreadEventExecutor的taskQueue队列中添加了一个任务,如果添加失败则调reject方法执行拒绝策略,通过前文分析可以知道,此处的拒绝策略就是直接抛错。
protected void addTask(Runnable task) { if (task == null) { throw new NullPointerException("task"); } if (!offerTask(task)) { reject(task); } }
final boolean offerTask(Runnable task) { if (isShutdown()) { reject(); } return taskQueue.offer(task); }
然后在看【***重要b】,如下,该方法虽然叫startThread,但内部有控制,不能无脑开启线程,因为调这个方法的时候会有两种情况:1).thread变量为空;2).thread不为空且不是当前线程。第一种情况需要开启新的线程,但第二种情况就不能直接创建线程了。所以看下面代码可以发现,它内部通过CAS+volatile(state属性加了volatile修饰)实现的开启线程的原子控制,保证多线程情况下也只会有一个线程进入doStartThread()方法。
private void startThread() { if (state == ST_NOT_STARTED) { if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) { boolean success = false; try { doStartThread(); success = true; } finally { if (!success) { STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED); } } } } }
继续往下看一下doStartThread()的方法逻辑:
private void doStartThread() { assert thread == null; executor.execute(new Runnable() { //此处的executor内部执行的就是ThreadPerTaskExecutor的execute逻辑,创建一个新线程运行下面的run方法 @Override public void run() { thread = Thread.currentThread(); //将Reactor线程记录到thread变量中,保证一个NioEventLoop只有一个主线程在运行 if (interrupted) { thread.interrupt(); } boolean success = false; updateLastExecutionTime(); try { SingleThreadEventExecutor.this.run(); //调用当前对象的run方法,该run方法就是Reactor线程的核心逻辑方法,后面会重点研究 success = true; } catch (Throwable t) { logger.warn("Unexpected exception from an event executor: ", t); } finally { // 省略无关逻辑 } } }); }
可以看到,在上面的方法中完成了Reactor线程thread的赋值和核心逻辑NioEventLoop中run方法的启动。这个run方法启动后,第一步做的事情是什么?让我们往前回溯,回到3.2.3),当然是执行当初封装了 register0方法的那个run方法的任务,即执行register0方法,下面填之前埋得坑,对【***重要3】进行追踪:
private void register0(ChannelPromise promise) { try { // 省略判断逻辑 boolean firstRegistration = neverRegistered; doRegister();// 执行注册逻辑 neverRegistered = false; registered = true; pipeline.invokeHandlerAddedIfNeeded();// 调用pipeline的逻辑 safeSetSuccess(promise); pipeline.fireChannelRegistered(); // 省略无关逻辑 } catch (Throwable t) { // 省略异常处理 } }
doRegister()方法的实现在AbstractNioChannel中,如下,就是完成了nio中的注册,将nio的ServerSocketChannel注册到selector上:
protected void doRegister() throws Exception { boolean selected = false; for (;;) { try { selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this); return; } catch (CancelledKeyException e) { // 省略异常处理 } } }
再看pipeline.invokeHandlerAddedIfNeeded()方法,该方法调用链路比较长,此处就不详细粘贴了,只是说一下流程。回顾下上面第二部分的第2步,在里面最后addLast了一个匿名的内部对象,重写了initChannel方法,此处通过pipeline.invokeHandlerAddedIfNeeded()方法就会调用到这个匿名对象的initChannel方法(只有第一次注册时才会调),该方法往pipeline中又添加了一个ServerBootstrapAcceptor对象。执行完方法后,netty会在finally中将之前那个匿名内部对象给remove掉,这时pipeline中的handler如下所示:
至此,算是基本完成了initAndRegister方法的逻辑,当然限于篇幅(本篇已经够长了),其中还有很多细节性的处理未提及。
三、AbstractBootstrap的doBind0方法
doBind0方法逻辑如下所示,new了一个Runnable任务交给Reactor线程执行,execute执行过程已经分析过了,此处不再赘述,集中下所剩无几的精力看下run方法中的bind逻辑。
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); } else { promise.setFailure(regFuture.cause()); } } }); }
channel.bind方法,如下:
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) { return pipeline.bind(localAddress, promise); }
调用了pipeline的bind方法:
public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) { return tail.bind(localAddress, promise); }
tail.bind方法:
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) { if (localAddress == null) { throw new NullPointerException("localAddress"); } if (isNotValidPromise(promise, false)) { // cancelled return promise; } // 从tail开始往前,找到第一个outbond的handler,这时只有head满足要求,故此处next是head final AbstractChannelHandlerContext next = findContextOutbound(MASK_BIND); EventExecutor executor = next.executor(); if (executor.inEventLoop()) {// 因为当前线程就是executor中的Reactor线程,所以直接进入invokeBind方法 next.invokeBind(localAddress, promise); } else { safeExecute(executor, new Runnable() { @Override public void run() { next.invokeBind(localAddress, promise); } }, promise, null); } return promise; }
下面进入head.invokeBind方法:
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); } }
核心逻辑就是handler.bind方法,继续追踪:
public void bind( ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) { unsafe.bind(localAddress, promise); }
此处的unsafe是NioMessageUnsafe,继续追踪会看到在bind方法中又调用了NioServerSocketChannel中的doBind方法,最终在这里完成了nio原生ServerSocketChannel和address的绑定:
protected void doBind(SocketAddress localAddress) throws Exception { if (PlatformDependent.javaVersion() >= 7) { javaChannel().bind(localAddress, config.getBacklog()); } else { javaChannel().socket().bind(localAddress, config.getBacklog()); } }
至此,ServerBootstrap的bind方法完成。
小结
本文从头到尾追溯了ServerBootstrap中bind方法的逻辑,将前面netty系列中的二、三两篇初始化给串联了起来,是承上启下的一个位置。后面的netty系列将围绕本文中启动的NioEventLoop.run方法展开,可以这么说,本文跟前面的三篇只是为run方法的出现做的一个铺垫,run方法才是核心功能的逻辑所在。
本文断断续续更新了一周,今天才完成,也没想到会这么长,就这样吧,后面继续netty run方法的学习。
- Netty源码学习系列之2-ServerBootstrap的初始化
- 【Netty源码学习】ServerBootStrap
- Netty源码系列(2)——ServerBootstrap
- Netty源码学习-ServerBootstrap启动及事件处理过程
- 【Netty源码学习】ServerBootStrap
- 【Netty源码学习】ServerBootStrap
- netty源码学习一(Serverbootstrap引导程序)
- 【Netty源码学习】BootStrap
- Angular 学习系列 - - angular.bind、angular.bootstrap、angular.copy
- Netty源码-ServerBootStrap服务端启动流程
- 【Netty源码学习】BootStrap
- netty源码分析系列——Bootstrap
- Netty之 netty源码学习之netty server端源码初读(下)
- Angular 学习系列 - - angular.bind、angular.bootstrap、angular.copy
- Netty 源码分析之 一 服务端创建(ServerBootstrap )
- Netty源码解读------------ServerBootstrap的启动(一)
- 【Netty】(6) ---源码ServerBootstrap
- Netty源码阅读(一) ServerBootstrap启动
- 学习 java netty (二) -- ServerBootstrap
- 一起学Netty(十八)netty源码学习之netty server端源码初读(上)