45 张图深度解析 Netty 架构与原理（上）

    public     static     void main(String[] args)     throws{
    ExecutorService threadPool = Executors.newCachedThreadPool();
    ServerSocket serverSocket =     new ServerSocket(8080);

        while (    true) {
        Socket socket = serverSocket.accept();
        threadPool.execute(() -> {
            handler(socket);
        });
    }
}

/**
 * 处理客户端请求
 */
    private     static     void handler(Socket socket)     throws{
        byte[] bytes =     new     byte[1024];

    InputStream inputStream = socket.getInputStream();
    socket.close();

        while (    true) {
            int read = inputStream.read(bytes);
            if (read != -1) {
            System.out.println("msg from client: " +     new String(bytes, 0, read));
        }     else {
                break;
        }
    }
}

    public     static     void main(String[] args)     throws{
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    Selector selector = Selector.open();

    // 绑定端口
    serverSocketChannel.socket().bind(    new InetSocketAddress(8080));

    // 设置 serverSocketChannel 为非阻塞模式
    serverSocketChannel.configureBlocking(    false);

    // 注册 serverSocketChannel 到 selector，关注 OP_ACCEPT 事件
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (    true) {
        // 没有事件发生
            if (selector.select(1000) == 0) {
                continue;
        }

        // 有事件发生，找到发生事件的 Channel 对应的 SelectionKey 的集合
        Set<SelectionKey> selectionKeys = selector.selectedKeys();

        Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
            SelectionKey selectionKey = iterator.next();

            // 发生 OP_ACCEPT 事件，处理连接请求
                if (selectionKey.isAcceptable()) {
                SocketChannel socketChannel = serverSocketChannel.accept();

                // 将 socketChannel 也注册到 selector，关注 OP_READ
                // 事件，并给 socketChannel 关联 Buffer
                socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
            }

            // 发生 OP_READ 事件，读客户端数据
                if (selectionKey.isReadable()) {
                SocketChannel channel = (SocketChannel) selectionKey.channel();
                ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                channel.read(buffer);

                System.out.println("msg form client: " +     new String(buffer.array()));
            }

            // 手动从集合中移除当前的 selectionKey，防止重复处理事件
            iterator.remove();
        }
    }
}

    public     abstract     class Selector     implements Closeable {
    ......
    
    /**
     * 得到一个选择器对象
     */
        public     static Selector open()     throws{
            return SelectorProvider.provider().openSelector();
    }
    ......

    /**
     * 返回所有发生事件的 Channel 对应的 SelectionKey 的集合，通过
     * SelectionKey 可以找到对应的 Channel
     */
        public     abstract Set<SelectionKey> selectedKeys();
    ......
    
    /**
     * 返回所有 Channel 对应的 SelectionKey 的集合，通过 SelectionKey
     * 可以找到对应的 Channel
     */
        public     abstract Set<SelectionKey> keys();
    ......
    
    /**
     * 监控所有注册的 Channel，当其中的 Channel 有 IO 操作可以进行时，
     * 将这些 Channel 对应的 SelectionKey 找到。参数用于设置超时时间
     */
        public     abstract     int select(    long     throws;
    
    /**
    * 无超时时间的 select 过程，一直等待，直到发现有 Channel 可以进行
    * IO 操作
    */
        public     abstract     int select()     throws;
    
    /**
    * 立即返回的 select 过程
    */
        public     abstract     int selectNow()     throws;
    ......
    
    /**
    * 唤醒 Selector，对无超时时间的 select 过程起作用，终止其等待
    */
        public     abstract Selector wakeup();
    ......
}

/**
* SocketChannel 继承 AbstractSelectableChannel
*/
    public     abstract     class SocketChannel
        extends AbstractSelectableChannel
        implements ByteChannel, 
               ScatteringByteChannel, 
               GatheringByteChannel, 
               NetworkChannel
{
    ......
}

    public     abstract     class AbstractSelectableChannel
        extends SelectableChannel
{
    ......
    /**
     * AbstractSelectableChannel 中包含注册方法，SocketChannel 实例
     * 借助该注册方法注册到 Selector 实例上去，该方法返回 SelectionKey
     */
        public     final SelectionKey register(
        // 指明注册到哪个 Selector 实例
        Selector sel, 
        // ops 是事件代码，告诉 Selector 应该关注该通道的什么事件
            int ops,
        // 附加信息 attachment
        Object att)     throws{
        ......
    }
    ......
}

    public     abstract     class SelectionKey {
    ......

    /**
     * 获取该 SelectionKey 对应的 Channel
     */
        public     abstract SelectableChannel channel();

    /**
     * 获取该 SelectionKey 对应的 Selector
     */
        public     abstract Selector selector();
    ......
    
    /**
     * 事件代码，上面的 ops 参数取这里的值
     */
        public     static     final     int OP_READ = 1 << 0;
        public     static     final     int OP_WRITE = 1 << 2;
        public     static     final     int OP_CONNECT = 1 << 3;
        public     static     final     int OP_ACCEPT = 1 << 4;
    ......
    
    /**
     * 检查该 SelectionKey 对应的 Channel 是否可读
     */
        public     final     boolean isReadable(){
            return (readyOps() & OP_READ) != 0;
    }

    /**
     * 检查该 SelectionKey 对应的 Channel 是否可写
     */
        public     final     boolean isWritable(){
            return (readyOps() & OP_WRITE) != 0;
    }

    /**
     * 检查该 SelectionKey 对应的 Channel 是否已经建立起 socket 连接
     */
        public     final     boolean isConnectable(){
            return (readyOps() & OP_CONNECT) != 0;
    }

    /**
     * 检查该 SelectionKey 对应的 Channel 是否准备好接受一个新的 socket 连接
     */
        public     final     boolean isAcceptable(){
            return (readyOps() & OP_ACCEPT) != 0;
    }

    /**
     * 添加附件（例如 Buffer）
     */
        public     final Object attach(Object ob){
            return attachmentUpdater.getAndSet(    this, ob);
    }

    /**
     * 获取附件
     */
        public     final Object attachment(){
            return attachment;
    }
    ......
}

    ssize_t read(    int filedes,     void *buf,     size_t;
    ssize_t write(    int filedes,     void *buf,     size_t;

    void *mmap(    void *addr,     size_t length,     int prot,     int flags,     int fd,     off_t;

    ssize_t sendfile(    int out_fd,     int in_fd,     off_t *offset,     size_t;

FileChannel.transderTo(    long position,     long count, WritableByteChannel target);

    public     static     void main(String[] args)     throws{
    SocketChannel socketChannel = SocketChannel.open();
    socketChannel.connect(    new InetSocketAddress("127.0.0.1", 8080));
    String fileName = "test.zip";

    // 得到一个文件 channel
    FileChannel fileChannel =     new FileInputStream(fileName).getChannel();
    
    // 使用零拷贝 IO 技术发送
        long transferSize = fileChannel.transferTo(0, fileChannel.size(), socketChannel);
    System.out.println("file transfer done, size: " + transferSize);
    fileChannel.close();
}