NIO学习

Posted 2021-02-16 beheaven

1. NIO客户端与服务端网络编程关键：

 理解各个监听事件的驱动事件，总结以下几点：
（1）ServerSocketChannel注册了OP_ACCEPT事件，需要客户端发起连接请求，服务端selector才能监听到（阻塞在selector.select()才能继续执行）
（2）服务端获取客户端SocketChannel，注册读事件后，只有客户端写事件，服务端selector才能监听到（阻塞在selector.select()才能继续执行，读事件是被动的，需要写事件驱动）
（3）不管服务端还是客户端，本端注册的管道写事件，selector马上能监听到（总结：写事件是主动的，只要注册，就能监听到）
（4）SelectionKey.OP_CONNECT(主动事件，客户端注册完之后，本端selector马上能监听到)-->isConnectable()为true
         SelectionKey.OP_ACCEPT（被动事件，需服务端注册accepte事件，还需要客户端发连接请求触发）-->isAcceptable()为true
         SelectionKey.OP_WRITE(主动事件，客户端注册完之后，本端selector马上能监听到)-->isWritable()为true
         SelectionKey.OP_READ（被动事件，需本端注册读事件，并且对端有写事件才触发）-->isReadable()为true

 

2. 服务端代码：

  1 package com.hw.nio;
  2 
  3 import java.io.IOException;  
  4 import java.net.InetSocketAddress;  
  5 import java.net.ServerSocket;  
  6 import java.nio.ByteBuffer;  
  7 import java.nio.channels.SelectionKey;  
  8 import java.nio.channels.Selector;  
  9 import java.nio.channels.ServerSocketChannel;  
 10 import java.nio.channels.SocketChannel;  
 11 import java.util.Iterator;  
 12 import java.util.Set;  
 13 /**
 14  * NIO客户端与服务端网络编程关键：
 15  *  理解各个监听事件的驱动事件，例如：
 16  * （1）ServerSocketChannel注册了OP_ACCEPT事件，需要客户端发起连接请求，服务端selector才能监听到（阻塞在selector.select()才能继续执行）
 17  * （2）服务端获取客户端SocketChannel，注册读事件后，只有客户端写事件，服务端selector才能监听到（阻塞在selector.select()才能继续执行）（总结：读事件是被动的，需要写事件驱动）
 18  * （3）不管服务端还是客户端，本端注册的管道写事件，selector马上能监听到（总结：写事件是主动的，只要注册，就能监听到）
 19  * （4）SelectionKey.OP_CONNECT(主动事件，客户端注册完之后，本端selector马上能监听到)-->isConnectable()为true
 20  *     SelectionKey.OP_ACCEPT（被动事件，需服务端注册accepte事件，还需要客户端发连接请求触发）-->isAcceptable()为true
 21  *     SelectionKey.OP_WRITE(主动事件，客户端注册完之后，本端selector马上能监听到)-->isWritable()为true
 22  *     SelectionKey.OP_READ（被动事件，需本端注册读事件，并且对端有写事件才触发）-->isReadable()为true
 23  * @author thinkpad
 24  *
 25  */
 26 public class Nioserver {  
 27       
 28     /*标识数字*/ 
 29     private  int flag = 0;  
 30     /*缓冲区大小*/ 
 31     private  int BLOCK = 4096;  
 32     /*接受数据缓冲区*/ 
 33     private  ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);  
 34     /*发送数据缓冲区*/ 
 35     private  ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);  
 36     private  Selector selector;  
 37  
 38     public NIOServer(int port) throws IOException {  
 39         // 打开服务端套接字通道  
 40         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();  
 41         // 服务器配置为非阻塞  
 42         serverSocketChannel.configureBlocking(false);  
 43         // 检索与此通道关联的服务器套接字  
 44         ServerSocket serverSocket = serverSocketChannel.socket();  
 45         // 进行服务的绑定  
 46         serverSocket.bind(new InetSocketAddress(port));  
 47         // 通过open()方法找到Selector  
 48         selector = Selector.open();  
 49         // 注册通道到selector，等待连接
 50         // self:1.如果不注册OP_ACCEPT,即使客户端发连接请求，selector也无法监听到连接事件，导致selector.select()一直阻塞等待
 51         // 2.即使注册了OP_ACCEPTE,客户端如果不发送连接请求，服务端也会一直阻塞在selector.select();
 52         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); 
 53         System.out.println("Server Start----8888:");  
 54     }  
 55  
 56  
 57     // 监听  
 58     private void listen() throws IOException {  
 59         while (true) {  
 60             // 选择一组键，并且相应的通道已经打开(服务端如果注册了OP_ACCEPTE，第一次等待客户端连接，若客户端无连接请求，阻塞在此处)
 61             selector.select();  
 62             // 返回此选择器的已选择键集。  
 63             Set<SelectionKey> selectionKeys = selector.selectedKeys();  
 64             Iterator<SelectionKey> iterator = selectionKeys.iterator();  
 65             while (iterator.hasNext()) {          
 66                 SelectionKey selectionKey = iterator.next();  
 67                 iterator.remove();  
 68                 handleKey(selectionKey);  
 69             }  
 70         }  
 71     }  
 72  
 73     // 处理请求  
 74     private void handleKey(SelectionKey selectionKey) throws IOException {  
 75         // 接受请求  
 76         ServerSocketChannel server = null;  
 77         SocketChannel client = null;  
 78         String receiveText;  
 79         String sendText;  
 80         int count=0;  
 81         // 测试此键的通道是否已准备好接受新的套接字连接。  
 82         if (selectionKey.isAcceptable()) {  
 83             // 返回为之创建此键的通道。  
 84             server = (ServerSocketChannel) selectionKey.channel();  
 85             // 接受到此通道套接字的连接。  
 86             // 此方法返回的套接字通道（如果有）将处于阻塞模式。  
 87             client = server.accept();  
 88             // 配置为非阻塞  
 89             client.configureBlocking(false);  
 90             // 注册到selector，等待连接  
 91             client.register(selector, SelectionKey.OP_READ);  
 92         } else if (selectionKey.isReadable()) {  // 仅仅注册了读事件还不行，还需要客户端写才能触发
 93             // 返回为之创建此键的通道。  
 94             client = (SocketChannel) selectionKey.channel();  
 95             //将缓冲区清空以备下次读取  
 96             receivebuffer.clear();  
 97             //读取服务器发送来的数据到缓冲区中  
 98             count = client.read(receivebuffer);   
 99             if (count > 0) {  
100                 receiveText = new String( receivebuffer.array(),0,count);  
101                 System.out.println("服务器端接受客户端数据--:"+receiveText);  
102                 client.register(selector, SelectionKey.OP_WRITE);  
103             }  
104         } else if (selectionKey.isWritable()) {  
105             //将缓冲区清空以备下次写入  
106             sendbuffer.clear();  
107             // 返回为之创建此键的通道。  
108             client = (SocketChannel) selectionKey.channel();  
109             sendText="message from server--" + flag++;  
110             //向缓冲区中输入数据  
111             sendbuffer.put(sendText.getBytes());  
112              //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
113             sendbuffer.flip();  
114             //输出到通道  
115             client.write(sendbuffer);  
116             System.out.println("服务器端向客户端发送数据--："+sendText);  
117             client.register(selector, SelectionKey.OP_READ);  
118         }  
119     }  
120  
121     /**  
122      * @param args  
123      * @throws IOException  
124      */ 
125     public static void main(String[] args) throws IOException {  
126         int port = 8888;  
127         NIOServer server = new NIOServer(port);  
128         server.listen();  
129     }  
130 } 

3. 客户端代码：

  1 package com.hw.nio;
  2 
  3 import java.io.IOException;  
  4 import java.net.InetSocketAddress;  
  5 import java.nio.ByteBuffer;  
  6 import java.nio.channels.SelectionKey;  
  7 import java.nio.channels.Selector;  
  8 import java.nio.channels.SocketChannel;  
  9 import java.util.Iterator;  
 10 import java.util.Set;  
 11  
 12 public class NIOClient {  
 13  
 14     /*标识数字*/ 
 15     private static int flag = 0;  
 16     /*缓冲区大小*/ 
 17     private static int BLOCK = 4096;  
 18     /*接受数据缓冲区*/ 
 19     private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);  
 20     /*发送数据缓冲区*/ 
 21     private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);  
 22     /*服务器端地址*/ 
 23     private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress(  
 24             "localhost", 8888);  
 25  
 26     public static void main(String[] args) throws IOException {  
 27         // TODO Auto-generated method stub  
 28         // 打开socket通道  
 29         SocketChannel socketChannel = SocketChannel.open();  
 30         // 设置为非阻塞方式  
 31         socketChannel.configureBlocking(false);  
 32         // 打开选择器  
 33         Selector selector = Selector.open();  
 34         // 注册连接服务端socket动作(self:只有将管道注册到selector上，selector.select()才会执行，否则阻塞，selector只会监听本端的
 35         // channel)
 36         socketChannel.register(selector, SelectionKey.OP_CONNECT);  
 37         // 连接  
 38         socketChannel.connect(SERVER_ADDRESS);  
 39         // 分配缓冲区大小内存  
 40           
 41         Set<SelectionKey> selectionKeys;  
 42         Iterator<SelectionKey> iterator;  
 43         SelectionKey selectionKey;  
 44         SocketChannel client;  
 45         String receiveText;  
 46         String sendText;  
 47         int count=0;  
 48  
 49         while (true) {  
 50             //选择一组键，其相应的通道已为 I/O 操作准备就绪。  
 51             //此方法执行处于阻塞模式的选择操作。  
 52             selector.select();  
 53             //返回此选择器的已选择键集。  
 54             selectionKeys = selector.selectedKeys();  
 55             //System.out.println(selectionKeys.size());  
 56             iterator = selectionKeys.iterator();  
 57             while (iterator.hasNext()) {  
 58                 selectionKey = iterator.next();  
 59                 if (selectionKey.isConnectable()) {  
 60                     System.out.println("client connect");  
 61                     client = (SocketChannel) selectionKey.channel();  
 62                     // 判断此通道上是否正在进行连接操作。  
 63                     // 完成套接字通道的连接过程。  
 64                     if (client.isConnectionPending()) {  
 65                         client.finishConnect();  
 66                         System.out.println("完成连接!");  
 67                         sendbuffer.clear();  
 68                         sendbuffer.put("Hello,Server".getBytes());  
 69                         sendbuffer.flip();  
 70                         // sendbuffer = null;如果写个空，服务端也不理
 71                         client.write(sendbuffer);  
 72                     }  
 73                     // self:向服务器端写完数据，用于客户端Socket管道注册读事件，如果本端（客户端）selector监听到服务端向客户端写数据，阻塞在selector.select()处的代码继续执行，则可以读取数据
 74                     // 本端注册读事件，是为了响应对端的写事件
 75                     client.register(selector, SelectionKey.OP_READ);  
 76                 } else if (selectionKey.isReadable()) {  
 77                     client = (SocketChannel) selectionKey.channel();  
 78                     //将缓冲区清空以备下次读取  
 79                     receivebuffer.clear();  
 80                     //读取服务器发送来的数据到缓冲区中  
 81                     count=client.read(receivebuffer);  
 82                     if(count>0){  
 83                         receiveText = new String( receivebuffer.array(),0,count);  
 84                         System.out.println("客户端接受服务器端数据--:"+receiveText);
 85                         // self:写事件注册完之后，selector马上能监听到，本端的写事件是主动的发起，读事件需要对端的写事件驱动
 86                         client.register(selector, SelectionKey.OP_WRITE);  
 87                     }  
 88  
 89                 } else if (selectionKey.isWritable()) {  
 90                     sendbuffer.clear();  
 91                     client = (SocketChannel) selectionKey.channel();  
 92                     sendText = "message from client--" + (flag++);  
 93                     sendbuffer.put(sendText.getBytes());  
 94                      //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
 95                     sendbuffer.flip();  
 96                     client.write(sendbuffer);  
 97                     System.out.println("客户端向服务器端发送数据--："+sendText);  
 98                     client.register(selector, SelectionKey.OP_READ);  
 99                 }  
100             }  
101             selectionKeys.clear();  
102         }  
103     }  
104 } 

4. 测试代码：

 1 package com.hw.nio;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.net.InetSocketAddress;
 6 import java.net.ServerSocket;
 7 import java.net.Socket;
 8 import java.net.SocketAddress;
 9 import java.nio.ByteBuffer;
10 import java.nio.channels.SocketChannel;
11 import java.util.concurrent.TimeUnit;
12 
13 public class NIOTest {
14 
15     public static void client() {
16         ByteBuffer buffer = ByteBuffer.allocate(1024);
17         SocketChannel socketChannel = null;
18         try {
19             socketChannel = SocketChannel.open();
20             socketChannel.configureBlocking(false);
21             socketChannel.connect(new InetSocketAddress("localhost", 8080));
22 
23             if (socketChannel.finishConnect()) {
24                 int i = 0;
25                 while (true) {
26                     TimeUnit.SECONDS.sleep(1);
27                     String info = "I‘m " + i++ + "-th information from client";
28                     buffer.clear();
29                     buffer.put(info.getBytes());
30                     buffer.flip();
31                     while (buffer.hasRemaining()) {
32                         System.out.println(buffer);
33                         socketChannel.write(buffer);
34                     }
35                 }
36             }
37         } catch (IOException | InterruptedException e) {
38             e.printStackTrace();
39         } finally {
40             try {
41                 if (socketChannel != null) {
42                     socketChannel.close();
43                 }
44             } catch (IOException e) {
45                 e.printStackTrace();
46             }
47         }
48     }
49 
50     public static void server() {
51         ServerSocket serverSocket = null;
52         InputStream in = null;
53         try {
54             serverSocket = new ServerSocket(8080);
55             int recvMsgSize = 0;
56             byte[] recvBuf = new byte[1024];
57             while (true) {
58                 Socket clntSocket = serverSocket.accept();
59                 SocketAddress clientAddress = clntSocket.getRemoteSocketAddress();
60                 System.out.println("Handling client at " + clientAddress);
61                 in = clntSocket.getInputStream();
62                 while ((recvMsgSize = in.read(recvBuf)) != -1) {
63                     byte[] temp = new byte[recvMsgSize];
64                     System.arraycopy(recvBuf, 0, temp, 0, recvMsgSize);
65                     System.out.println(new String(temp));
66                 }
67             }
68         } catch (IOException e) {
69             e.printStackTrace();
70         } finally {
71             try {
72                 if (serverSocket != null) {
73                     serverSocket.close();
74                 }
75                 if (in != null) {
76                     in.close();
77                 }
78             } catch (IOException e) {
79                 e.printStackTrace();
80             }
81         }
82     }
83     public static void main(String[] args) {
84         if("client".equals(args[0])) {
85             client();
86         }
87         server();
88         if("server".equals(args[0])) {
89             server();
90         }
91     }
92 }