// 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();
    }