作者： 一字马胡
转载标志 【2017-11-03】
更新日志
| 日期 | 更新内容 | 备注 |
|---|---|---|
| 2017-11-03 | 添加转载标志 | 持续更新 |
Netty是一个基于NIO的基于事件的高性能网络框架，在NIO里面，比较和核心的三个内容分别是Channel、Buffer、Selector，Channel负责网络数据传输，而
Buffer则存储数据，Buffer可以从Channel中获取到数据，也可以向Channel里面写入数据，Selector可以监听多个Channel的事件，当发生某种事件的时候可以
发出通知。
下面是一个基于Netty的Echo应用的客户端和服务端代码示例：
// 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();
}
// Configure the client.
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
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
if (sslCtx != null) {
p.addLast(sslCtx.newHandler(ch.alloc(), HOST, PORT));
}
//p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new EchoClientHandler());
}
});
// Start the client.
ChannelFuture f = b.connect(HOST, PORT).sync();
// Wait until the connection is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down the event loop to terminate all threads.
group.shutdownGracefully();
}
可以发现，代码中是通过Bootstrap/ServerBootstrap 来启动Echo的服务端和客户端的，其中有一个部分是配置Channel的，服务端和客户端配置的Channel是不一样的，服务端
传入的参数是“NioServerSocketChannel.class”， 而客户端传入的参数为“NioSocketChannel.class”，跟踪代码，进入channel函数：
/**
* The {@link Class} which is used to create {@link Channel} instances from.
* You either use this or {@link #channelFactory(io.netty.channel.ChannelFactory)} if your
* {@link Channel} implementation has no no-args constructor.
*/
public B channel(Class<? extends C> channelClass) {
if (channelClass == null) {
throw new NullPointerException("channelClass");
}
return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
}
发现将我们传进去的参数变为参数生成了一个新的对象ReflectiveChannelFactory，然后将这个对象作为参数传递给了一个叫做channelFactory的函数，先来看一下ReflectiveChannelFactory这个类
到底做了什么事情：
/**
* A {@link ChannelFactory} that instantiates a new {@link Channel} by invoking its default constructor reflectively.
*/
public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {
private final Class<? extends T> clazz;
public ReflectiveChannelFactory(Class<? extends T> clazz) {
if (clazz == null) {
throw new NullPointerException("clazz");
}
this.clazz = clazz;
}
@Override
public T newChannel() {
try {
return clazz.getConstructor().newInstance();
} catch (Throwable t) {
throw new ChannelException("Unable to create Channel from class " + clazz, t);
}
}
}
可以发现，这个类将我们传递进去的参数记录了下来，最为重要的是这个类实现了ChannelFactory这个接口，这个接口只有一个方法，也就是newChannel方法，这个方法负责根据class对象创建
一个新的Channel，也就是根据我们从channel函数里面传递进去的那个class对象（要么是NioServerSocketChannel，要么是NioSocketChannel），通过反射来新建一个新的对象返回。刚才说到
这个新的对象还被传递进去一个方法中去，这个方法叫做channelFactory，这个方法做了什么呢？其实就是将ReflectiveChannelFactory做了一下类型转换，然后保存起来，当需要新建一个Channel
的时候，就会来调用这个channFactory通过newChannel方法来新建一个Channel。
在具体分析NioServerSocketChannel和NioSocketChannel的类之前，还是先搞清楚什么时候调用这个newChannel。通过寻找发现，在类AbstractBootstrap里面的initAndRegister函数里面调用了
newChannel方法来新建一个Channel。那这个initAndRegister方法在哪里会被调用呢？可以发现代码里面有两个地方调用了这个方法，一个地方是服务端在做bind的时候，还有一个地方是客户端
在做connect的时候，也就是说，无论是对于客户端来说，还是对于服务端来说，都是在启动之初就会调用，这也很好理解，无论是客户端还是服务端都是需要基于Channel来做网络操作
（比如read、write），所以肯定是在启动一开始就需要初始化Channel，下面分客户端和服务端来分析一下这个调用链。
首先对于服务端来说，doBind函数里面调用了initAndRegister函数来生成一个新的Channel，下面是一个调用链接：register ← initAndRegister ← doBing0 ← doBind ← bind，当然，到这里还只是分析了新建
一个新的Channel的事情，生成一个Channel之后的流程还没有分析，这个就留到分析Bootstrap和ServerBootstrap的时候再分析吧。
对于客户端来说，调用链是这样的： connect ← doResolveAndConnect。
当然，客户端和服务端最后都将新建Channel来完成启动，然后就可以进行网络IO操作了。下面开始分析两个主要的Channel类，上面也提到过的：NioServerSocketChannel和NioSocketChannel。
下面首先分别贴上两个类的类图：
从上面的类图中可以感受到，两个类的实现还是很复杂的，但是两个类的实现具有共同的实现模式，可以看出两个两个类的类图模式是一模一样的，只是某些类不一样而已。
