Netty核心概念(4)之Bootstrap

1.前言

    第三节介绍了Netty的一些基本概念，此节介绍Netty的第一个概念Bootstrap——启动类。Netty中服务端和客户端的启动类是不一样的，这个不要搞错了，类都在bootstrap包下。之后的所有章节都是基于目前最新版本的Netty 4.1.24.Final版本。

2.结构详解

    

    bootstrap中主要就两个内容：bootstrap和config。channelFactory被移动到其他地方了，这个接口已经废弃。乱入了一个FailedChannel，这里暂且不管。

    config给人带来歧义，让人误以为是我们去设置这个config，bootstrap读取这个设置进行初始化。实际上相反，这个类的作用是暴露我们对bootstrap的设置，仅仅起到展示配置的作用，并不是对其设置。设置相关内容还是需要直接操作bootstrap。所以config也不进行介绍，只剩下AbstractBootstrap、Bootstrap和ServerBootstrap了，本章主要介绍这三个内容。

2.1 AbstractBootstrap

 　这个是所有启动类的抽象父类，包含了一系列的基础内容。

　这是该类的基础字段：

　　group：线程池

　　channelFactory： 创建channel的工厂类

　　localAddress：本地地址

　　options： socket及其它的一些属性设置

　　attrs：附加属性设置

　　handler：channel处理类

　其中options和attrs在例子中暂时没有表现出来，使用起来也不复杂，看具体方法即可。下面介绍一些需要关注的方法。

+ View Code?

1 2 3 4 5 6

public B channel(Class<? extends C> channelClass) {     if (channelClass == null) {         throw new NullPointerException("channelClass");     }     return channelFactory(new ReflectiveChannelFactory<C>(channelClass)); }

　这个方法可以看出，放入Channel.class之后，其实际上是通过一个工厂类生成的channel对象，ReflectiveChannelFactory的做法也十分的简单，就是通过反射的方式newInstance()了该类的一个对象。另外bootstrap还直接提供了一个channelFactory方法，从字段也可以看出我们需要的是一个channelFactory。

　localAddress(..)该方法就是设置bind的方法监听的本地地址端口了，和bind()配合使用，bind(..)就是直接使用传入的地址，而不会管之前设置的localAddress。

    最后介绍一下最重要的bind(address)方法，这个就是针对服务端的监听端口环节，看看这步究竟做了些什么事情：

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

public ChannelFuture bind(SocketAddress localAddress) {     validate();     if (localAddress == null) {         throw new NullPointerException("localAddress");     }     return doBind(localAddress); }   private ChannelFuture doBind(final SocketAddress localAddress) {     final ChannelFuture regFuture = initAndRegister();     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);         return promise;     } else {         // Registration future is almost always fulfilled already, but just in case it's not.         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) {                     // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an                     // IllegalStateException once we try to access the EventLoop of the Channel.                     promise.setFailure(cause);                 } else {                     // Registration was successful, so set the correct executor to use.                     // See https://github.com/netty/netty/issues/2586                     promise.registered();                       doBind0(regFuture, channel, localAddress, promise);                 }             }         });         return promise;     } }

　　1、先检验基础配置是否完成，主要关心两个内容：线程池和channelFactory。

　　2、通过channelFactory生成一个channel对象，并初始化（init(Channel)，方法该方法是个抽象方法，子类完成初始化动作），失败关闭相关资源，之后将channel注册到线程池中(即线程池提供了注册channel的方法)，失败一样清除相关资源。

　　3、如果前面成功，开始绑定端口地址，绑定失败自动关闭，这个就是由channel自身完成，channel.bind(address, promise)。

　上面整个bind方法就完成了，主要注意的有以下几个内容：

　　　　1.启动类可以自己决定channel初始化的一些操作；

　　　　2.channel必须注册到线程池中，即线程池提供channel接入的入口；

　　　　3.具体的监听端口方法由channel自身实现；

　其它的方法就无关紧要了，抽象父类需要关注的内容就这么点。

2.2 ServerBootstrap

　该类是服务端的启动类，根据第三节所说的，为了区别处理服务端本身的监听端口channel和客户端的channel都使用了连接线程池。实际上不只是线程池，其继承抽象父类的都是服务端的相关内容，客户端的内容用另一组字段设置了，所以我们可以看到我们设置的handler是childHandler，服务端本身是不需要设置handler的。具体客户端相关设置如下：

　大部分都是针对child设置的内容，不需要一一解释，应该都能明白。

　该类需要关注的方法只有一个，就是抽象父类交给子类实现的init方法，如何初始化channel？

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

void init(Channel channel) throws Exception {     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()) {             @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()));     }       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、首先就是设置channel的socket参数了，这个就是我们之前设置的option参数了。

　　2、就是设置属性了，这个属性就是与channel绑定的，也是之前设置的attr参数。

　　3、最后是关键的一步，获取了这个channel的pipeline，pipeline的概念channel那章再介绍，这里只需要了解对channel的管理都是通过pipeline完成的。之前我说过服务端不需要设置handler，并不意味着完全可以不要，这里就为服务端的channel设置了handler。我们可以想一下，如果不处理，如何对客户端的channel进行设置属性等内容呢。这里就在channel初始化的时候设置了ServerBootstrapAcceptor。

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public void channelRead(ChannelHandlerContext ctx, Object msg) {         final Channel child = (Channel) msg;           child.pipeline().addLast(childHandler);           setChannelOptions(child, childOptions, logger);           for (Entry<AttributeKey<?>, Object> e: childAttrs) {             child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());         }           try {             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);         }  }

　上述就是ServerBootstrapAcceptor的read方法，其做了如下操作：

　　1、设置handler

　　2、设置socket属性

　　3、设置attr

　　4、将channel注册到childGroup，客户端的线程池中。

　这里可以推测一下相关逻辑了，因为read方法不是数据读取的时候才触发吗？根据JAVA NIO例子，这步应该出现在accept事件阶段，所以可以推测是该阶段调用了handler的read方法，传递了accept的客户端channel，在此对该channel进行处理，至于对不对，要后续解读代码进行验证（这个没错，简单说下，以NIO为例，主要逻辑在NioEventLoop调用的unsafe.read()，对于Server端而言是NioMessageUnsafe的read()方法，其调用了NioServerSocketChannel的doReadMessages方法，在buf中放入了accept的NioSocketChannel对象，再回到read()方法，通过pipeline调用fireChannelRead(buf[i])，这个会最终传导到handler，该handler接收到的不是byte而是一个客户端的channel对象，所以扩展连接方法的时候这段逻辑要非常注意）。但是通过上述说明，也就能明白服务端为什么不用设置handler了，因为能做的事情也就这些，除非你还有其他的事情要做，也许是统计多久有一个连接进来？这个没实验过，不过根据原理，应该可行，除非做了其他限制。

2.3 Bootstrap

　最后一个我们客户端的设置。客户端与服务端最大的不同在于，其是connect而不是bind，而且其需要知道远程服务端的地址。所以客户端的字段多了如下内容：

　远程地址，和翻译远程地址的resolver。由于客户端关注的是connect方法，而不是bind方法，我们重新对connect方法进行说明：

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {     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 {         // Registration future is almost always fulfilled already, but just in case it's not.         final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);         regFuture.addListener(new ChannelFutureListener() {             @Override             public void operationComplete(ChannelFuture future) throws Exception {                 // Directly obtain the cause and do a null check so we only need one volatile read in case of a                 // failure.                 Throwable cause = future.cause();                 if (cause != null) {                     // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an                     // IllegalStateException once we try to access the EventLoop of the Channel.                     promise.setFailure(cause);                 } else {                     // Registration was successful, so set the correct executor to use.                     // See https://github.com/netty/netty/issues/2586                     promise.registered();                     doResolveAndConnect0(channel, remoteAddress, localAddress, promise);                 }             }         });         return promise;     } }

　　1、第一步和bind操作一样，创建一个channel，初始化这个channel（操作差不多，注册handler，设置socket参数，设置attr）注册到线程池中，失败就清除资源。

　　2、根据线程池获取resolver，对不同的连接，翻译不同的地址。

　　3、进行连接，调用channel提供的connect方法。

　大体内容和server端差不多，这里不需要再增加额外的内容了，只需要使用抽象父类的字段就可以完成了。

3.后记

　本节主要介绍了bootstrap包中的一些内容，即Netty启动的一些操作。主要内容如下：

　　1.客户端和服务端执行的逻辑不同，一个是connect一个是bind，但是最终都是通过channel来完成该操作的，即channel决定了连接的方式。

　　2.服务端不需要设置服务端的handler，其内置了一个ServerBoostrapAcceptor，主要设置了客户端的channel属性，这段逻辑最终也是由服务端的channel的read相关方法控制的，即服务端的channel，read方法接收的是一个channel而不是一个byte。

　　3.所有的channel都需要注册到EventLoop中。

　以上几点内容都是与channel，EventLoop相关联了，所以特此提出，方便后续概念的相互验证，其具体做了哪些工作。