在做关于NIO TCP编程小案例时遇到无法监听write的问题，没想到只是我的if语句的位置放错了位置，哎，看了半天没看出来

在做关于NIO TCP编程小案例时遇到无法监听write的问题，没想到只是我的if语句的位置放错了位置，哎，看了半天没看出来

贴下课堂笔记：

在Java中使用NIO进行网络TCP套接字编程主要以下几个类：

ServerSocketChannel: 服务端套接字通道,主要监听接收客户端请求

Selector：通道选择器,主要用于管理服务端通道和所有客户端通道(监听通道中发生的事件)，也就说是一个多路通道复用器。

SelectorKey: 事件选择键

SocketChannel: 套接字通道(客户端)

这篇文章《NIO编程中的SelectionKey.interestOps方法中的逻辑运算》解决了我一些疑问，地址:https://blog.csdn.net/woaiqianzhige/article/details/78696188

NIO 套接字服务端开发步骤：

1. 创建选择器
2. 启动服务端通道
3. 设置服务端通道为非阻塞模式
4. 将服务端通道注册到选择器
5. 轮训通道事件
6. 处理通道事件
7. 关闭通道(可选)

案例：服务端接收客户端发送的短信息，服务端回复已收到。

服务端代码：

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.ClosedChannelException;
 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;

 public class Server {
     private Selector selector;
     private ServerSocketChannel serverSocketChannel;
     private ByteBuffer byteBuffer = ByteBuffer.allocate(8192);

     /**
      * 构造方法 启动服务器
      *
      * @param port
      * @throws IOException
      */
     public Server() {
         try {
             selector = Selector.open();
             serverSocketChannel = ServerSocketChannel.open();
             serverSocketChannel.configureBlocking(false);
             serverSocketChannel.bind(new InetSocketAddress(10086));
             serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
             System.out.println("Server start successful with port: 10086");
         } catch (ClosedChannelException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) throws Exception {
         new Server().start();
     }

     private void start() {
         while (true) {
             try {
                 selector.select();
                 Set<SelectionKey> keys = selector.selectedKeys();
                 Iterator<SelectionKey> keyIterator = keys.iterator();
                 while (keyIterator.hasNext()) {
                     SelectionKey key = keyIterator.next();
                     keyIterator.remove();
                     if (!key.isValid()) {
                         continue;
                     }
                     if (key.isAcceptable()) {
                         accept(key);
                     }
                     if (key.isReadable()) {
                         receive(key);
                     }
                     if (key.isWritable()) {
                         reply(key);
                     }
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

     private void reply(SelectionKey key) {
         try {
             SocketChannel socketChannel = (SocketChannel) key.channel();
             byteBuffer.clear();
             String message = "receive success";
             byteBuffer.put(message.getBytes());
             byteBuffer.flip();
             socketChannel.write(byteBuffer);
             System.out.println("reply:" + message);
             byteBuffer.clear();
             key.interestOps(SelectionKey.OP_READ);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     private void receive(SelectionKey key) {
         try {
             SocketChannel socketChannel = (SocketChannel) key.channel();
             byteBuffer.clear();
             int flag = socketChannel.read(byteBuffer);
             if (flag == -1) {
                 key.channel().close();
                 key.cancel();
                 return;
             }
             byteBuffer.flip();
             byte[] buf = new byte[byteBuffer.remaining()];
             byteBuffer.get(buf);
             String message = new String(buf);
             System.out.println("receive message:" + message);
             byteBuffer.clear();
             key.interestOps(SelectionKey.OP_WRITE);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     private void accept(SelectionKey key) {
         try {
             SocketChannel socketChannel = serverSocketChannel.accept();
             socketChannel.configureBlocking(false);
             socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
             System.out.println(Thread.currentThread().getName() + ": create client channel.");
         } catch (ClosedChannelException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

客户端代码：

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.ClosedChannelException;
 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 Client {
     private Selector selector;
     private ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
     private SocketChannel socketChannel;

     public Client() {
         try {
             selector = Selector.open();
             socketChannel = SocketChannel.open();
             socketChannel.configureBlocking(false);
             socketChannel.register(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ | SelectionKey.OP_WRITE);
             socketChannel.connect(new InetSocketAddress("127.0.0.1", 10086));
             System.out.println("Client start successful");
         } catch (ClosedChannelException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         new Client().start();
     }

     private void start() {
         while (true) {
             try {
                 selector.select();
                 Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
                 while (keys.hasNext()) {
                     SelectionKey key = keys.next();
                     keys.remove();
                     if (!key.isValid()) {
                         continue;
                     }
                     if (key.isConnectable()) {
                         if (socketChannel.finishConnect()) {
                             key.interestOps(key.interestOps() & ~SelectionKey.OP_CONNECT);
                             System.out.println("Client connect server success");
                         }
                     }
                     if (key.isReadable()) {
                         receive(key);
                     }
                     if (key.isWritable()) {
                         reply(key);
                     }
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

     private void reply(SelectionKey key) {
         try {
             @SuppressWarnings("resource")
             Scanner scanner = new Scanner(System.in);
             byteBuffer.clear();
             System.out.println("please input message:");
             String message = scanner.next();
             byteBuffer.put(message.getBytes());
             byteBuffer.flip();
             socketChannel.write(byteBuffer);
             byteBuffer.clear();
             System.out.println("send message:" + message);
             key.interestOps(SelectionKey.OP_READ);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     private void receive(SelectionKey key) {
         try {
             byteBuffer.clear();
             socketChannel.read(byteBuffer);
             byteBuffer.flip();
             byte[] bytes = new byte[byteBuffer.remaining()];
             byteBuffer.get(bytes);
             String message = new String(bytes).trim();
             System.out.println("receive message: " + message);
             byteBuffer.clear();
             key.interestOps(SelectionKey.OP_WRITE);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

真是粗心大意了。。。特发此博文给我自己涨涨记性