// Invariants: mark <= position <= limit <= capacity

	// 标记，调用 mark () 可以将 position 的值赋给 mark，reset () 恢复 position

    private int mark = -1;

	// 位置，下一个要读或写的偏移量

    private int position = 0;

	// 缓冲区当前的终点，不能对大于 limit 的位置修改，limit 位置可以修改

    private int limit;

	// 容量，可容纳最大数据量，不可修改

    private int capacity;

public interface Channel extends Closeable {

    public boolean isOpen();

    public void close() throws IOException;

}

@Slf4j(topic = "Server")

public class NIOServer {

    public static void main(String[] args) throws IOException {

        // 创建选择器 (open 是一个工厂方法)

        Selector selector = Selector.open();

        // 创建 ServerSocketChannel 绑定套接字

        ServerSocketChannel ssChannel = ServerSocketChannel.open();

        ssChannel.socket().bind(new InetSocketAddress("127.0.0.1", 8888));

        // 设置非阻塞

        ssChannel.configureBlocking(false);

        // 将通道注册到选择器上，接受连接事件操作

        ssChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 循环监听

        while (true) {

            // 监听事件，会阻塞直到有至少一个事件到达

            selector.select();

            // 获取到达的事件

            Set<SelectionKey> keys = selector.selectedKeys();

            // 使用迭代器遍历

            Iterator<SelectionKey> keyIterator = keys.iterator();

            while (keyIterator.hasNext()) {

                SelectionKey key = keyIterator.next();

                // 对应 OP_ACCEPT 通道事件，客户端连接先执行这个代码

                if (key.isAcceptable()) {

                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();

                    // 服务器会为每个新连接创建一个 SocketChannel

                    SocketChannel sChannel = ssChannel1.accept();

                    sChannel.configureBlocking(false);

                    log.info("socketChannel HashCode: {}", sChannel.hashCode());

                    // 这个新连接主要用于从客户端读取数据

                    sChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));

                } else if (key.isReadable()) {

                    //key 反向获取对应 Channel

                    SocketChannel sChannel = (SocketChannel) key.channel();

                    // 拿到之前放进去的 ByteBuffer

                    ByteBuffer buffer = (ByteBuffer) key.attachment();

                    sChannel.read(buffer);

                    // 读写反转 limit=position，position = 0

                    buffer.flip();

                    log.info(new String(buffer.array(), buffer.position(), buffer.limit()));

                    sChannel.close();

                }

                // 从 SectionKeys 集合中移除当前已处理的 SelectionKey，重复操作

                keyIterator.remove();

            }

        }

    }

@Slf4j(topic = "Client")

public class NiOClient {

    public static void main(String[] args) throws IOException, IOException {

//        Socket socket = new Socket("127.0.0.1", 8888);

//        OutputStream out = socket.getOutputStream();

//        String s = "hello world";

//        out.write(s.getBytes());

//        out.close();

        SocketChannel socketChannel = SocketChannel.open();

        socketChannel.configureBlocking(false);

        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8888);

        if(!socketChannel.connect(inetSocketAddress)) {

            while (!socketChannel.finishConnect()){

            }

        }

        String str = "你好，啊";

        // 无需指定大小，直接就是你传进的 byte 数组大小

        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes(StandardCharsets.UTF_8));

        socketChannel.write(buffer);

    }

}

@Test

    public void mappedByteBufferTest() throws IOException {

        /*

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

         */

        RandomAccessFile randomAccessFile = new RandomAccessFile("h1.txt", "rw");

        FileChannel fileChannel = randomAccessFile.getChannel();

        // FileChannel.MapMode.READ_WRITE 读写模式

        // 0 可以修改的起始位置

        // 映射到内存的大小，即将文件多少个字节映射到内存

        // 可直接修改的范围是 0-5

        MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

        mappedByteBuffer.put(0, (byte) 'H');

        mappedByteBuffer.put(1, (byte) 'H');

        mappedByteBuffer.put(2, (byte) 'H');

        mappedByteBuffer.put(3, (byte) 'H');

        mappedByteBuffer.put(4, (byte) 'H');

        randomAccessFile.close();

    }