利用 Socket 实现服务器客户端聊天

Socket是网络编程中最基本的通信接口，常用的网络辅助类，比如URL等之类，其底层还是基于Socket来实现的。

而Socket，形象来说，就是连接通信的两端，比如这样 S<==>S，中间的通道就是网络了，而简单地利用Socket，我们就可以来实现一个简单的聊天功能

具体效果看下图：

这只是在本地中试用的效果，如果加上UI界面，其实就可以做成一个聊天的小应用了。

1. Server 端主要是利用ServerSocket的accept方法来等待客户端的连接，如果客户一直没有连接，则会在这里等待，直到客户端请求到来。

而客户端就是一个Socket，当客户端请求到来的时候，accept会返回一个Socket对象， 这就是S<==>S中的左边那个S了，可以利用其InputStream和OutputStream来进行读写了，读就是接收信息，而写就是回复信息。

[java] view plain copy

1. public class Server {  
2.   
3.     public static void main(String[] args) {  
4.         try {  
5.             ServerSocket server = new ServerSocket(9999);  
6.             Helper.println("Server started, waiting for message.");  
7.             Socket client = server.accept();  
8.             PrintWriter pw = null;  
9.             while (true) {  
10.                 BufferedReader br = new BufferedReader(new InputStreamReader(  
11.                         client.getInputStream()));  
12.                 String content = br.readLine();  
13.                 if (content.equals("end")) {  
14.                     server.close();  
15.                     br.close();  
16.                     if (pw != null) {  
17.                         pw.close();  
18.                     }  
19.                     break;  
20.                 }  
21.                 Helper.println(content);  
22.                 Helper.print("Server:");  
23.                 pw = new PrintWriter(client.getOutputStream(), true);  
24.                 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));  
25.                 String output = "Server : " + in.readLine();  
26.                 pw.println(output);  
27.                 pw.flush();  
28.             }  
29.             Helper.println("Client left! Server Closed.");  
30.         } catch (IOException e) {  
31.             // TODO Auto-generated catch block  
32.             e.printStackTrace();  
33.         }  
34.     }  
35. }  

2. Client端就是一个Socket，并定义一个连接的地址和端口，地址表明是网络中哪一台主机，而端口则表明了是主机中的那个应用程序，很显然就是上面Server这个应用，因为其定义了其等待监听的端口就是9999。当创建了一个Socket对象，并指定了地址和端口的时候，其实就已经发送了一个请求去对应的Server，请求连接，而如果连接成功，就可以继续下去，不然直接抛出异常。当然，这里连接成功，必须是Server先在监听了。

[java] view plain copy

1. public class Client {  
2.   
3.     public static void main(String[] args) {  
4.         try {  
5.             Socket client = new Socket("127.0.0.1", 9999);  
6.             PrintWriter pw = null;  
7.             InputStreamReader isr = null;  
8.             Helper.println("Client started, ready to write content.");  
9.             String input = "";  
10.             while (true) {  
11.                 Helper.print("Client : ");  
12.                 InputStream is = System.in;  
13.                 input = new BufferedReader(new InputStreamReader(is))  
14.                         .readLine();  
15.                 pw = new PrintWriter(client.getOutputStream(), true);  
16.                 pw.println("Client:" + input);  
17.                 if (input.equals("end")) {  
18.                     client.close();  
19.                     is.close();  
20.                     pw.close();  
21.                     if (isr != null) {  
22.                         isr.close();  
23.                     }  
24.                     break;  
25.                 }  
26.                 isr = new InputStreamReader(client.getInputStream());  
27.                 Helper.println(new BufferedReader(isr).readLine());  
28.             }  
29.             Helper.println("Client stopped!");  
30.         } catch (IOException e) {  
31.             // TODO Auto-generated catch block  
32.             e.printStackTrace();  
33.         }  
34.     }  
35.   
36. }  

嗯，结束。