版权声明：本文为博主原创文章，未经博主允许不得转载。
摘要
该系列文章主要是分析Netty源码4.1.16.Final，了解Netty框架的设计和其中各种组件的优化手段。
这篇文章作为系列的第一篇文章，以最简单的EchoServer为例，从ServerBootstrap开始跟踪其初始化和启动流程，让读者在直观上对Netty框架有大概的认识。
EchoServer
我们从Netty提供的EchoServer开始，重要的代码片段如下：
// Configure the server.
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 100)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
if (sslCtx != null) {
p.addLast(sslCtx.newHandler(ch.alloc()));
}
//p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new EchoServerHandler());
}
});
// Start the server.
ChannelFuture f = b.bind(PORT).sync();
// Wait until the server socket is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down all event loops to terminate all threads.
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
ServerBootstrap
ServerBootstrap作为一个启动辅助类，通过他可以很方便的创建一个Netty服务端。从EchoServer可以看出，实现一个Server大概分为这样几个步骤：
- 设置bossGroup和workGroup。这里可以先理解为两个线程池，bossGroup设置一个线程，用于处理连接请求和建立连接，而workGroup线程池大小默认值2*CPU核数，在连接建立之后处理IO请求。EventLoopGroup体现了Netty对线程模型的抽象设计，之后会独立开篇介绍。
- 指定使用NioServerSocketChannel来处理连接请求。
channel(NioServerSocketChannel.class)这段代码实际上在设置channelFactory，而ServerBootstrap会通过channelFactory.newChannel来生产channel。这里channelFactory是一个ReflectiveChannelFactory，顾名思义这个工厂类以反射的方式来构建channel实例，而实例的类型就是我们指定的NioServerSocketChannel。
public T newChannel() {
...
return clazz.getConstructor().newInstance();
...
}
- 配置TCP参数。
- 配置handler和childHandler，数据处理器。
- ServerBootstrap启动服务器。
真正的启动过程由ChannelFuture f = b.bind(PORT).sync();开始触发。调用链路：ServerBootstrap.bind → AbstractBootstrap.bind → AbstractBootstrap.doBind，重点分析一下doBind：
private ChannelFuture doBind(final SocketAddress localAddress) {
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
...
ChannelPromise promise = channel.newPromise();
doBind0(regFuture, channel, localAddress, promise);
return promise;
...
}
这个过程分为两个关键步骤：
- initAndRegister - 包括Channel的创建、初始化和注册三个子步骤
- doBind0 - Channel绑定到监听端口
1.1 NioServerSocketChannel创建
final ChannelFuture initAndRegister() {
...
channel = channelFactory.newChannel();
init(channel);
...
ChannelFuture regFuture = config().group().register(channel);
...
return regFuture;
}
这里channelFactory就是上面提到的ReflectiveChannelFactory，他通过反射来创建NioServerSocketChannel实例，继续跟进NioServerSocketChannel的构造方法：
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
public NioServerSocketChannel() {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}
private static ServerSocketChannel newSocket(SelectorProvider provider) {
...
return provider.openServerSocketChannel();
...
}
public NioServerSocketChannel(ServerSocketChannel channel) {
super(null, channel, SelectionKey.OP_ACCEPT);
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}
因为获取provider的过程包含同步访问的消耗，所以NioServerSocketChannel缓存了provider并使用provider.openServerSocketChannel()来创建ServerSocketChannel实例。
除了创建ServerSocketChannel外，还要创建NioServerSocketChannelConfig。ChannelConfig的职责是统一保存channel配置，并提供读取和设置的接口。不同的ChannelConfig具体实现不一样，例如NioServerSocketChannelConfig提供的setReuseAddress接口，是为ServerSocketChannel设置useAddress参数。
NioServerSocketChannel的构造过程并没有这么简单，还要继续向上看看父类的构造函数。
先来看AbstractNioChannel的构造方法：
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
super(parent);
this.ch = ch;
this.readInterestOp = readInterestOp;
...
//设置channel非阻塞模式
ch.configureBlocking(false);
...
}
}
接下来是AbstractChannel类的构造方法：
protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}
代码清楚的交代了3件事情：
- 为当前channel生成ID（由机器名，进程名，序列号，进程号和随机数组成）。
- 创建Unsafe实例（NioMessageUnSafe）。所有的UnSafe类都主要用于网络方面的操作，比如read，write，close等，Channel关于网络的操作都会委托给该unsafe来完成。
- 创建DefaultChannelPipeline，他就是大名鼎鼎的Pipeline机制。先从DefaultChannelPipeline构造函数入手：
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
...
tail = new TailContext(this);
head = new HeadContext(this);
head.next = tail;
tail.prev = head;
}
pipeline内部会组织一个ChannelHandlerContext的链表，上下行的事件都会经过这个链表依次处理。但是在构造Pipeline时，就只有两个ChannelHandlerContext：HeadContext主要用于处理输出事件，而TailContext用于处理输入事件。用户添加的Handler也会被封装在新的Context然后插入到链表中，参与事件的处理，这一点后面会再提到。
先来看看TailContext构造函数：
TailContext(DefaultChannelPipeline pipeline) {
super(pipeline, null, TAIL_NAME, true, false);
...
}
AbstractChannelHandlerContext(DefaultChannelPipeline pipeline, EventExecutor executor, String name,
boolean inbound, boolean outbound) {
this.name = ObjectUtil.checkNotNull(name, "name");
this.pipeline = pipeline;
this.executor = executor;
this.inbound = inbound;
this.outbound = outbound;
ordered = executor == null || executor instanceof OrderedEventExecutor;
}
值得注意的是inbound和outbound两个属性，TailContext（inbound=true，outbound=false），而HeadContext刚好相反（inbound=false，outbound=true），这两个属性由于标识该Context是用于处理输入事件还是输出事件的，当事件处理时会根据是事件输入还是输出而选择相应的Context来处理。
再来看HeadContext：
HeadContext(DefaultChannelPipeline pipeline) {
super(pipeline, null, HEAD_NAME, false, true);
unsafe = pipeline.channel().unsafe();
...
}
与TailContext
相比，HeadContext多了unsafe属性，是从pipeline中的channel中获取的，即NioSocketChannel构造函数中提到的unsafe对象。TailContext实现的很多方法都是空的，不做任何处理；而HeadContext实现的方法就比较多了，包括bind，connect，disconnect，read，write等，都是依赖unsafe来完成的。
到这里NioServerSocketChannel的创建过程才算结束，总结一下这个过程都包含了那些步骤：
- ServerBootStrap通过ReflectiveChannelFactory创建NioServerSocketChannel实例。
- NioServerSocketChannel实例内部创建了ServerSocketChannel。
- 每个Channel（AbstractChannel）内部都会创建ChannelID，unsafe以及pipeline。
1.2 NioServerSocketChannel初始化
回到AbstractBootstrap.initAndRegister：
final ChannelFuture initAndRegister() {
...
channel = channelFactory.newChannel();
init(channel);
...
ChannelFuture regFuture = config().group().register(channel);
...
return regFuture;
}
上一节介绍了channel的创建过程，接下来再看ServerBootstrap.init：
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();
...
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));
}
});
}
});
}
该初始化过程可以划分为两个部分：
- 设置channel的配置参数和附属属性。
- 向channel的pipeline添加handler。这里的handler是通过
ServerBootstrap.handler设置的，是在连接建立后的通用handler。
重点来看最后提到的ServerBootstrapAcceptor是什么？首先他是一个ChannelHandler，也会参与到事件的处理中，其次事件处理过程channelRead值得注意：
public void channelRead(ChannelHandlerContext ctx, Object msg) {
final Channel child = (Channel) msg;
child.pipeline().addLast(childHandler);
...
childGroup.register(child).addListener(new ChannelFutureListener() {
...
});
...
}
当新的连接SocketChannel建立后，会被包装在一个新建的NioSocketChannel中，之后开始触发pipeline.fireChannelRead，最终经过ServerBootstrapAcceptor.channelRead。在这里开始为这个NioSocketChannel添加childHandler，而childHandler则是我们在ServerBootstrap中指定的childHandler。接着在childGroup（也就是我们配置的workerGroup）中注册
