Java nio 学习笔记（五）

Java nio SocketChannel ServerSocketChannel 以及Selector实现的echo服务器和客户端（暂时有问题）

服务器端代码：

[java]  view plain copy

1. import java.io.IOException;  
2. import java.net.InetSocketAddress;  
3. import java.nio.ByteBuffer;  
4. import java.nio.channels.SelectionKey;  
5. import java.nio.channels.Selector;  
6. import java.nio.channels.ServerSocketChannel;  
7. import java.nio.channels.SocketChannel;  
8. import java.util.Calendar;  
9. import java.util.Iterator;  
10.   
11.   
12. public class TestServer {  
13.     public static void main(String[] args) {  
14.         new Thread(new EchoServer(1982)).start();  
15.     }  
16. }  
17.   
18. class EchoServer implements Runnable {  
19.     //要监听的端口号  
20.     private int port;  
21.     //生成一个信号监视器  
22.     private Selector s;  
23.     //读缓冲区  
24.     private ByteBuffer r_bBuf = ByteBuffer.allocate(1024);  
25.       
26.     public EchoServer(int port) {  
27.         this.port = port;  
28.         try {  
29.             s = Selector.open();  
30.         } catch (IOException e) {  
31.             e.printStackTrace();  
32.         }  
33.     }  
34.   
35.     @Override  
36.     public void run() {  
37.         try {  
38.             //生成一个ServerScoket通道的实例对象，用于侦听可能发生的IO事件  
39.             ServerSocketChannel ssc = ServerSocketChannel.open();  
40.             //将该通道设置为异步方式  
41.             ssc.configureBlocking(false);  
42.             //绑定到一个指定的端口  
43.             ssc.socket().bind(new InetSocketAddress(port));  
44.             //注册特定类型的事件到信号监视器上  
45.             ssc.register(s, SelectionKey.OP_ACCEPT);  
46.             System.out.println("The server has been launched...");  
47.             while(true) {  
48.                 //将会阻塞执行，直到有事件发生  
49.                 System.out.println("监听新事件...");  
50.                 s.select();  
51.                 Iterator<SelectionKey> it = s.selectedKeys().iterator();  
52.                 while(it.hasNext()) {  
53.                     SelectionKey key = it.next();  
54.                     //key定义了四种不同形式的操作  
55.                     switch(key.readyOps()) {  
56.                     case SelectionKey.OP_ACCEPT :  
57.                         dealwithAccept(key);  
58.                         break;  
59.                     case SelectionKey.OP_CONNECT :  
60.                         break;  
61.                     case SelectionKey.OP_READ :  
62.                         dealwithRead(key);  
63.                         break;  
64.                     case SelectionKey.OP_WRITE :  
65.                         break;  
66.                     }  
67.                     //处理结束后移除当前事件，以免重复处理  
68.                     it.remove();  
69.                 }  
70.             }  
71.         } catch (IOException e) {  
72.             e.printStackTrace();  
73.         }  
74.     }  
75.     //处理接收连接的事件  
76.     private void dealwithAccept(SelectionKey key) {  
77.         try {  
78.             System.out.println("deal with new accept...");  
79.             ServerSocketChannel server = (ServerSocketChannel)key.channel();  
80.             SocketChannel sc = server.accept();  
81.             sc.configureBlocking(false);  
82.             //注册读事件  
83.             sc.register(s, SelectionKey.OP_WRITE);  
84.             System.out.println("deal with new accept2...");  
85.         } catch (IOException e) {  
86.             e.printStackTrace();  
87.         }  
88.     }  
89.     //处理客户端发来的消息，处理读事件  
90.     private void dealwithRead(SelectionKey key) {  
91.         try {  
92.             SocketChannel sc = (SocketChannel)key.channel();  
93.             System.out.println("读入数据");  
94.             r_bBuf.clear();  
95.             sc.write(r_bBuf);  
96.             r_bBuf.flip();  
97.             System.out.println(r_bBuf.asCharBuffer().toString());  
98.             r_bBuf.clear();  
99.             System.out.println("处理完毕...");  
100.             try {  
101.                 Thread.currentThread().sleep(1000);  
102.             } catch (InterruptedException e) {  
103.                 e.printStackTrace();  
104.             }  
105.         } catch (IOException e) {  
106.             e.printStackTrace();  
107.         }  
108.     }  
109.       
110.     private String getCurrentTime() {  
111.         return Calendar.getInstance().toString();  
112.     }  
113. }  

 

client 端代码：

[java]  view plain copy

1. import java.io.BufferedReader;  
2. import java.io.IOException;  
3. import java.io.InputStreamReader;  
4. import java.net.InetSocketAddress;  
5. import java.nio.ByteBuffer;  
6. import java.nio.channels.SocketChannel;  
7.   
8.   
9. public class TestClient {  
10.     public static void main(String[] args) {  
11.         new MiniClient("localhost", 1982);  
12.     }  
13. }  
14. class MiniClient {  
15.     private SocketChannel sc;  
16.     private ByteBuffer w_bBuf;  
17.     public MiniClient(String host, int port) {  
18.         try {  
19.             InetSocketAddress remote = new InetSocketAddress(host, port);  
20.             sc = SocketChannel.open();  
21.             sc.connect(remote);  
22.             if(sc.finishConnect()) {  
23.                 System.out.println("已经与服务器成功建立连接...");  
24.             }  
25.             while(true) {  
26.                 if(!sc.isConnected()) {  
27.                     System.out.println("已经与服务器失去了连接...");  
28.                 }  
29.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
30.                 String str = br.readLine();  
31.                 System.out.println("读入一行数据，开始发送...");  
32.                 w_bBuf = ByteBuffer.wrap(str.getBytes());  
33.                 w_bBuf.flip();  
34.                 //向缓冲区中写入数据  
35.                 sc.write(w_bBuf);  
36.                 System.out.println("数据发送成功...");  
37.                 w_bBuf.clear();  
38.                 try {  
39.                     Thread.currentThread().sleep(1000);  
40.                 } catch (InterruptedException e) {  
41.                     e.printStackTrace();  
42.                 }  
43.             }  
44.         } catch (IOException e) {  
45.             // TODO Auto-generated catch block  
46.             e.printStackTrace();  
47.         }  
48.     }  
49. }  

Thinking in java中的一个图片，刚找到的，比较清楚关系图。