Java IO模型：BIO、NIO、AIO

阅读原文时间：2023年07月08日阅读：2

Java IO模型：BIO、NIO、AIO

本来是打算直接学习网络框架Netty的，但是先补充了一下自己对Java 几种IO模型的学习和理解。分别是 BIO、NIO、AIO三种IO模型。

BIO模型图

缺点：

如果有很多个Client，则会产生很多个线程。压力主要是在服务器端。客户端的压力并不大。
另外建立连接之后，并不是在时时刻刻的使用。会有空间时间。
会阻塞。

NIO模型图

特点：

事件驱动
多路复用
Netty底层使用的NIO模型

AIO模型

目前还未得到广泛运用。异步非阻塞。先了解就可以。

BIO、NIO、AIO使用场景分析

BOI方式使用与连接数目比较小固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中。JDK1.4以前的唯一选择。但是程序简单容易理解。
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务期间通讯等。编程比较复杂，JDK1.4开始支持。
AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS操作系统参与并发操作，编程比较复杂，JDK7开始支持。但是目前还未得到广泛运用。

JAVA BIO 基本介绍

JAVA BIO 工作机制

JAVA BIO 应用实例

package com.dawa.netty.bio;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 功能需求
 * 1. 使用BIO模型编写一个服务器,监听6666端口,当有客户连接的时候,就启动一个客户端线程与之连接
 * 2. 要求使用县城连接机制,可以连接过个客户端
 * 3. 服务器端可以接受客户端发送的数据(TeInet方法即可)
 */
public class TestBIO {
    public static void main(String[] args) throws Exception {
        //1. 创建一个线程池. 这里 借助 Executors 这个工具类
        ExecutorService pool = Executors.newCachedThreadPool();
        //2. 建立一个监听服务,用来监听客户端连接
        ServerSocket serverSocket = new ServerSocket(6666);

        while (true) {
            final Socket socket = serverSocket.accept();
            System.out.println("一个客户端连接");
            //就创建一个线程与之通信
            pool.execute(new Runnable() {
                public void run() {
                    //编写一个处理方法.
                    handler(socket);
                }
            });
        }
    }

    public static void handler(Socket socket) {
        byte[] bytes = new byte[1024];

        try (InputStream inputStream = socket.getInputStream()) {
            while (true) {
                int read = inputStream.read(bytes);
                if (read != -1) {
                    //注意这里,不能用String转换了.因为String已经不支持有参数的构造方法.
                    System.out.println(Arrays.toString(bytes));
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println("关闭连接");
        }

    }
}

JAVA BIO 问题分析

NIO 基本介绍

NIO的三个核心，channel相当于IO的Socket
Buffer，Channel，Selector(选择器)三大核心组件。
通过Buffer实现非阻塞，
面向缓冲区，或者面向块编程（Buffer就是这样的）。
NIO是事件驱动的

NIO Buffer 基本使用

这没有BooleanBuffer，另外StringBuffer继承自StringBuilder.

一个简单的Buffer子类的使用案例如下

package com.dawa.netty.bio;

import java.nio.IntBuffer;

public class TestNIO {
    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(5);

        for (int i = 0; i < intBuffer.capacity(); i++) {
            System.out.println(intBuffer.put(i*5));
        }

        intBuffer.flip();

        while (intBuffer.hasRemaining()) {
            System.out.println(intBuffer.get());
        }
    }
}

NIO 和 BIO 的比较

NIO 三大核心原理示意图

Selector、Channel和Buffer的关系图

Buffer的Doc源码（java11）

基本介绍

Buffer的子类

容器对象（函数组），如何理解？从源码中可以看到。Int，Float等，每一个子类Buffer对象，都是[]数组。

具有的四个子类

private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

代码跟踪-详解

Buffer类及其子类中的重要的方法

如，通过设置position的值，来读取指定位置的值。也可以修改limit的值等。

ByteBuffer

ByteBuffer，是最常用的。二进制数据。

Channel接口的Doc源码（java11）

基本介绍

Channel的子类

FileChannel类

Channel应用实例

Channel应用实例1——本地文件写数据

实例代码如下：

package com.dawa.netty.nio;

import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class TestNIOFileChannel01 {
    public static void main(String[] args) throws Exception{

        //准备字符串
        String string = "dawa,大娃,Bigbaby";

        //准备输出流.指定输出的文件地址
        FileOutputStream fileOutputStream = new FileOutputStream("dawa.txt");

        //准备Channel管道. 对输出流进行封装,封装为一个channel管道.
        FileChannel fileChannel = fileOutputStream.getChannel();

        //准备一个byte数组, 也就是一个 Buffer数组,来缓存数据
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        //读取数据
        byteBuffer.put(string.getBytes());

          //这里第一次没有反转,文件里面乱码
        byteBuffer.flip();

        //完成写的操作
        fileChannel.write(byteBuffer);

        //关闭流
        fileOutputStream.close();
    }
}

注意：

是FileOutPutStream 包含 NIO FileChannel
FileChannel的具体的实现类是：FileChannelImpl

Channel应用实例2——本地文件读数据

代码案例如下

package com.dawa.netty.nio;

import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

//本地 读文件
public class TestNIOFileChannel02 {
    public static void main(String[] args) throws Exception {

        //读到文件
        File file = new File("dawa.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

        //fileInputStream 包装为 Channel
        FileChannel fileChannel = fileInputStream.getChannel();

        //借助Buffer byte[]缓冲数
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

        //将Channel的数据读入到byteBuffer
        fileChannel.read(byteBuffer);

        System.out.println(new String(byteBuffer.array()));

        fileInputStream.close();

    }
}

Channel应用案例3——使用Buffer完成文件的读写

类似于拷贝的操作，使用文件Channel+Buffer完成

代码案例如下

package com.dawa.netty.nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

//使用一个Channel完成文件的读写
public class TestNIOFileChannel03 {
    public static void main(String[] args)  throws  Exception{

        FileInputStream fileInputStream = new FileInputStream("dawa.txt");
        FileChannel channel01 = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("erwa.txt");
        FileChannel channel02 = fileOutputStream.getChannel();

        //Buffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(512);

        while (true) {
            //这里注意使用Clear操作,不然会进入死循环
            /**
             * public Buffer clear() {
             *         position = 0;
             *         limit = capacity;
             *         mark = -1;
             *         return this;
             *     }
             */
            byteBuffer.clear();

            int read = channel01.read(byteBuffer);
            if (read == -1) {
                break;
            }
            //反转,切换流
            byteBuffer.flip();
            channel02.write(byteBuffer);
        }
                        fileInputStream.close();
            fileOutputStream.close();
    }
}

这里需要注意的是使用clear操作,重置缓冲区基本参数

public Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }

Channel应用案例4——Transferform拷贝

transferFrom方法

    public long transferFrom(ReadableByteChannel src,
                             long position, long count)
        throws IOException
    {
        ensureOpen();
        if (!src.isOpen())
            throw new ClosedChannelException();
        if (!writable)
            throw new NonWritableChannelException();
        if ((position < 0) || (count < 0))
            throw new IllegalArgumentException();
        if (position > size())
            return 0;
        if (src instanceof FileChannelImpl)
           return transferFromFileChannel((FileChannelImpl)src,
                                          position, count);

        return transferFromArbitraryChannel(src, position, count);
    }

案例如下

package com.dawa.netty.nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

//使用一个Channel完成文件的读写
public class TestNIOFileChannel03 {
    public static void main(String[] args)  throws  Exception{

        FileInputStream fileInputStream = new FileInputStream("dawa.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("erwa.txt");

        FileChannel sourceCH = fileInputStream.getChannel();
        FileChannel destCH = fileOutputStream.getChannel();

        //直接通过通道,完成拷贝
        destCH.transferFrom(sourceCH, 0, sourceCH.size());

        fileInputStream.close();
        fileOutputStream.close();

    }
}

关于Buffer和Channel的注意事项和注意细节

存取类型需要保持一致（存取顺序一致）

Buffer可以转为只读Buffer

byteBuffer.asReadOnlyBuffer();

MappedBuffer 可以让文件直接在内存（堆外内存）修改，操作系统不需要拷贝一次

MappedByteBuffer是抽象类，实际能够操作的类型是 DirectByteBuffer

代码案例如下：

```java
package com.dawa.netty.nio;

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

//使用 MappedBuffer 直接完成文件在内存中的数据修改
public class MappedBuffer01 {
public static void main(String[] args) throws Exception {

       //获取一个读取文件流
       RandomAccessFile randomAccessFile = new RandomAccessFile("dawa.txt","rw");   //获取指定的Channel
   FileChannel channel = randomAccessFile.getChannel();

   //读取模式. 0 代表从0开始, 5代表读取5个字节,也同时意味着只能在内存中操作这5个字节
   MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

   //对指定位置进行操作
   mappedByteBuffer.put(0, (byte) 'A');
   mappedByteBuffer.put(2, (byte) 9);

   randomAccessFile.close();
   channel.close();
   }

}

Scattering&Gathering的使用

Scattering：将数据写入到Buffer时，可以采用Buffer数组，依次写入【分散】

Gathering：从Buffer读取数据时，可以采用Buffer数组，依次读【聚合】

解决的问题：当一个数组不够用的时候，可以用数组组，来完成类似的操作

代码案例如下：使用数组，来完成客户端 - 服务器端读取操作

package com.dawa.netty.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

public class ScatteringGatheringGetPut {
    public static void main(String[] args) throws Exception {    //创建服务器端的
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

    //监听端口号
    InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 7000);

    //绑定端口号到服务器端的Channel
    serverSocketChannel.socket().bind(inetSocketAddress);

    //创建Buffer数组
    ByteBuffer[] byteBuffers = new ByteBuffer[2];
    byteBuffers[0] = ByteBuffer.allocate(5);
    byteBuffers[1] = ByteBuffer.allocate(3);

    // 等待连接,获取连接, 并生成客户端的 Channel
    SocketChannel socketChannel = serverSocketChannel.accept();

    //假设从 客户端读取 8个字节
    int messageLength = 8;

    while (true) {
        //1. 将客户端的数据, 读取
        int byteRead = 0;
        while (byteRead &lt; messageLength) {
            long l = socketChannel.read(byteBuffers);
            System.out.println("byteRead = " + byteRead);
            byteRead += 1;//累积读取的字节数

            //使用流打印,看看当前Buffer里面的position和limit
            Arrays.asList(byteBuffers).stream()
                    .map(byteBuffer -&gt; "position=" + byteBuffer.position() + ", limit=" + byteBuffer.limit()).forEach(System.out::println);
        }

        //将所有的 Buffer反转
        Arrays.asList(byteBuffers).forEach(ByteBuffer::flip);

        //2. 将读取到的数据,写回客户端
        int byteWrite = 0;
        while (byteWrite &lt; messageLength) {
            socketChannel.write(byteBuffers);
            byteWrite += 1;
        }

        //将所有的Buffer进行Clear操作
        Arrays.asList(byteBuffers).forEach(ByteBuffer::clear);

        //读完之后,打印出来看看读写文件的长度
        System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWrite + ", messageLength" + messageLength);

    }

}
}

Selector的Doc源码（java11）

基本介绍

示意图：

Select示意图和特点说明

Selector的子类

Selector类的相关方法

PS：一个线程，对应一个Selector，每个Selector通过调用select()方法，获取不同的能够代表Channel的SelectionKey，得到一个能够被选择的Channel集合。

注意事项

NIO非阻塞网络编程原理分析图

NIO非阻塞网络相关的（Selector、SelectionKey、ServerSocketChannel和SocketChannel）关系图梳理。

对上图的说明

当客户端生成时，会通过ServerSocketChannel得到SocketChannel。
Selector开始监听…Selector进行监听select方法，返回有事件发生的通道的个数。
将SocketChannel注册到Selector上.register(Selector sel,int ops).一个Selector上可以注册多个SocketChannel。

SocketChannel的父类里面有注册方法

SelectableChannel里面还有一个注册方法，这个用的比较多
注册后，返回一个SelectionKey，会和该Selector关联（集合）
进一步得到各个SelectionKey（有事件发生）
再通过SelectionKey 反向获取SocketChannel。

SelectionKey类中的channel()方法
通过得到的Channel，完成业务处理

NIO非阻塞网络编程快速入门

创建服务器端。
  1. 创建ServerSocketChannel ，并设置非阻塞
  2. 得到一个Selector对象
  3. 绑定一个端口6666.在服务器端监听
  4. 把servrSocketChannel 注册到 selector  关心事件为 SelectionKey.OP_ACCEPT
  5. 循环等待客户端连接
      //这里我们等待一秒，如果没有事件发生，返回
      1. if(selector.selecct(1000)==0){//没有事件发生
      sout("服务器等待了一秒");
      continue;
    }

        //如果返回的值>0,就获取到相关的selectionKey集合
        // 1. 表示已经获取到关注的事件。
        // 2. 通过selectionKeys()返回关注的集合。
        // 3. 通过selectionKeys
        seletor.selectedKeys().var;

        //遍历得到的selectionKeys.
            //1. 获取SelectionKey
            //2. 根据key 对应的通道发生的事件做处理
            //3. 如果是 OP_ACCEPT，有新的客户端连接
                    //1. 给该客户端生成一个SocketChannel
                    //2. 将SocketChannel 注册到select,关注事件为OP_READ，并关联一个Buffer
            //4. 如果是 OP_READ，读取数据
                    //1. 通过key,反向获取对应的channel
                    //2. 获取到该channel关联的buffer
            //5. 手动从集合中移动单签的SelectionKey，防止重复操作。

创建客户端。
  1. 得到一个网络通道SocketChannel.并设置非阻塞
  2. 提供服务区的IP和端口，连接服务器

服务器端代码

package com.dawa.netty.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

// NIO 服务端
public class TestNIOServer {
    public static void main(String[] args) throws Exception {

        //  1. 创建ServerSocketChannel ，并设置非阻塞
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        //  2. 得到一个Selector对象
        Selector selector = Selector.open();
        //  3. 绑定一个端口6666.在服务器端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //  4. 把serverSocketChannel 注册到 selector  关心事件为 SelectionKey.OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环,等待客户端连接
        while (true) {
            if (selector.select(1000) == 0) {// 没有事件发生
                System.out.println("服务器端等待1秒,没有客户端连接");
                continue;
            }
            Set<SelectionKey> selectionKeys = selector.selectedKeys();//得到所有被选中的Key
            //循环遍历每一个key,每一个key代表一个事件
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                //根据key对应的事件,做响应的处理
                if (selectionKey.isAcceptable()) {//如果是 Accept事件, 连接事件,则生成对应的客户端Channel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    //将SocketChannel 注册到select,关注事件为OP_READ，并关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if (selectionKey.isReadable()) {//如果是读事件
                    //1. 通过key,反向生成Channel
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    //设置非同步NIO
                    socketChannel.configureBlocking(false);
                    //2. 获取到该channel关联的buffer
                    ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                    socketChannel.read(buffer);
                    //打印出获取到的Buffer
                    System.out.println("from 客户端:" + new String(buffer.array()));
                }
                //这里一定要记得把处理过的key给移除掉,自己遇到了死循环.
                iterator.remove();
            }
        }
    }
}

客户端代码

package com.dawa.netty.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

//NIO 客户端
public class TestNIOClient {
    public static void main(String[] args) throws Exception {

        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        //服务器端的IP和端口
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 6666);

        if (!socketChannel.connect(socketAddress)) {
            System.out.println("连接失败,但是可以干其他事情,非阻塞");
            while (!socketChannel.finishConnect()) {
                System.out.println("在连接完成之前,我一直干其他的事情");
            }
        }

        String string = "hello,dawa";
        socketChannel.write(ByteBuffer.wrap(string.getBytes()));
        System.in.read();
    }
}

SelectionKey

Selector.keys() 是列出所有的key。

Selector.selectedKeys()是列出所有被选中的key。

这两个是不一样的。

ServerSocketChannel

SocketChannel

功能示意图

服务器端代码

构造器初始化

监听方法

Listen()

里面循环的写法：

里面读数据的方法：

try catch完成离线处理

里面转发给其他客户端的方法

客户端代码

构造器初始化
向服务器发消息
读取从服务器端回复的消息

启动客户端和服务器端

启动客户端的方法
启动服务器端的方法

自己编码：实现群发

客户端代码

package com.dawa.netty.nio.group;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

//客户端
public class GroupCharClient {

    private SocketChannel socketChannel;
    private static final int PORT = 6667;
    private static final String HOST = "127.0.0.1";
    private Selector selector;
    private String userName;

    public GroupCharClient() throws IOException {
        selector = Selector.open();
        //连接服务器
        socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
        userName = socketChannel.getRemoteAddress().toString().substring(1);
    }

    //发送消息
    public void sendMessage(String message){
        message = userName + "说" + message;
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
        try {
            socketChannel.write(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读取服务器端发来的消息
    public void readMessage() {
        try {
            int readChannels = selector.select();
            if (readChannels > 0) {//有可用的通道
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        socketChannel.read(buffer);

                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    }
                }
            } else {
                //没有可用的通道
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        GroupCharClient groupCharClient = new GroupCharClient();

        new Thread(() -> {
            while (true) {
                groupCharClient.readMessage();
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        //发送数据给服务器端
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String message = scanner.nextLine();
            groupCharClient.sendMessage(message);
        }
    }

}

服务器端代码

package com.dawa.netty.nio.group;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

/**
 * 服务器端代码
 */
public class GroupChatServer {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private static final int PORT = 6666;

    public GroupChatServer() {
        try {
            //得到选择器
            selector = Selector.open();
            //绑定端口
            serverSocketChannel = ServerSocketChannel.open().bind(new InetSocketAddress(PORT));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //服务器端监听的方法
    public void listen() {
        try {
            //循环监听
            while (true) {
                int count = selector.select();
                if (count > 0) {
                    Iterator<SelectionKey> selectionKeyIterator = selector.selectedKeys().iterator();
                    while (selectionKeyIterator.hasNext()) {
                        //取出Key
                        SelectionKey key = selectionKeyIterator.next();

                        //判断事件
                        if (key.isAcceptable()) {//监听访问
                            //key 转Channel
                            SocketChannel channel = serverSocketChannel.accept();
                            SocketAddress remoteAddress = channel.getRemoteAddress();
                            System.out.println(remoteAddress + ":上线了");
                        }
                        if (key.isReadable()) {//读取事件
                            //处理读
                            readData(key);
                        }
                        //移除已经处理的key
                        selectionKeyIterator.remove();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读数据
    public void readData(SelectionKey key) {
        SocketChannel channel = null;
        try {
            //根据key,取得Channel
            channel = (SocketChannel) key.channel();
            channel.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int read = channel.read(buffer);
            if (read > 0) {
                String message = new String(buffer.array());
                System.out.println("from: 客户端" + message);

                // 向其他用户,转发消息
                sendMessageToOtherCLient(message,key);
            }

        } catch (IOException e) {
            try {
                System.out.println(channel.getRemoteAddress() + " :离线了");
                key.cancel();
                channel.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    //向其他用户转发消息
    public void sendMessageToOtherCLient(String message,SelectionKey self){
        System.out.println("服务器转发消息ing");

        selector.keys().forEach(key -> {
            //根据Key,取出对应的SocketChannel.或者是ServerSocketChannel
            Channel targetChannel = key.channel();
            //排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                //转型
                SocketChannel dest = (SocketChannel) targetChannel;
                //Buffer
                ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
                try {
                    dest.write(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

    }

    public static void main(String[] args) {
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}