java netty之ServerBootstrap的启动

通过前面的几篇文章，对整个netty部分的架构已经运行原理都有了一定的了解，那么这篇文章来分析一个经常用到的类：ServerBootstrap，一般对于服务器端的编程它用到的都还算是比较的多。。看一看它的初始化，以及它的运行原理。。。

首先我们还是引入一段代码，通过分析这段代码来分析ServerBootstrap的运行。。。

EventLoopGroup bossGroup = new NioEventLoopGroup(); //这个是用于serversocketchannel的eventloop
EventLoopGroup workerGroup = new NioEventLoopGroup(); //这个是用于处理accept到的channel
try {
ServerBootstrap b = new ServerBootstrap(); //构建serverbootstrap对象
b.group(bossGroup, workerGroup); //设置时间循环对象，前者用来处理accept事件，后者用于处理已经建立的连接的io
b.channel(NioServerSocketChannel.class); //用它来建立新accept的连接，用于构造serversocketchannel的工厂类
b.childHandler(new ChannelInitializer<SocketChannel>(){ //为accept channel的pipeline预添加的inboundhandler
@Override //当新连接accept的时候，这个方法会调用
protected void initChannel(SocketChannel ch) throws Exception {
// TODO Auto-generated method stub
ch.pipeline().addLast(new MyChannelHandler()); //为当前的channel的pipeline添加自定义的处理函数
}
});
//bind方法会创建一个serverchannel，并且会将当前的channel注册到eventloop上面，
//会为其绑定本地端口，并对其进行初始化，为其的pipeline加一些默认的handler
ChannelFuture f = b.bind(80).sync();
f.channel().closeFuture().sync(); //相当于在这里阻塞，直到serverchannel关闭
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}

这段代码在前面的文章也有用到，基本上其意思也都在上面的注释中说的比较清楚了，那么我们接下来具体的分析其中的方法调用，首先是ServerBootstrap的group方法：

//这里parent用于执行server的accept时间事件，child才是用于执行获取的channel连接的事件
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
super.group(parentGroup);
if (childGroup == null) {
throw new NullPointerException("childGroup");
}
if (this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
}
this.childGroup = childGroup;
return this;
}

这个方法是用来设置eventloopgroup，首先调用了父类的group方法（abstractbootstrap），就不将父类的方法列出来了，其实意思都差不多，eventloopgroup属性的值。。。

好了，接下来我们再来看一下channel方法：

//构造serversocketchannel factory
public B channel(Class<? extends C> channelClass) {
if (channelClass == null) {
throw new NullPointerException("channelClass");
}
return channelFactory(new BootstrapChannelFactory<C>(channelClass)); //构造工厂类
}
/**
* {@link ChannelFactory} which is used to create {@link Channel} instances from
* when calling {@link #bind()}. This method is usually only used if {@link #channel(Class)}
* is not working for you because of some more complex needs. If your {@link Channel} implementation
* has a no-args constructor, its highly recommend to just use {@link #channel(Class)} for
* simplify your code.
*/
@SuppressWarnings("unchecked")
public B channelFactory(ChannelFactory<? extends C> channelFactory) {
if (channelFactory == null) {
throw new NullPointerException("channelFactory");
}
if (this.channelFactory != null) {
throw new IllegalStateException("channelFactory set already");
}
this.channelFactory = channelFactory; //设置
return (B) this;
}

该方法主要是用于构造用于产生channel的工厂类，在我们这段代码说白了就是用于实例化serversocketchannel的工厂类。。。

接下来我们再来看一下childHandler方法：

//设置childHandler，这个是当有channel accept之后为其添加的handler
public ServerBootstrap childHandler(ChannelHandler childHandler) {
if (childHandler == null) {
throw new NullPointerException("childHandler");
}
this.childHandler = childHandler;
return this;
}

这个很简单吧，就是一个赋值，具体说他有什么用，前面的注释有说明，不过以后的分析会说明它有什么用的。。。

接下来我们来看一下bind方法，这个比较重要吧：

//最终将会创建serverchannel，然后会将其绑定到这个地址，然后对其进行初始化
public ChannelFuture bind(int inetPort) {
return bind(new InetSocketAddress(inetPort));
}

好吧，接下来再来看bind方法：

public ChannelFuture bind(SocketAddress localAddress) {
validate();
if (localAddress == null) {
throw new NullPointerException("localAddress");
}
return doBind(localAddress);
}

好吧，再来看看doBind方法：

private ChannelFuture doBind(final SocketAddress localAddress) {
final ChannelFuture regPromise = initAndRegister(); //在这里创建serverchanel，并对其进行初始化，并将其注册到eventloop当中去
final Channel channel = regPromise.channel();
final ChannelPromise promise = channel.newPromise();
if (regPromise.isDone()) {
doBind0(regPromise, channel, localAddress, promise); //将当前的serverchannel绑定地址
} else {
regPromise.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
doBind0(future, channel, localAddress, promise);
}
});
}
return promise;
}

这里调用了一个比较重要的方法：initAndRegister，我们来看看它的定义：

//创建初始化以及注册serverchanel
final ChannelFuture initAndRegister() {
//利用工厂类创建channel
final Channel channel = channelFactory().newChannel();
try {
init(channel); //init函数留给了后面来实现，用于初始化channel，例如为其的pipeline加上handler
} catch (Throwable t) {
channel.unsafe().closeForcibly();
return channel.newFailedFuture(t);
}
ChannelPromise regPromise = channel.newPromise();
group().register(channel, regPromise); //将当前创建的serverchannel注册到eventloop上面去
if (regPromise.cause() != null) {
if (channel.isRegistered()) {
channel.close();
} else {
channel.unsafe().closeForcibly();
}
}
// If we are here and the promise is not failed, it's one of the following cases:
// 1) If we attempted registration from the event loop, the registration has been completed at this point.
// i.e. It's safe to attempt bind() or connect() now beause the channel has been registered.
// 2) If we attempted registration from the other thread, the registration request has been successfully
// added to the event loop's task queue for later execution.
// i.e. It's safe to attempt bind() or connect() now:
// because bind() or connect() will be executed *after* the scheduled registration task is executed
// because register(), bind(), and connect() are all bound to the same thread.
return regPromise;
}

代码还是很简单，而且也相对比较好理解，无非就是利用前面说到过的channel工厂类来创建一个serversocketchannel，然后调用init方法对这个刚刚生成的channel进行一些初始化的操作，然后在调用eventloopgroup的register方法，将当前这个channel的注册到group上，那么以后这个channel的事件都在这个group上面执行，说白了也就是一些accept。、。。

好，我们先来看看这个init方法吧：

@Override
//初始化chanel，当用channel factory构造channel以后，会调用这个函数来初始化，说白了就是为当前的channel的pipeline加入一些handler
void init(Channel channel) throws Exception {
//先初始化一些配置
final Map<ChannelOption<?>, Object> options = options();
synchronized (options) {
channel.config().setOptions(options);
}
//初始化一些属性
final Map<AttributeKey<?>, Object> attrs = attrs();
synchronized (attrs) {
for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
@SuppressWarnings("unchecked")
AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
channel.attr(key).set(e.getValue());
}
}
//获取当前channel的pipeline
ChannelPipeline p = channel.pipeline();
if (handler() != null) {
p.addLast(handler());
}
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(Channel ch) throws Exception {
//这是一个inboundher，将其加入到serverchannel的pipeline上面去
ch.pipeline().addLast(new ServerBootstrapAcceptor(
currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}

代码还是相对很简单，首先初始化一些配置参数，然后初始化属性，最后还要为当前的channel的pipeline添加一个handler，这个handler用来当channel注册到eventloop上面之后对其进行一些初始化，我们还是来看看channelInitalizer的定义吧：

public abstract class ChannelInitializer<C extends Channel> extends ChannelStateHandlerAdapter {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(ChannelInitializer.class);
/**
* This method will be called once the {@link Channel} was registered. After the method returns this instance
* will be removed from the {@link ChannelPipeline} of the {@link Channel}.
*
* @param ch the {@link Channel} which was registered.
* @throws Exception is thrown if an error occours. In that case the {@link Channel} will be closed.
*/
protected abstract void initChannel(C ch) throws Exception;
@SuppressWarnings("unchecked")
@Override
public final void channelRegistered(ChannelHandlerContext ctx)
throws Exception {
boolean removed = false;
boolean success = false;
try {
//调用用户定义的init函数对当前的channel进行初始化
initChannel((C) ctx.channel());
ctx.pipeline().remove(this);
removed = true;
ctx.fireChannelRegistered();
success = true;
} catch (Throwable t) {
logger.warn("Failed to initialize a channel. Closing: " + ctx.channel(), t);
} finally {
if (!removed) {
ctx.pipeline().remove(this);
}
if (!success) {
ctx.close();
}
}
}
@Override
public void inboundBufferUpdated(ChannelHandlerContext ctx) throws Exception {
ctx.fireInboundBufferUpdated();
}
}

它有一个channelRegistered方法，这个方法是在当前pipeline所属的channel注册到eventloop上面之后会激活的方法，它则是调用了用户自定义的函数来初始化channel，然后在将当前handler移除。。。也就是执行

ch.pipeline().addLast(new ServerBootstrapAcceptor(
currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));

这里又为当前的serversocketchannel添加了另外一个handler，来看看该类型的定义吧：

private static class ServerBootstrapAcceptor
extends ChannelStateHandlerAdapter implements ChannelInboundMessageHandler<Channel> {
private final EventLoopGroup childGroup;
private final ChannelHandler childHandler;
private final Entry<ChannelOption<?>, Object>[] childOptions;
private final Entry<AttributeKey<?>, Object>[] childAttrs;
@SuppressWarnings("unchecked")
ServerBootstrapAcceptor(
EventLoopGroup childGroup, ChannelHandler childHandler,
Entry<ChannelOption<?>, Object>[] childOptions, Entry<AttributeKey<?>, Object>[] childAttrs) {
this.childGroup = childGroup; //这个是用于管理accept的channel的eventloop
this.childHandler = childHandler;
this.childOptions = childOptions;
this.childAttrs = childAttrs;
}
@Override
public MessageBuf<Channel> newInboundBuffer(ChannelHandlerContext ctx) throws Exception {
return Unpooled.messageBuffer();
}
@Override
@SuppressWarnings("unchecked")
//当有数据进来的时候，会调用这个方法来处理数据，这里进来的数据就是accept的channel
public void inboundBufferUpdated(ChannelHandlerContext ctx) {
MessageBuf<Channel> in = ctx.inboundMessageBuffer(); //获取buf
for (;;) {
Channel child = in.poll();
if (child == null) {
break;
}
child.pipeline().addLast(childHandler); //为accept的channel的pipeline加入用户定义的初始化handler
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);
}
}
for (Entry<AttributeKey<?>, Object> e: childAttrs) {
child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
}
try {
childGroup.register(child); //将当前accept的channel注册到eventloop
} catch (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()) {
// stop accept new connections for 1 second to allow the channel to recover
// See https://github.com/netty/netty/issues/1328
config.setAutoRead(false);
ctx.channel().eventLoop().schedule(new Runnable() {
@Override
public void run() {
config.setAutoRead(true);
}
}, 1, TimeUnit.SECONDS);
}
// still let the exceptionCaught event flow through the pipeline to give the user
// a chance to do something with it
ctx.fireExceptionCaught(cause);
}
}

主要是有一个比较重要的方法，inboundBufferUpdated，这个方法是在有数据进来的时候会调用的，用于处理进来的数据，也就是accept到的channel，这里就知道我们定义的chidHandler的用处了吧，netty会将这个handler直接加入到刚刚accept到的channel的pipeline上面去。。。最后还要讲当前accept到的channel注册到child eventloop上面去，这里也就完完全全的明白了最开始定义的两个eventloopgroup的作用了。。。

好了，serversocketchannel的init以及register差不多了，然后会调用doBind0方法，将当前的serversocketchannel绑定到一个本地端口，

//将chanel绑定到一个本地地址
private static void doBind0(
final ChannelFuture regFuture, final Channel channel,
final SocketAddress localAddress, final ChannelPromise promise) {
// This method is invoked before channelRegistered() is triggered. Give user handlers a chance to set up
// the pipeline in its channelRegistered() implementation.
channel.eventLoop().execute(new Runnable() {
@Override
//匿名内部类想要访问外面的参数，那么外面的参数必须是要final的才行
public void run() {
if (regFuture.isSuccess()) {
//调用channel的bind方法，将当前的channl绑定到一个本地地址，其实是调用的是pipeline的bind方法，但是最终又是调用的当前
//channel的unsafe对象的bind方法
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
} else {
promise.setFailure(regFuture.cause());
}
}
});
}

其实这里调用bind方法最终还是调用serversocketchannel的unsafe对象的bind方法。。。。

到这里，整个serverbootstrap 就算初始化完成了，而且也可以开始运行了。。。

b.childHandler(new ChannelInitializer<SocketChannel>(){ //为accept channel的pipeline预添加的inboundhandler
@Override //当新连接accept的时候，这个方法会调用
protected void initChannel(SocketChannel ch) throws Exception {
// TODO Auto-generated method stub
ch.pipeline().addLast(new MyChannelHandler()); //为当前的channel的pipeline添加自定义的处理函数
}
});

这段代码的意思是对于刚刚accept到的channel，将会在它的pipeline上面添加handler，这个handler的用处主要是就是用户自定义的initChannel方法，就是初始化这个channel，说白了就是为它的pipeline上面添加自己定义的handler。。。

这样整个serverbootstrap是怎么运行的也就差不多了。。。

刚开始接触到netty的时候觉得这里一头雾水，通过这段时间对其代码的阅读，总算搞懂了其整个运行的原理，而且觉得其设计还是很漂亮的，虽然有的时候会觉得有那么一点点的繁琐。。。。

整个运行过程总结为一下几个步骤：

（1）创建用于两个eventloopgroup对象，一个用于管理serversocketchannel，一个用于管理accept到的channel

（2）创建serverbootstrap对象，

（3）设置eventloopgroup

（4）创建用于构建用到的channel的工厂类

（5）设置childhandler，它的主要功能主要是用户定义代码来初始化accept到的channel

（6）创建serversocketchannel，并对它进行初始化，绑定端口，以及register，并为serversocketchannel的pipeline设置默认的handler

通过这几个步骤，整个serverbootstrap也就算是运行起来了。。。

秒客网

java netty之ServerBootstrap的启动

相关文章