java netty之NioSocketChannel

上一篇文章分析了NioServerSocketChannel，在这篇文章分析一下另外一种SocketChannel，其实也是调用accept之后创建的channel。。。

还是按照惯例来，先看一下它的继承体系吧：

其实和ServerSocketChannel差不太多，只不过这里直接继承的是AbstractNioByteChannel，而不是AbstractNioMessageChannel，也就是说NioSocketChannel的数据是以byte为单位的，而ServerSocketChannel是以对象为单位的。。。

首先我们来看看AbstractByteChannel的定义吧，主要还是里面的unsafe对象，先来看看read方法：

        public void read() {            assert eventLoop().inEventLoop();            final SelectionKey key = selectionKey();            if (!config().isAutoRead()) {                // only remove readInterestOp if needed                key.interestOps(key.interestOps() & ~readInterestOp);            }//获取当前channel的pipeline            final ChannelPipeline pipeline = pipeline(); //获取当前存数据的buffer，这里是基于字节的buffer            final ByteBuf byteBuf = pipeline.inboundByteBuffer();            boolean closed = false;            boolean read = false;            boolean firedChannelReadSuspended = false;            try {                expandReadBuffer(byteBuf);                loop: for (;;) {                //真正的从channel中读取数据                    int localReadAmount = doReadBytes(byteBuf);                    if (localReadAmount > 0) {                        read = true;                    } else if (localReadAmount < 0) {                        closed = true;                        break;                    }                    switch (expandReadBuffer(byteBuf)) {                    case 0:                        // Read all - stop reading.                        break loop;                    case 1:                        // Keep reading until everything is read.                        break;                    case 2:                        // Let the inbound handler drain the buffer and continue reading.                        if (read) {                            read = false;                            pipeline.fireInboundBufferUpdated();  //这个时候会激活注册的函数，用于处理刚刚读进来的数据                            if (!byteBuf.isWritable()) {                                throw new IllegalStateException(                                        "an inbound handler whose buffer is full must consume at " +                                        "least one byte.");                            }                        }                    }                }            } catch (Throwable t) {                if (read) {                    read = false;                    pipeline.fireInboundBufferUpdated();                }                if (t instanceof IOException) {                    closed = true;                } else if (!closed) {                    firedChannelReadSuspended = true;                    pipeline.fireChannelReadSuspended();                }                pipeline().fireExceptionCaught(t);            } finally {                if (read) {                    pipeline.fireInboundBufferUpdated();                }                if (closed) {                    setInputShutdown();                    if (isOpen()) {                        if (Boolean.TRUE.equals(config().getOption(ChannelOption.ALLOW_HALF_CLOSURE))) {                            key.interestOps(key.interestOps() & ~readInterestOp);                            pipeline.fireUserEventTriggered(ChannelInputShutdownEvent.INSTANCE);                        } else {                            close(voidFuture());                        }                    }                } else if (!firedChannelReadSuspended) {                    pipeline.fireChannelReadSuspended();                }            }        }    }

相对来说还是比较容易读懂的吧，首先获取selectionkey，然后获取当前channel的pipeline，然后再从pipeline里面获取用于存储数据的buffer。

至于真正的读取数据的操作，则是调用doReadBytes方法来完成的，这个方法的实现延后到了在NioSocketChannel中实现。。。最后，读取完了数据之后，会调用fireInboundBufferUpdated方法，来激活注册的函数，用于处理刚刚读进来的数据。。。。

另外就还有发送文件的方法，由于这部分还没有怎么看，所以就先不说了。。。

好了，接下来看看NioSocketChannel吧，其实蛮简单的吧，首先是一个静态类方法，用于创建java nio 的socketchannel，其定义如下：

    //用于创建socketchannel    private static SocketChannel newSocket() {        try {            return SocketChannel.open();  //创建socketchannel，这里就与nio联系了起来，在NioServerSocketChannel中，用的是ServerSocketChannel        } catch (IOException e) {            throw new ChannelException("Failed to open a socket.", e);        }    }

另外就还有一些bind，connect函数，然后还有真正的读取和写数据的定义，先来看从channel里读取数据的函数定义吧：

//真正的读取数据，具体是怎么读的要等到分析了buffer的定义之后才知道了    protected int doReadBytes(ByteBuf byteBuf) throws Exception {        return byteBuf.writeBytes(javaChannel(), byteBuf.writableBytes());    }

因为没有看过buffer部分的代码，所以这一部分也就不知道具体的实现了，其实也都能猜出来，无非是从nio channel里面读取数据，然后保存到buf里面去，这部分就留在以后再分析吧。。。

然后就是用于发送数据的方法定义：

//写数据到channel里面，将buf里面的数据发送出去    protected int doWriteBytes(ByteBuf buf, boolean lastSpin) throws Exception {        final int expectedWrittenBytes = buf.readableBytes();  //相当于是需要发送的数据        final int writtenBytes = buf.readBytes(javaChannel(), expectedWrittenBytes);  //这里就是真正的发送数据        final SelectionKey key = selectionKey();   //获取selectionkey        final int interestOps = key.interestOps();   //获取当前channel挂起的事件        if (writtenBytes >= expectedWrittenBytes) {        //如果想要发送的数据都已经发送完了，那么可以更新感兴趣的事件了，将write事件去除            // Wrote the outbound buffer completely - clear OP_WRITE.            if ((interestOps & SelectionKey.OP_WRITE) != 0) {                key.interestOps(interestOps & ~SelectionKey.OP_WRITE);            }        } else {            // Wrote something or nothing.            // a) If wrote something, the caller will not retry.            //    - Set OP_WRITE so that the event loop calls flushForcibly() later.            // b) If wrote nothing:            //    1) If 'lastSpin' is false, the caller will call this method again real soon.            //       - Do not update OP_WRITE.            //    2) If 'lastSpin' is true, the caller will not retry.            //       - Set OP_WRITE so that the event loop calls flushForcibly() later.        //如果没有发送完数据，那么需要挂起写事件            if (writtenBytes > 0 || lastSpin) {                if ((interestOps & SelectionKey.OP_WRITE) == 0) {                    key.interestOps(interestOps | SelectionKey.OP_WRITE);                }            }        }        return writtenBytes;    }}

其实还是比较容易懂，不过具体是怎么发送的还是需要看buf的代码了，不过猜也能猜出来吧。。又不是很复杂。。。

好了，NioServerSocketChannel一起NioSocketChannel都已经分析的差不多了，那么连接这一块也差不多了。。。那么接下来看什么呢。。。buffer？pipeline？future？