作者： 一字马胡
转载标志 【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。
下面首先分别贴上两个类的类图：

image.png image.png

从上面的类图中可以感受到，两个类的实现还是很复杂的，但是两个类的实现具有共同的实现模式，可以看出两个两个类的类图模式是一模一样的，只是某些类不一样而已。