netty源码深入研究（从客户端入手）第一篇

研究源码的前提建立在：

1、首先我们得知道怎么用这个框架

2、其次以用法为入口进行源码研究

ok，我们首先找到入口函数，官方文档有详细介绍,官方地址：点击打开链接，官方文档有提供的详细例子：

public static void main(String[] args) throws Exception {
        String host = args[0];
        int port = Integer.parseInt(args[1]);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        
        try {
            Bootstrap b = new Bootstrap(); // (1)
            b.group(workerGroup); // (2)
            b.channel(NioSocketChannel.class); // (3)
            b.option(ChannelOption.SO_KEEPALIVE, true); // (4)
            b.handler(new ChannelInitializer() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new TimeClientHandler());
                }
            });
            
            // Start the client.
            ChannelFuture f = b.connect(host, port).sync(); // (5)

            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }

这就是官方提供的一个简单的客户端demo，大体上可以了解到，创建客户端必须先创建Bootstrap（英文意思是引导的意思），将

EventLoopGroup的创建绑定到Bootstrap，暂且叫他事件群管理，接下来绑定通道b.channel(NioSocketChannel.class)，然后b.option(ChannelOption.SO_KEEPALIVE, true);开始设置socket属性，再初始化管道设置，最后连接。

现在我们点进

connect

实现链接的第一步

publicChannelFuture connect(SocketAddress remoteAddress) {
        if (remoteAddress == null) {
            throw newNullPointerException("remoteAddress");
        }
          /**
         * 判断有没有设置handler，没有抛异常程序结束
         */
        validate();
        returndoResolveAndConnect(remoteAddress, config.localAddress());
    }
     validate方法主要判断初始化的一些必要参数用户有没有设置  if (group == null) {
           throw new IllegalStateException("group notset");
       }
       if (channelFactory == null) {
           throw new IllegalStateException("channel orchannelFactory not set");
       }
       if (config.handler() == null) {
           throw new IllegalStateException("handler notset");
       }

继续走会进入   
private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();


        if (regFuture.isDone()) {
            if (!regFuture.isSuccess()) {
                return regFuture;
            }
            return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
        } else {
            // Registration future is almost always fulfilled already, but just in case it's not.
            final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
            regFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    // Directly obtain the cause and do a null check so we only need one volatile read in case of a
                    // failure.
                    Throwable cause = future.cause();
                    if (cause != null) {
                        // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
                        // IllegalStateException once we try to access the EventLoop of the Channel.
                        promise.setFailure(cause);
                    } else {
                        // Registration was successful, so set the correct executor to use.
                        // See https://github.com/netty/netty/issues/2586
                        promise.registered();
                        doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
                    }
                }
            });
            return promise;
        }
    }

跟进initAndRegister这个方法注册方法很重要， 连接的时候注册初始化

 final ChannelFuture initAndRegister() {        Channel channel = null;        try {
channelFactory
//利用channelFactory创建通道channel ，也就是上面所传入的NioSocketChannel.class
            channel = channelFactory.newChannel();
//开始初始化channel跟进

            init(channel);
        } catch (Throwable t) {
            if (channel != null) {
                // channel can be null if newChannel crashed (eg SocketException("too many open files"))
                channel.unsafe().closeForcibly();
            }
            // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
            return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
        }
     /**
     * 注册通道
       */
        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }


        return regFuture;
    }

//进入init（）方法继续
 void init(Channel channel) throws Exception {
    /**
    * 把初始化handler句柄加入管道里
    * 用默认的DefaultChannelPipeline管道对象
    */
        ChannelPipeline p = channel.pipeline();
        p.addLast(config.handler());
        final Map, Object> options = options0();
        //把属性的一些设置（如前面设置的 bootStrap.option(ChannelOption.SO_KEEPALIVE, true);
bootStrap.option(ChannelOption.TCP_NODELAY, true);）设置到configuration里面
        synchronized (options) {
            setChannelOptions(channel, options);
        }
/**
attrs属性也设置到config配置里面
*/
        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                channel.attr((AttributeKey