Netty源码分析（二）—客户端初始化

Netty源码分析（二）—客户端初始化

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

个人主页：tuzhenyu’s page

原文地址：Netty源码分析（二）—客户端初始化

(0)客户端初始化

客户端初始化的步骤

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

创建并绑定Reactor线程池EventLoopGroup；

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

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

连接特定IP和端口；

客户端初始化实例

private void connect(String host,int port){
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.group(group).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY,true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
socketChannel.pipeline().addLast(new TimeClientHandler());
}
});

ChannelFuture f = b.connect(host,port).sync();
f.channel().closeFuture().sync();
}catch (Exception e){
e.printStackTrace();
}finally {
group.shutdownGracefully();
}
}

(1) Bootstrap初始化

ServerBootstrap继承AbstracBootstrap类，需要对EventLoopGroup，Channel和ChannelHandler等参数进行配置；

(2) EventLoopGroup线程池初始化

EventLoopGroup初始化是创建创建一个NioEventLoopGroup类型的Reactor线程池group分别用来通道IO事件；

EventLoopGroup group = new NioEventLoopGroup();

BootStrap b = new Bootstrap();

b.group(group);

将group赋值给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通道等；

在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;
}
}

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

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

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

Bootstrap.handler方法接收一个 ChannelHandler, 而我们传递的是一个 派生于ChannelInitializer的匿名类, 它正好也实现了 ChannelHandler接口；在channelInitializer抽象类中存在抽象方法initChannel()需要实现，同时在ChannelInitializer类中channelRegistered方法调用initChannle()方法实现handler处理器添加到pipeline管道中；

public abstract class ChannelInitializer<C extends Channel> extends ChannelInboundHandlerAdapter {

private static final InternalLogger logger = InternalLoggerFactory.getInstance(ChannelInitializer.class);
protected abstract void initChannel(C ch) throws Exception;

@Override
@SuppressWarnings("unchecked")
public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {
initChannel((C) ctx.channel());
ctx.pipeline().remove(this);
ctx.fireChannelRegistered();
}
...
}

在 channelRegistered 方法中, 会调用initChannel 方法, 将自定义的 handler 添加到 ChannelPipeline 中, 然后调用 ctx.pipeline().remove(this) 将自己从 ChannelPipeline 中删除.

(5)客户端的连接过程

完成启动辅助类Bootstrap的参数配置后调用connect()方法连接服务端

public ChannelFuture connect(SocketAddress remoteAddress) {
if(remoteAddress == null) {
throw new NullPointerException("remoteAddress");
} else {
this.validate();
return this.doResolveAndConnect(remoteAddress, this.config.localAddress());
}
}

connect()方法调用validate()方法看各个Part是否准备就绪，然后调用doResolveAndConnect()方法：

private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
ChannelFuture regFuture = this.initAndRegister();
final Channel channel = regFuture.channel();
if(regFuture.isDone()) {
return !regFuture.isSuccess()?regFuture:this.doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
} else {
final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
regFuture.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
Throwable cause = future.cause();
if(cause != null) {
promise.setFailure(cause);
} else {
promise.registered();
Bootstrap.this.doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
}

}
});
return promise;
}
}

通过调用initAndRegister()方法用ChannelFactory创建了一个Channel的实例，然后调用init()方法初始化Channel，最后将Channel注册到EventLoopGroup上：

总结

客户端初始化和服务端初始化基本相同，区别在于Channel的类型设置和Handler处理链的添加等