在做关于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. 关闭通道(可选)

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

服务端代码：

 

  1 import java.io.ioexception;
  2 import java.net.inetsocketaddress;
  3 import java.nio.bytebuffer;
  4 import java.nio.channels.closedchannelexception;
  5 import java.nio.channels.selectionkey;
  6 import java.nio.channels.selector;
  7 import java.nio.channels.serversocketchannel;
  8 import java.nio.channels.socketchannel;
  9 import java.util.iterator;
 10 import java.util.set;
 11 
 12 public class server {
 13     private selector selector;
 14     private serversocketchannel serversocketchannel;
 15     private bytebuffer bytebuffer = bytebuffer.allocate(8192);
 16 
 17     /**
 18      * 构造方法 启动服务器
 19      * 
 20      * @param port
 21      * @throws ioexception
 22      */
 23     public server() {
 24         try {
 25             selector = selector.open();
 26             serversocketchannel = serversocketchannel.open();
 27             serversocketchannel.configureblocking(false);
 28             serversocketchannel.bind(new inetsocketaddress(10086));
 29             serversocketchannel.register(selector, selectionkey.op_accept);
 30             system.out.println("server start successful with port: 10086");
 31         } catch (closedchannelexception e) {
 32             e.printstacktrace();
 33         } catch (ioexception e) {
 34             e.printstacktrace();
 35         }
 36     }
 37 
 38     public static void main(string[] args) throws exception {
 39         new server().start();
 40     }
 41 
 42     private void start() {
 43         while (true) {
 44             try {
 45                 selector.select();
 46                 set<selectionkey> keys = selector.selectedkeys();
 47                 iterator<selectionkey> keyiterator = keys.iterator();
 48                 while (keyiterator.hasnext()) {
 49                     selectionkey key = keyiterator.next();
 50                     keyiterator.remove();
 51                     if (!key.isvalid()) {
 52                         continue;
 53                     }
 54                     if (key.isacceptable()) {
 55                         accept(key);
 56                     }
 57                     if (key.isreadable()) {
 58                         receive(key);
 59                     }
 60                     if (key.iswritable()) {
 61                         reply(key);
 62                     }
 63                 }
 64             } catch (ioexception e) {
 65                 e.printstacktrace();
 66             } catch (exception e) {
 67                 e.printstacktrace();
 68             }
 69         }
 70     }
 71 
 72     private void reply(selectionkey key) {
 73         try {
 74             socketchannel socketchannel = (socketchannel) key.channel();
 75             bytebuffer.clear();
 76             string message = "receive success";
 77             bytebuffer.put(message.getbytes());
 78             bytebuffer.flip();
 79             socketchannel.write(bytebuffer);
 80             system.out.println("reply:" + message);
 81             bytebuffer.clear();
 82             key.interestops(selectionkey.op_read);
 83         } catch (ioexception e) {
 84             e.printstacktrace();
 85         }
 86     }
 87 
 88     private void receive(selectionkey key) {
 89         try {
 90             socketchannel socketchannel = (socketchannel) key.channel();
 91             bytebuffer.clear();
 92             int flag = socketchannel.read(bytebuffer);
 93             if (flag == -1) {
 94                 key.channel().close();
 95                 key.cancel();
 96                 return;
 97             }
 98             bytebuffer.flip();
 99             byte[] buf = new byte[bytebuffer.remaining()];
100             bytebuffer.get(buf);
101             string message = new string(buf);
102             system.out.println("receive message:" + message);
103             bytebuffer.clear();
104             key.interestops(selectionkey.op_write);
105         } catch (ioexception e) {
106             e.printstacktrace();
107         }
108     }
109 
110     private void accept(selectionkey key) {
111         try {
112             socketchannel socketchannel = serversocketchannel.accept();
113             socketchannel.configureblocking(false);
114             socketchannel.register(selector, selectionkey.op_read | selectionkey.op_write);
115             system.out.println(thread.currentthread().getname() + ": create client channel.");
116         } catch (closedchannelexception e) {
117             e.printstacktrace();
118         } catch (ioexception e) {
119             e.printstacktrace();
120         }
121     }
122 }

 

客户端代码：

 1 import java.io.ioexception;
 2 import java.net.inetsocketaddress;
 3 import java.nio.bytebuffer;
 4 import java.nio.channels.closedchannelexception;
 5 import java.nio.channels.selectionkey;
 6 import java.nio.channels.selector;
 7 import java.nio.channels.socketchannel;
 8 import java.util.iterator;
 9 import java.util.scanner;
10 
11 public class client {
12     private selector selector;
13     private bytebuffer bytebuffer = bytebuffer.allocate(1024);
14     private socketchannel socketchannel;
15 
16     public client() {
17         try {
18             selector = selector.open();
19             socketchannel = socketchannel.open();
20             socketchannel.configureblocking(false);
21             socketchannel.register(selector, selectionkey.op_connect | selectionkey.op_read | selectionkey.op_write);
22             socketchannel.connect(new inetsocketaddress("127.0.0.1", 10086));
23             system.out.println("client start successful");
24         } catch (closedchannelexception e) {
25             e.printstacktrace();
26         } catch (ioexception e) {
27             e.printstacktrace();
28         }
29     }
30 
31     public static void main(string[] args) {
32         new client().start();    
33     }
34 
35     private void start() {
36         while (true) {
37             try {
38                 selector.select();
39                 iterator<selectionkey> keys = selector.selectedkeys().iterator();
40                 while (keys.hasnext()) {
41                     selectionkey key = keys.next();
42                     keys.remove();
43                     if (!key.isvalid()) {
44                         continue;
45                     }
46                     if (key.isconnectable()) {
47                         if (socketchannel.finishconnect()) {
48                             key.interestops(key.interestops() & ~selectionkey.op_connect);
49                             system.out.println("client connect server success");
50                         }
51                     }
52                     if (key.isreadable()) {
53                         receive(key);
54                     }
55                     if (key.iswritable()) {
56                         reply(key);
57                     }
58                 }
59             } catch (exception e) {
60                 e.printstacktrace();
61             }
62         }
63     }
64 
65     private void reply(selectionkey key) {
66         try {
67             @suppresswarnings("resource")
68             scanner scanner = new scanner(system.in);
69             bytebuffer.clear();
70             system.out.println("please input message:");
71             string message = scanner.next();
72             bytebuffer.put(message.getbytes());
73             bytebuffer.flip();
74             socketchannel.write(bytebuffer);
75             bytebuffer.clear();
76             system.out.println("send message:" + message);
77             key.interestops(selectionkey.op_read);
78         } catch (ioexception e) {
79             e.printstacktrace();
80         }
81     }
82 
83     private void receive(selectionkey key) {
84         try {
85             bytebuffer.clear();
86             socketchannel.read(bytebuffer);
87             bytebuffer.flip();
88             byte[] bytes = new byte[bytebuffer.remaining()];
89             bytebuffer.get(bytes);
90             string message = new string(bytes).trim();
91             system.out.println("receive message: " + message);
92             bytebuffer.clear();
93             key.interestops(selectionkey.op_write);
94         } catch (ioexception e) {
95             e.printstacktrace();
96         }
97     }
98 }

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