Netty源码分析（一）—服务端初始化

Netty源码分析（一）—服务端初始化

传统Java NIO在服务端启动时会涉及到ServerSocketChannel，Selector，selectorKey等类；Netty对Java NIO基础类进行了封装，减少用户开发工作量，降低开发难度；

个人主页：tuzhenyu’s page

原文地址：Netty源码分析（一）—服务端初始化

(0) 服务端初始化

服务端初始化的步骤

创建ServerBootstrap启动辅助类，通过Builder模式进行参数配置；

创建并绑定Reactor线程池EventLoopGroup；

设置并绑定服务端Channel通道类型；

绑定服务端通道数据处理器责任链Handler；

绑定并启动监听端口；

服务端初始化实例

public class TimeServer {
private void bind(int port){
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

try{
ServerBootstrap b= new ServerBootstrap();
b.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG,1024)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new TimeServerHandler());
}
});

ChannelFuture f = b.bind(port).sync();
f.channel().closeFuture().sync();
} catch (Exception e){
e.printStackTrace();
}finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}

public static void main(String[] args) {
new TimeServer().bind(8008);
}
}

(1) ServerBootstrap初始化

ServerBootstrap是netty启动辅助类，通过Builder模式进行参数设置
4000
初始化；ServerBootstrap继承AbstracBootstrap类，需要对EventLoopGroup，Channel和ChannelHandler等参数进行配置；

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
private final Map<ChannelOption<?>, Object> childOptions = new LinkedHashMap();
private final Map<AttributeKey<?>, Object> childAttrs = new LinkedHashMap();
private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
private volatile EventLoopGroup childGroup;
private volatile ChannelHandler childHandler;
}

ServerBootstrap比其父类AbstractBootstrap多出四个part需要进行设置

(2) EventLoop线程池初始化

EventLoopGroup初始化是创建创建两个NioEventLoopGroup类型的Reactor线程池bossGroup和workGroup分别用来处理客户端的连接请求和通道IO事件；

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap b= new ServerBootstrap();

b.group(boosGroup,workGroup)

通过group()方法设置EventLoop

将bossGroup传入到AbstractBootstrap中设置到group属性上，将workGroup设置到ServerBootstrap的childGroup属性上；

如果只传入了一个EventLoopGroup则最后传入两个相同的group；

public ServerBootstrap group(EventLoopGroup group) {
return this.group(group, group);
}

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
super.group(parentGroup);
if(childGroup == null) {
throw new NullPointerException("childGroup");
} else if(this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
} else {
this.childGroup = childGroup;
return this;
}
}

super.group(parentGroup)方法对AbstractBootstrap的group属性进行设置

public B group(EventLoopGroup group) {
if(group == null) {
throw new NullPointerException("group");
} else if(this.group != null) {
throw new IllegalStateException("group set already");
} else {
this.group = group;
return this;
}
}

(3) Channel通道初始化

Channel初始化主要是指对通道类型进行设置，常见的通道类型主要有NioServerSocktChannel异步非阻塞服务端TCP通道，NioSocketChannel异步非阻塞客户端通道，OioServerSocketChannel同步阻塞服务端通道，OioSocketChannel同步阻塞客户端通道，NioDatagramChannel异步非阻塞UDP通道，OioDatagramChannel同步阻塞UDP通道等；

ChannelFactory通道工程类设置

在serverBootstrap初始化过程中通过调用channel()方法进行通道类型设置

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

根据传入的Channe类型初始化一个ChannelFactory类型的工厂类，工厂类中通过newChannel()方法创建Channel实例

private final Class<? extends T> clazz;

public ReflectiveChannelFactory(Class<? extends T> clazz) {
if(clazz == null) {
throw new NullPointerException("clazz");
} else {
this.clazz = clazz;
}
}

public T newChannel() {
try {
return (Channel)this.clazz.newInstance();
} catch (Throwable var2) {
throw new ChannelException("Unable to create Channel from class " + this.clazz, var2);
}
}

通过channelFactory()方法将创建工厂类实例指向AbstractoryBootstrap的channelFactory属性

public B channelFactory(ChannelFactory<? extends C> channelFactory) {
if(channelFactory == null) {
throw new NullPointerException("channelFactory");
} else if(this.channelFactory != null) {
throw new IllegalStateException("channelFactory set already");
} else {
this.channelFactory = channelFactory;
return this;
}
}

Channel通道实例化

配置好AbstractBootstrap的channelFactory工厂类，Channel的实例化通过ChannelFactory.newChannel()方法实现；具体的newChannel()方法的调用链是：

ServerBootstrap.bind() -> AbstractBootstrap.doBind() -> AbstractBootstrap.initAndRegister() -> ChannelFactory.newChannel();

public T newChannel() {
try {
return (Channel)this.clazz.newInstance();
} catch (Throwable var2) {
throw new ChannelException("Unable to create Channel from class " + this.clazz, var2);
}
}

通过clazz.newInstance()方法调用构造器创建NioServerSocketChannel实例

public NioServerSocketChannel() {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

调用newSocket()方法创建ServerSocketChannel实例，这里的ServerSocketChannel和NIO中的ServerSocketChannel是同一个东西，接下来会调用父类构造器对其进行外部封装和相关参数的配置；

public NioServerSocketChannel(java.nio.channels.ServerSocketChannel channel) {
super((Channel)null, channel, 16);
this.config = new NioServerSocketChannel.NioServerSocketChannelConfig(this, this.javaChannel().socket());
}

在 NioServerSocketChannsl 实例化过程中, 所需要做的工作

调用 NioServerSocketChannel.newSocket(DEFAULT_SELECTOR_PROVIDER) 打开一个新的 Java NIO ServerSocketChannel

AbstractNioChannel 中的属性:

SelectableChannel ch 被设置为 Java ServerSocketChannel, 即 NioServerSocketChannel#newSocket 返回的 Java NIO ServerSocketChannel.

readInterestOp 被设置为 SelectionKey.OP_ACCEPT

SelectableChannel ch 被配置为非阻塞的 ch.configureBlocking(false)

AbstractChannel(Channel parent) 中初始化 AbstractChannel 的属性:

parent 属性置为 null

unsafe 通过newUnsafe() 实例化一个 unsafe 对象, 它的类型是 AbstractNioMessageChannel#AbstractNioUnsafe 内部类

pipeline 是 new DefaultChannelPipeline(this) 新创建的绑定管道实例.

NioServerSocketChannel 中的属性:

ServerSocketChannelConfig config = new NioServerSocketChannelConfig(this, javaChannel().socket())

Channel通道注册

在channel通道创建和初始化完毕后，会通过group.register()方法将channel通道注册到EventLoop线程池中；

final ChannelFuture initAndRegister() {
// 去掉非关键代码
final Channel channel = channelFactory().newChannel();
init(channel);
ChannelFuture regFuture = group().register(channel);
}

通过一系列的注册方法调用：AbstractBootstrap.initAndRegister -> MultithreadEventLoopGroup.register -> SingleThreadEventLoop.register -> AbstractUnsafe.register，最终是通过Unsafe类的register0()方法

private void register0(ChannelPromise promise) {
boolean firstRegistration = neverRegistered;
doRegister();
neverRegistered = false;
registered = true;
safeSetSuccess(promise);
pipeline.fireChannelRegistered();
// Only fire a channelActive if the channel has never been registered. This prevents firing
// multiple channel actives if the channel is deregistered and re-registered.
if (firstRegistration && isActive()) {
pipeline.fireChannelActive();
}
}

register0()方法调用了doRegister()方法实现通道注册到线程池中(EventLoop线程池会绑定一个selector选择器)

@Override
protected void doRegister() throws Exception {
// 省略错误处理
selectionKey = javaChannel().register(eventLoop().selector, 0, this);
}

(4)Pipeline管道初始化

每一个Channel通道在初始化时都会创建并绑定一个管道类，用来作为通道数据流的处理；pipeline管道的实例化是在AbstractChannel 的构造器中；

在创建DefaultChannelPipeline实例时会传入一个Channel对象，这个Channel对象就是之前实例化的NioServerSocketChannel实例，将pipeline管道和channel通道进行绑定；

DefaultChannelPipeline中维护了一个以AbstractChannelHandlerContext为节点的双向链表，包含两个字段head和tail分别指向双向链表的头部和尾部；

public DefaultChannelPipeline(AbstractChannel channel) {
if (channel == null) {
throw new NullPointerException("channel");
}
this.channel = channel;

tail = new TailContext(this);
head = new HeadContext(this);

head.next = tail;
tail.prev = head;
}

(5)handler处理器的添加过程

我们可以自定义Handler处理器并将其加入到pipeline管道中，进而像插件一样自由组合各种handler完成具体的业务逻辑；添加handler的过程是获取与channel通道绑定的管道pipeline然后将自定义的handler添加进pipeline内部维护的一个双向链表；

bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new TimeServerHandler());
}
});

Bootstrap.childerHandler方法接收一个 ChannelHandler, 而我们传递的是一个 派生于ChannelInitializer的匿名类，它正好也实现了 ChannelHandler接口，因此将ChannelHandler实例赋值给ServerBootstrap的childHandler属性；

public ServerBootstrap childHandler(ChannelHandler childHandler) {
if(childHandler == null) {
throw new NullPointerException("childHandler");
} else {
this.childHandler = childHandler;
return this;
}
}

在启动服务端绑定端口时候最终通过调用initAndRegister()方法创建Channel实例，并将通过init()方法将系统定义的处理器ServerBootstrapAccptor添加到与channel绑定的pipeline通道中；

@Override
void init(Channel channel) throws Exception {
...
ChannelPipeline p = channel.pipeline();

final EventLoopGroup currentChildGroup = childGroup;
final ChannelHandler currentChildHandler = childHandler;
final Entry<ChannelOption<?>, Object>[] currentChildOptions;
final Entry<AttributeKey<?>, Object>[] currentChildAttrs;

p.addLast(new ChannelInitializer<Channel>() {
@Override
public void initChannel(Channel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
ChannelHandler handler = handler();
if (handler != null) {
pipeline.addLast(handler);
}
pipeline.addLast(new ServerBootstrapAcceptor(
currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}

在ServerBootstrapAcceptor中重写了channelRead()方法，将自定义的handler处理器添加到管道中；

public void channelRead(ChannelHandlerContext ctx, Object msg) {
final Channel child = (Channel) msg;
child.pipeline().addLast(childHandler);
...
childGroup.register(child).addListener(...);
}

服务器端的 handler 与 childHandler 的区别与联系:

服务器 NioServerSocketChannel 的 pipeline 中添加的是 handler 与 ServerBootstrapAcceptor.

当有新的客户端连接请求时, ServerBootstrapAcceptor.channelRead 中负责新建此连接的NioSocketChannel并添加 childHandler 到 NioSocketChannel 对应的pipeline中, 并将此channel绑定到workerGroup中的某个eventLoop中；

handler是在accept阶段起作用, 它处理客户端的连接请求，ServerBootstrap也能设置handler()方法添加ServerSocketChannel的自定义处理器；

总结

Netty服务端的初始化主要是创建初始化辅助类ServerBootstrap，并对辅助类的相关参数进行初始化包括EventLoop线程池，Channle通道类型和ChannleHandler通道处理器等；

在调用bind()方法进行端口绑定时，会根据ServerBootsrap中的初始化参数启动服务端，具体的启动流程为：

创建ServerBootstrap启动辅助类实例，并对其Channel，EventLoopGroup，Handler等参数进行配置；

调用bootstrap.bind()方法时触发启动，会根据配置的Channle类型创建Channel实例，比如NioServerSocketChannel等

在实例化Channel时候会初始化Pipeline管道并与AbstractChannel绑定

将channel管道注册到EventLoopGroup线程池中，从线程池中轮询获取一个线程EventLoop并与之绑定；

启动线程，线程执行绑定的selector的select()方法监听注册的channel的状态，并执行定时任务