java Socket实现简单在线聊天（二）

接《Java Socket实现简单在线聊天（一）》，在单客户端连接的基础上，这里第二步需要实现多客户端的连接，也就需要使用到线程。每当有一个新的客户端连接上来，服务端便需要新启动一个线程进行处理，从而解决之前的循环读取中造成阻塞的问题。

写线程通常有两种方法，集成Thread或者实现runnable接口，原则上是能实现runnable的情况下就不继承，因为实现接口的方式更加灵活。

客户端代码相较之前没有变化，变得是服务端，因此这里便只贴出服务端代码：

[java] view plain copy

1. package chat.chat;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.EOFException;  
5. import java.io.IOException;  
6. import java.net.BindException;  
7. import java.net.ServerSocket;  
8. import java.net.Socket;  
9. import java.net.SocketException;  
10.   
11. /** 
12.  * java使用socket和awt组件以及多线程简单实现在线聊天功能服务端 ： 实现多个客户端连接后不断向服务端发送消息， 
13.  * 相对于第一个版本，重点在于使用了多线程。服务端还未实现转发功能，客户端图形窗口中只能看到自己输入的信息， 不能看到其他客户端发送的消息 
14.  *  
15.  * @author tuzongxun123 
16.  * 
17.  */  
18. public class ChatServer {  
19.   
20.     public static void main(String[] args) {  
21.         new ChatServer().start();  
22.     }  
23.   
24.     // 是否成功启动服务端  
25.     private boolean isStart = false;  
26.     // 服务端socket  
27.     private ServerSocket ss = null;  
28.     // 客户端socket  
29.     private Socket socket = null;  
30.   
31.     public void start() {  
32.         try {  
33.             // 启动服务器  
34.             ss = new ServerSocket(8888);  
35.         } catch (BindException e) {  
36.             System.out.println("端口已在使用中");  
37.             // 关闭程序  
38.             System.exit(0);  
39.         } catch (Exception e) {  
40.             e.printStackTrace();  
41.         }  
42.   
43.         try {  
44.             isStart = true;  
45.             while (isStart) {  
46.                 // 启动监听  
47.                 socket = ss.accept();  
48.                 System.out.println("one client connect");  
49.                 // 启动客户端线程  
50.                 Client client = new Client(socket);  
51.                 new Thread(client).start();  
52.             }  
53.         } catch (Exception e) {  
54.             e.printStackTrace();  
55.         } finally {  
56.             // 关闭服务  
57.             try {  
58.                 ss.close();  
59.             } catch (IOException e) {  
60.                 e.printStackTrace();  
61.             }  
62.         }  
63.   
64.     }  
65.   
66.     /** 
67.      * 客户端线程 
68.      *  
69.      * @author tuzongxun123 
70.      * 
71.      */  
72.     class Client implements Runnable {  
73.         // 客户端socket  
74.         private Socket socket = null;  
75.         // 客户端输入流  
76.         private DataInputStream dataInputStream = null;  
77.         private boolean isConnect = false;  
78.   
79.         public Client(Socket socket) {  
80.             this.socket = socket;  
81.             try {  
82.                 isConnect = true;  
83.                 // 获取客户端输入流  
84.                 dataInputStream = new DataInputStream(socket.getInputStream());  
85.             } catch (IOException e) {  
86.                 e.printStackTrace();  
87.             }  
88.         }  
89.   
90.         @Override  
91.         public void run() {  
92.             isConnect = true;  
93.             try {  
94.                 while (isConnect) {  
95.                     // 读取客户端传递的数据  
96.                     String message = dataInputStream.readUTF();  
97.                     System.out.println("客户端说：" + message);  
98.                 }  
99.             } catch (EOFException e) {  
100.                 System.out.println("client closed!");  
101.             } catch (SocketException e) {  
102.                 System.out.println("Client is Closed!!!!");  
103.             } catch (Exception e) {  
104.                 e.printStackTrace();  
105.             } finally {  
106.                 // 关闭相关资源  
107.                 try {  
108.                     dataInputStream.close();  
109.                     socket.close();  
110.                 } catch (IOException e) {  
111.                     e.printStackTrace();  
112.                 }  
113.             }  
114.         }  
115.   
116.     }  
117.   
118. }