public abstract class Selector implements Closeable {
    protected Selector() { }
	// 創(chuàng)建 Selector 實例
    public static Selector open() throws IOException {
        return SelectorProvider.provider().openSelector();
    }
    public abstract boolean isOpen();
    public abstract SelectorProvider provider();
	//  key set 代表了所有注冊在這個 Selector 上的 channel ，這個集合可以通過 keys() 方法拿到。
    public abstract Set<SelectionKey> keys();
	// Selected-key set 代表了所有通過 select() 方法監(jiān)測到可以進行 IO 操作的 channel ，這個集合可以通過 selectedKeys() 拿到。
    public abstract Set<SelectionKey> selectedKeys();
    public abstract int selectNow() throws IOException;
	// 可以設置超時的 select() 操作。
    public abstract int select(long timeout) throws IOException;
	// 監(jiān)控所有注冊的 channel ，當其中有注冊的 IO 操作可以進行時，該函數(shù)返回，并將對應的 SelectionKey 加入 selected-key set 。
    public abstract int select() throws IOException;
	// 使一個還未返回的 select() 操作立刻返回。
    public abstract Selector wakeup();
    public abstract void close() throws IOException;
}

public abstract class Buffer {
    static final int SPLITERATOR_CHARACTERISTICS =
        Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1;		// 一個臨時存放的位置下標。調用 mark() 會將 mark 設為當前的 position 的值，以后調用 reset() 會將 position 屬性設置為 mark 的值。 mark 的值總是小于等于 position 的值，如果將 position 的值設的比 mark 小，當前的 mark 值會被拋棄掉。
    private int position = 0;		// 讀 / 寫操作的當前下標。當使用 buffer 的相對位置進行讀 / 寫操作時，讀 / 寫會從這個下標進行，并在操作完成后， buffer 會更新下標的值。
    private int limit;		// 在 Buffer 上進行的讀寫操作都不能越過這個下標。當寫數(shù)據(jù)到 buffer 中時， limit 一般和 capacity 相等，當讀數(shù)據(jù)時， limit 代表 buffer 中有效數(shù)據(jù)的長度。
    private int capacity;		// 這個 Buffer 最多能放多少數(shù)據(jù)。 capacity 一般在 buffer 被創(chuàng)建的時候指定
    long address;
    Buffer(int mark, int pos, int lim, int cap) {       // package-private
        if (cap < 0)
            throw new IllegalArgumentException("Negative capacity: " + cap);
        this.capacity = cap;
        limit(lim);
        position(pos);
        if (mark >= 0) {
            if (mark > pos)
                throw new IllegalArgumentException("mark > position: ("
                                                   + mark + " > " + pos + ")");
            this.mark = mark;
        }
    }
    public final int capacity() {
        return capacity;
    }
    public final int position() {
        return position;
    }
    public final Buffer position(int newPosition) {
        if ((newPosition > limit) || (newPosition < 0))
            throw new IllegalArgumentException();
        position = newPosition;
        if (mark > position) mark = -1;
        return this;
    }
    public final int limit() {
        return limit;
    }
    public final Buffer limit(int newLimit) {
        if ((newLimit > capacity) || (newLimit < 0))
            throw new IllegalArgumentException();
        limit = newLimit;
        if (position > limit) position = limit;
        if (mark > limit) mark = -1;
        return this;
    }
    public final Buffer mark() {
        mark = position;
        return this;
    }
	// 
    public final Buffer reset() {
        int m = mark;
        if (m < 0)
            throw new InvalidMarkException();
        position = m;
        return this;
    }
	// 把 position 設為 0 ，把 limit 設為 capacity ，一般在把數(shù)據(jù)寫入 Buffer 前調用。
    public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }
	// 把 limit 設為當前 position ，把 position 設為 0 ，一般在從 Buffer 讀出數(shù)據(jù)前調用。
    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }
	// 把 position 設為 0 ， limit 不變，一般在把數(shù)據(jù)重寫入 Buffer 前調用。
    public final Buffer rewind() {
        position = 0;
        mark = -1;
        return this;
    }
    public final int remaining() {
        return limit - position;
    }
    public final boolean hasRemaining() {
        return position < limit;
    }
	// 用來判斷一個 Buffer 是否只讀
    public abstract boolean isReadOnly();
    public abstract boolean hasArray();
    public abstract Object array();
    public abstract int arrayOffset();
    public abstract boolean isDirect();
    final int nextGetIndex() {                          // package-private
        if (position >= limit)
            throw new BufferUnderflowException();
        return position++;
    }
    final int nextGetIndex(int nb) {                    // package-private
        if (limit - position < nb)
            throw new BufferUnderflowException();
        int p = position;
        position += nb;
        return p;
    }
    final int nextPutIndex() {                          // package-private
        if (position >= limit)
            throw new BufferOverflowException();
        return position++;
    }
    final int nextPutIndex(int nb) {                    // package-private
        if (limit - position < nb)
            throw new BufferOverflowException();
        int p = position;
        position += nb;
        return p;
    }
    final int checkIndex(int i) {                       // package-private
        if ((i < 0) || (i >= limit))
            throw new IndexOutOfBoundsException();
        return i;
    }
    final int checkIndex(int i, int nb) {               // package-private
        if ((i < 0) || (nb > limit - i))
            throw new IndexOutOfBoundsException();
        return i;
    }
    final int markValue() {                             // package-private
        return mark;
    }
    final void truncate() {                             // package-private
        mark = -1;
        position = 0;
        limit = 0;
        capacity = 0;
    }
    final void discardMark() {                          // package-private
        mark = -1;
    }
    static void checkBounds(int off, int len, int size) { // package-private
        if ((off | len | (off + len) | (size - (off + len))) < 0)
            throw new IndexOutOfBoundsException();
    }
}

boolean isOpen()	// 該 Channel 是否是打開的。 
void close()		// 關閉這個 Channel ，相關的資源會被釋放。 

int read(ByteBuffer dst) 	// 從 channel 中讀取 byte 數(shù)據(jù)并寫到 ByteBuffer 中。返回讀取的 byte 數(shù)。

int write(ByteBuffer src)	// 從 ByteBuffer 中讀取 byte 數(shù)據(jù)并寫到 channel 中。返回寫出的 byte 數(shù)。 

public abstract class SelectableChannel extends AbstractInterruptibleChannel implements Channel
{
    protected SelectableChannel() { }
    public abstract SelectorProvider provider();
	// 返回一個 bit mask ，表示這個 channel 上支持的 IO 操作。當前在 SelectionKey 中，用靜態(tài)常量定義了 4 種 IO 操作的 bit 值： OP_ACCEPT ， OP_CONNECT ， OP_READ 和 OP_WRITE 。
    public abstract int validOps();
	// 該 channel 是否已注冊在一個或多個 Selector 上
    public abstract boolean isRegistered();
	// 返回該 channe 在 Selector 上的注冊關系所對應的 SelectionKey 。若無注冊關系，返回 null 。
    public abstract SelectionKey keyFor(Selector sel);
	// 多出來的 att 參數(shù)會作為 attachment 被存放在返回的 SelectionKey 中，這在需要存放一些 session state 的時候非常有用。
    public abstract SelectionKey register(Selector sel, int ops, Object att) throws ClosedChannelException;
	// 將當前 channel 注冊到一個 Selector 上并返回對應的 SelectionKey 。在這以后，通過調用 Selector 的 select() 函數(shù)就可以監(jiān)控這個 channel 。 ops 這個參數(shù)是一個 bit mask ，代表了需要監(jiān)控的 IO 操作。
    public final SelectionKey register(Selector sel, int ops) throws ClosedChannelException
    {
        return register(sel, ops, null);
    }
	// 設置 blocking 模式
    public abstract SelectableChannel configureBlocking(boolean block) throws IOException;
	// 返回是否為 blocking 模式
    public abstract boolean isBlocking();
    public abstract Object blockingLock();
}

public class NIOClient {
    public static void main(String[] args) throws Exception{
        //得到一個網絡通道
        SocketChannel socketChannel = SocketChannel.open();
        //設置非阻塞
        socketChannel.configureBlocking(false);
        //連接網絡
        InetSocketAddress address = new InetSocketAddress("localhost",8081);
        //判斷是否連接
        if(!socketChannel.connect(address)){
            while(!socketChannel.finishConnect()){
                System.out.println("沒有服務端進行連接");
            }
        }
        //要發(fā)送的內容
        String str = "hello NIO 服務端！";
        // 將要轉發(fā)的字符串內容轉換成 Byte 類型
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        //寫入通道
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

public class NIOServer {
    public static void main(String[] args) throws Exception{
        //得到通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //得到selector對象
        Selector selector = Selector.open();
        //設置為非阻塞
        serverSocketChannel.configureBlocking(false);
        //設置端口
        serverSocketChannel.bind(new InetSocketAddress(8081));
        //注冊到selector對象上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while(true){
            //監(jiān)控客戶端
            if(selector.select(200)==0){
                System.out.println("沒有服務端連接");
                continue;
            }
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                //獲取所有的監(jiān)聽對象
                SelectionKey selectionKey = iterator.next();
                //連接客戶端
                if(selectionKey.isAcceptable()){
                    //得到通道
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1023));
                }
                //讀取數(shù)據(jù)
                if(selectionKey.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                    socketChannel.read(buffer);
                    System.out.printf("客戶端發(fā)來的數(shù)據(jù):%s%n", new String(buffer.array()));
                }
                //刪除防止重復發(fā)送
                iterator.remove();
            }
        }
    }
}

 public static byte[] readBytes(String fileName) {
      try {
          ///獲取對應文件的FileChannel對象
          RandomAccessFile accessFile = new RandomAccessFile(fileName, "rw");
          FileChannel fileChannel = accessFile.getChannel();
          /// 創(chuàng)建一個緩沖區(qū)（大小為48byte）
          ByteBuffer byteBuffer = ByteBuffer.allocate(48);
          StringBuilder builder = new StringBuilder();
		  // 從文件向緩沖區(qū)寫入數(shù)據(jù)
          int bytesRead = fileChannel.read(byteBuffer);
          // 若讀取到該通道數(shù)據(jù)的末尾，則返回-1  
          while (bytesRead != -1) {
              System.out.println("Read " + bytesRead);
              // 由向緩沖區(qū)寫入數(shù)據(jù)轉換成從緩沖區(qū)讀取數(shù)據(jù)需要調用該方法
              byteBuffer.flip();
              ///每次讀取完之后，輸出緩存中的內容
              while (byteBuffer.hasRemaining()) {
                  System.out.println((char) byteBuffer.get());
                  builder.append((char) byteBuffer.get());
              }
              // 然后清空緩存區(qū)
              byteBuffer.clear();
              // 重新再讀數(shù)據(jù)到緩存區(qū)中
              bytesRead = fileChannel.read(byteBuffer);
          }
          accessFile.close();
          return builder.toString().getBytes();
      } catch (IOException e) {
          e.printStackTrace();
          return null;
      }
  }

  public static void writeBytes(String fileName, byte[] data) {
      try {
          RandomAccessFile accessFile = new RandomAccessFile(fileName, "rw");
          FileChannel channel = accessFile.getChannel();
          ByteBuffer buffer = ByteBuffer.allocate(48);
          buffer.put(data);
          channel.write(buffer);
      } catch (FileNotFoundException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

  /**
   * channel 間的傳輸
   *
   * @param sFileName 源文件
   * @param dFileName 目標文件
   */
  public static void channelToChannel(String sFileName, String dFileName) {
      try {
          RandomAccessFile sAccess = new RandomAccessFile(sFileName, "rw");
          RandomAccessFile dAccess = new RandomAccessFile(dFileName, "rw");
          FileChannel sChannel = sAccess.getChannel();
          FileChannel dChannel = dAccess.getChannel();
          long pos = 0;
          long sCount = sChannel.size();
          long dCount = dChannel.size();
//            dChannel.transferFrom(sChannel,pos,sCount);//dChannel 必須是FileChannel
          sChannel.transferTo(pos, dCount, dChannel);///sChannel 是FileChannel
      } catch (FileNotFoundException e) {
          e.printStackTrace();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

   /**
   * 關于：DatagramChannel
   * UDP 無連接網絡協(xié)議
   * 發(fā)送和接收的是數(shù)據(jù)包
   */
  public static void datagramChannel() {
      DatagramChannel datagramChannel = null;
      try {
          ///打開
          datagramChannel = DatagramChannel.open();
          ///連接并開始監(jiān)聽UDP 9999端口
          datagramChannel.socket().bind(new InetSocketAddress(9999));
          // 接收數(shù)據(jù)包（receive()方法會將接收到的數(shù)據(jù)包內容復制到指定的Buffer. 如果Buffer容不下收到的數(shù)據(jù)，多出的數(shù)據(jù)將被丟棄。 ）
          ByteBuffer buf = ByteBuffer.allocate(48);
          buf.clear();
          datagramChannel.receive(buf);
          // 發(fā)送數(shù)據(jù) send()
          String sendMsg = "要發(fā)送的數(shù)據(jù)";
          ByteBuffer sendBuf = ByteBuffer.allocate(48);
          sendBuf.clear();
          sendBuf.put(sendMsg.getBytes());
          sendBuf.flip();
          datagramChannel.send(sendBuf,new InetSocketAddress("xxxxx",80));
          // TODO: 連接到特定的地址(鎖住DatagramChannel ，讓其只能從特定地址收發(fā)數(shù)據(jù) 因為UDP無連接，本身沒有真正的連接產出)
          datagramChannel.connect(new InetSocketAddress("jenkov.com", 80));
          ///連接后，也可以使用Channal 的read()和write()方法，就像在用傳統(tǒng)的通道一樣。只是在數(shù)據(jù)傳送方面沒有任何保證
      } catch (IOException e) {
          e.printStackTrace();
      } finally {
          if (datagramChannel != null)
              try {
                  datagramChannel.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
      }
  }

/**
   * 關于NIO管道（Pipe）
   * 定義：2個線程之間的單向數(shù)據(jù)連接
   */
  public static void aboutPipe(){
      Pipe pipe=null;
      try {
          /// 打開管道
          pipe = Pipe.open();
          ///TODO: 一、 向管道寫入數(shù)據(jù)
          /// 訪問Pipe.sinkChannel，向Pipe寫入數(shù)據(jù)
          /// 首先，獲取Pipe.sinkChannel
          Pipe.SinkChannel sinkChannel = pipe.sink();
          /// 然后，調用write()，開始寫入數(shù)據(jù)
          String newData = "New String to write to file..." + System.currentTimeMillis();
          ByteBuffer buf = ByteBuffer.allocate(48);
          buf.clear();
          buf.put(newData.getBytes());
          buf.flip();
          while(buf.hasRemaining()){
          sinkChannel.write(buf);
          }
          // TODO: 二、讀取管道中的數(shù)據(jù)
          // 首先，獲取Pipe.sourceChannel
          Pipe.SourceChannel sourceChannel = pipe.source();
          /// 讀取數(shù)據(jù)到buffer
          ByteBuffer buf2 = ByteBuffer.allocate(48);
          int bytesRead = sourceChannel.read(buf2);
      } catch (IOException e) {
          e.printStackTrace();
      }
  }