完成聊天室的私聊功能

1 完成聊天室的私聊功能

完成聊天室私聊功能。私聊功能是指，客户端之间可以实现一对一的聊天。

服务器端程序启动后，将等待客户端连接，界面效果如图－1所示：

图－1

客户端程序运行时，需要用户先输入昵称。用户输入昵称之后，提示用户可以开始聊天。界面效果如图－2所示：

图－2

另一个客户端运行起来后，也需要输入昵称，界面效果如图－3所示：

图－3

此时，其他运行中的客户端会收到昵称为“jerry”的客户端上线的消息。比如，之前运行起来的客户端“mary”的界面效果如图－4所示：

图－4

其他客户端可以通过输入类似“jerry:你好”这样的字样和昵称为“jerry”的客户端私聊。比如，昵称为“mary”的客户端可以输入如图－5所示的信息：

图－5

注意：如果需要进行私聊，必需使用“昵称:信息”的格式发送消息。其中，“昵称:”为固定格式，“昵称”表示要私聊的客户端的昵称；“信息”表示需要发送的消息。例如："jerry:你好"，表示发送消息“你好”给昵称为“jerry”的客户端。

昵称为“jerry”的客户端将接收到客户端“mary”发来的信息，界面效果如图－6所示：

图－6

如果某客户端程序停止运行，其他客户端程序可以接收到消息并显示。例如，昵称为“jerry”的客户端停止运行，昵称为“mary”的客户端的界面效果如图－7所示：

图－7

对于服务器端而言，只要有客户端连接，就会在界面输出提示信息。界面效果如图－8所示：

图－8

参考答案

实现此案例需要按照如下步骤进行。

步骤一：创建客户端类

新建名为com.tarena.homework的包，并在包下新建名为Client的类，用于表示客户端。

在Client 类中声明全局变量 socket 表示一个客户端Socket对象，并在实例化 Client 类时使用构造方法“Socket（String ip,int port）”来创建Socket类的对象。此时，需要进行异常处理。代码如下所示：

 

1. package com.tarena.homework;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.OutputStreamWriter;
9. import java.io.PrintWriter;
10. import java.net.Socket;
11. import java.util.Scanner;
13. /**
14. * 客户端应用程序
15. */
16. public class Client {
17.     //客户端Socket
18.     private Socket socket;
19.     /**
20.      * 构造方法，用于初始化
21.      */
22.     public Client(){
23.         try {
24.             socket = new Socket("localhost",8088);
25.         } catch (Exception e) {
26.             e.printStackTrace();
27.         }
28.     }
29. }

步骤二：定义客户端线程要执行的任务

在Client类中定义成员内部类ServerHander。该内部类需要实现Runnable接口并实现该接口的run() 方法。在该方法中实现线程要执行的任务，在此，线程要执行的任务为循环接收服务端的消息并打印到控制台。代码如下所示：

 

1. public class Client {
2.     //其他代码，略
3.     
4.     /**
5.      * 该线程用于接收服务端发送过来的信息
6.      */
7.     private class ServerHander implements Runnable{
8.         @Override
9.         public void run() {
10.             try {
11.                 InputStream in = socket.getInputStream();
12.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
13.                 BufferedReader br = new BufferedReader(isr);
14.                 while(true){
15.                     System.out.println(br.readLine());
16.                 }
17.             } catch (Exception e) {
18.                 e.printStackTrace();
19.             }
20.         }
21.     }
22. }

步骤三：定义方法inputNickName()，用于输入昵称

为Client类定义方法inputNickName()，用于输入昵称。代码如下所示：

 

1. public class Client {
2.     //其他代码，略
3.     
4.     /**
5.      * 输入昵称
6.      */
7.     private void inputNickName(Scanner scanner)throws Exception{
8.         //定义昵称
9.         String nickName = null;
10.         //创建输出流
11.         PrintWriter pw = new PrintWriter(
12.                             new OutputStreamWriter(
13.                                 socket.getOutputStream(),"UTF-8")
14.                          ,true);
15.         //创建输入流
16.         BufferedReader br = new BufferedReader(
17.                                 new InputStreamReader(
18.                                         socket.getInputStream(),"UTF-8")
19.                          );
20.         /*
21.          * 循环以下操作
22.          * 输入用户名，并上传至服务器，等待服务器回应，若昵称可用就结束循环，否则通知用户后
23.          * 重新输入昵称
24.          */
25.         while(true){
26.             System.out.println("请输入昵称:");
27.             nickName = scanner.nextLine();
28.             if(nickName.trim().equals("")){
29.                 System.out.println("昵称不能为空");
30.             }else{
31.                 pw.println(nickName);
32.                 String pass = br.readLine();
33.                 if(pass!=null&&!pass.equals("OK")){
34.                     System.out.println("昵称已被占用，请更换。");
35.                 }else{
36.                     System.out.println("你好!"+nickName+",开始聊天吧!");
37.                     break;
38.                 }
39.             }
40.         }
41.     }
42. }

步骤四：创建客户端工作方法 start()

为 Client 类创建客户端工作方法 start()。在该方法中，首先调用方法inputNickName()得到用户昵称，然后启动接收服务端信息的线程，接收数据后打印显示。

代码如下所示：

 

1. public class Client {
2.     //其他代码，略
4.     /**
5.      * 客户端工作方法
6.      */
7.     public void start(){
8.         try {
9.             //创建Scanner读取用户输入内容
10.             Scanner scanner = new Scanner(System.in);
11.             //首先输入昵称
12.             inputNickName(scanner);
13.             
14.             //将接收服务端信息的线程启动
15.             ServerHander handler = new ServerHander();
16.             Thread t = new Thread(handler);
17.             t.setDaemon(true);
18.             t.start();
19.             
20.             OutputStream out = socket.getOutputStream();            
21.             OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");            
22.             PrintWriter pw = new PrintWriter(osw,true);
23.             while(true){
24.                 pw.println(scanner.nextLine());
25.             }
26.         } catch (Exception e) {
27.             e.printStackTrace();
28.         } finally{
29.             if(socket != null){
30.                 try {
31.                     socket.close();
32.                 } catch (IOException e) {
33.                     e.printStackTrace();
34.                 }
35.             }
36.         }
37.     }
38. }

步骤五：为客户端类定义 main() 方法

为类 Client 定义 main() 方法，并在该方法中，创建 Client 对象，调用上一步中所创建的 start() 方法。代码如下所示：

 

1. /**
2. * 客户端应用程序
3. */
4. public class Client {
5.     //其他代码，略
6.     
7.     public static void main(String[] args) {
8.         Client client = new Client();
9.         client.start();
10.     }
11. }

步骤六：定义 Server类

定义Server类，并在Server类中添加ExecutorService类型的属性threadPool,并在构造方法中将其初始化。初始化时，使用固定大小的线程池，线程数量为40。这里使用Executors类的newFixedThreadPool(int threads)方法来创建固定大小的线程池。定义属性serverSocket，其类型为ServerSocket，并在构造方法中将其初始化，申请的服务端口为8088。再定义属性allOut,其类型为HashMap,其中key用于保存用户昵称，value用于保存该客户端的输出流，并在构造方法中初始化以便服务端可以转发信息。

代码如下所示：

 

1. package com.tarena.homework;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.OutputStreamWriter;
9. import java.io.PrintWriter;
10. import java.net.ServerSocket;
11. import java.net.Socket;
12. import java.util.HashMap;
13. import java.util.Map;
14. import java.util.concurrent.ExecutorService;
15. import java.util.concurrent.Executors;
17. /**
18. * 服务端应用程序
19. */
20. public class Server {
21.     // 服务端Socket
22.     private ServerSocket serverSocket;
23.     // 所有客户端输出流,key为用户的昵称，value为该用户的输出流
24.     private Map<String,PrintWriter> allOut;
25.     // 线程池
26.     private ExecutorService threadPool;
27.     /**
28.      * 构造方法，用于初始化
29.      */
30.     public Server() {
31.         try {
32.             serverSocket = new ServerSocket(8088);            
33.             allOut = new HashMap<String,PrintWriter>();            
34.             threadPool = Executors.newFixedThreadPool(40);
35.         } catch (Exception e) {
36.             e.printStackTrace();
37.         }
38.     }
39. }

步骤七：为 Server 类定义 addOut()和removeOut()方法

定义 addOut()方法，该方法向Server的属性allOut集合中添加输出流，并使用synchronized关键字修饰，使该方法变为同步方法。

再定义removeOut()方法，该方法从Server的属性allOut集合中删除输出流，并使用synchronized关键字修饰，使该方法变为同步方法。

代码如下所示：

1. public class Server {
2.     //其他代码，略
4.     /**
5.      * 将输出流存入共享集合，与下面两个方法互斥，保证同步安全
6.      * @param out
7.      */
8.     private synchronized void addOut(String nickName,PrintWriter out){
9.         allOut.put(nickName,out);
10.     }
11.     /**
12.      * 将给定输出流从共享集合删除
13.      * @param out
14.      */
15.     private synchronized void removeOut(String nickName){
16.         allOut.remove(nickName);
17.     }
18. }

步骤八：为 Server 类定义sendMessage()方法

定义sendMessage()方法，该方法用于遍历Server的属性allOut集合元素，将信息写入每一个输出流来完成广播消息的功能，并使用synchronized关键字修饰，使该方法变为同步方法。代码如下所示：

 

1. public class Server {
2.     //其他代码，略
4.     /**
5.      * 将消息转发给所有客户端
6.      * @param message
7.      */
8.     private synchronized void sendMessage(String message){
9.         for(PrintWriter o : allOut.values()){
10.             o.println(message);
11.         }
12.     }
13. }

步骤九：为 Server 类定义sendMessageToOne() 方法

定义sendMessageToOne()方法，该方法用于将消息发送给指定昵称的客户端来实现私聊功能。代码如下所示：

 

1. public class Server {
2.     //其他代码，略
4.     /**
5.      * 将消息发送给指定昵称的客户端
6.      * @param nickName
7.      * @param message
8.      */
9.     private synchronized void sendMessageToOne(String nickName,String message){
10.         PrintWriter out = allOut.get(nickName);
11.         if(out!=null){
12.             out.println(message);
13.         }
14.     }
15. }

步骤十：创建内部类

创建 Server的内部类ClientHandler，在内部类中定义run()方法。在run()方法中，读取用户昵称以发送用户上线信息，并进行消息转发，其中先判断是否为私聊信息，若是则调用发送私聊信息的方法，否则向所有客户端广播消息 。代码如下所示：

 

1.     /**
2.      * 线程体，用于并发处理不同客户端的交互
3.      */
4.     private class ClientHandler implements Runnable {
5.         // 该线程用于处理的客户端
6.         private Socket socket;
7.         // 开客户端的昵称
8.         private String nickName;
10.         public ClientHandler(Socket socket) {
11.             this.socket = socket;
12.         }
14.         @Override
15.         public void run() {
16.             PrintWriter pw = null;
17.             try {
18.                 //将客户端的输出流存入共享集合，以便广播消息
19.                 OutputStream out = socket.getOutputStream();
20.                 OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
21.                 pw = new PrintWriter(osw,true);
22.                 /*
23.                  * 将用户信息存入共享集合
24.                  * 需要同步
25.                  */
26.                 //先获取该用户昵称
27.                 nickName = getNickName();
28.                 addOut(nickName,pw);
29.                 Thread.sleep(100);
30.                 /*
31.                  * 通知所有用户该用户已上线
32.                  */
33.                 sendMessage(nickName+"上线了");
34.                 
35.                 InputStream in = socket.getInputStream();
36.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
37.                 BufferedReader br = new BufferedReader(isr);
38.                 
39.                 String message = null;
40.                 // 循环读取客户端发送的信息
41.                 while ((message = br.readLine())!=null) {
42.                     //首先查看是不是私聊
43.                     if(message.startsWith("\")){
44.                         /*
45.                          * 私聊格式：昵称:内容
46.                          */
47.                         //找到:的位置
48.                         int index = message.indexOf(":");
49.                         if(index>=0){
50.                             //截取昵称
51.                             String name = message.substring(1,index);
52.                             //截取内容
53.                             String info = message.substring(
54.                                                  index+1,message.length()
55.                                                  );
56.                             //拼接内容
57.                             info = nickName+"对你说:"+info;
58.                             //发送私聊信息给指定用户
59.                             sendMessageToOne(name, info);
60.                             //发送完私聊后就不在广播了。
61.                             continue;
62.                         }
63.                     }
64.                     /*
65.                      * 遍历所有输出流，将该客户端发送的信息转发给所有客户端
66.                      * 需要同步
67.                      */
68.                     sendMessage(nickName+"说:"+message);
69.                 }
70.             } catch (Exception e) {
71.                 e.printStackTrace();
72.             } finally {
73.                 /*
74.                  * 当客户端断线，要将输出流从共享集合中删除
75.                  * 需要同步
76.                  */
77.                 removeOut(nickName);
78.                 /*
79.                  * 通知所有用户该用户已下线
80.                  */
81.                 sendMessage(nickName+"下线了");
82.                 System.out.println("当前在线人数:"+allOut.size());
83.                 if (socket != null) {
84.                     try {
85.                         socket.close();
86.                     } catch (IOException e) {
87.                         e.printStackTrace();
88.                     }
89.                 }
90.             }
91.         }
92. }

步骤十一：为内部类定义方法getNickName()

为 Server的内部类ClientHandler定义方法getNickName()，用于获取用户的昵称。代码如下所示：

 

1.     private class ClientHandler implements Runnable {
2.         //其他代码，略
4.         /**
5.          * 获取该用户的昵称
6.          * @return
7.          */
8.         private String getNickName()throws Exception{
9.             try {
10.                 //获取该用户的输出流
11.                 OutputStream out = socket.getOutputStream();
12.                 OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
13.                 PrintWriter pw = new PrintWriter(osw,true);
14.                 //获取该用户的输入流
15.                 InputStream in = socket.getInputStream();
16.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
17.                 BufferedReader br = new BufferedReader(isr);
18.                 //读取客户端发送过来的昵称
19.                 String nickName = br.readLine();
20.                 while(true){
21.                     //若昵称为空发送失败代码
22.                     if(nickName.trim().equals("")){
23.                         pw.println("FAIL");
24.                     }
25.                     //若昵称已经存在发送失败代码
26.                     if(allOut.containsKey(nickName)){
27.                         pw.println("FAIL");
28.                     //若成功，发送成功代码，并返回昵称
29.                     }else{
30.                         pw.println("OK");
31.                         return nickName;
32.                     }
33.                     //若改昵称被占用，等待用户再次输入昵称
34.                     nickName = br.readLine();
35.                 }
36.             } catch (Exception e) {
37.                 throw e;
38.             }            
39.         }
40.     }

步骤十二：为 Server 类创建 start()方法

为 Server 类创建 start()方法。在该方法中，循环监听8088端口，等待客户端的连接，一旦一个客户端连接后，向线程池申请一个线程来完成针对该客户端的交互。代码如下所示：

 

1. public class Server {
2.     //其他代码，略
4.     /**
5.      * 服务端开启方法
6.      */
7.     public void start() {
8.         try {
9.             //循环监听客户端的连接
10.             while(true){
11.                 System.out.println("等待客户端连接...");
12.                 // 监听客户端的连接
13.                 Socket socket = serverSocket.accept();
14.                 System.out.println("客户端已连接!");
15.                 
16.                 //启动一个线程来完成针对该客户端的交互
17.                 ClientHandler handler = new ClientHandler(socket);
18.                 threadPool.execute(handler);
19.             }            
20.         } catch (Exception e) {
21.             e.printStackTrace();
22.         }
23.     }
24. }

步骤十三：为 Server类定义 main() 方法

为 Server 类定义 main() 方法，并在 main() 方法中，创建 Server 对象，调用上一步中所创建的 start() 方法。代码如下所示：

 

1. public class Server {
2.     //其他代码，略
4.     public static void main(String[] args) {
5.         Server server = new Server();
6.         server.start();
7.     }
8. }

本案例中，类Server的完整代码如下所示：

 

1. package com.tarena.homework;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.OutputStreamWriter;
9. import java.io.PrintWriter;
10. import java.net.ServerSocket;
11. import java.net.Socket;
12. import java.util.HashMap;
13. import java.util.Map;
14. import java.util.concurrent.ExecutorService;
15. import java.util.concurrent.Executors;
17. /**
18. * 服务端应用程序
19. */
20. public class Server {
21.     // 服务端Socket
22.     private ServerSocket serverSocket;
23.     // 所有客户端输出流,key为用户的昵称，value为该用户的输出流
24.     private Map<String,PrintWriter> allOut;
25.     // 线程池
26.     private ExecutorService threadPool;
27.     /**
28.      * 构造方法，用于初始化
29.      */
30.     public Server() {
31.         try {
32.             serverSocket = new ServerSocket(8088);            
33.             allOut = new HashMap<String,PrintWriter>();            
34.             threadPool = Executors.newFixedThreadPool(40);
35.         } catch (Exception e) {
36.             e.printStackTrace();
37.         }
38.     }
40.     /**
41.      * 服务端开启方法
42.      */
43.     public void start() {
44.         try {
45.             //循环监听客户端的连接
46.             while(true){
47.                 System.out.println("等待客户端连接...");
48.                 // 监听客户端的连接
49.                 Socket socket = serverSocket.accept();
50.                 System.out.println("客户端已连接!");
51.                 
52.                 //启动一个线程来完成针对该客户端的交互
53.                 ClientHandler handler = new ClientHandler(socket);
54.                 threadPool.execute(handler);
55.             }            
56.         } catch (Exception e) {
57.             e.printStackTrace();
58.         }
59.     }
60.     /**
61.      * 将输出流存入共享集合，与下面两个方法互斥，保证同步安全
62.      * @param out
63.      */
64.     private synchronized void addOut(String nickName,PrintWriter out){
65.         allOut.put(nickName,out);
66.     }
67.     /**
68.      * 将给定输出流从共享集合删除
69.      * @param out
70.      */
71.     private synchronized void removeOut(String nickName){
72.         allOut.remove(nickName);
73.     }
74.     /**
75.      * 将消息转发给所有客户端
76.      * @param message
77.      */
78.     private synchronized void sendMessage(String message){
79.         for(PrintWriter o : allOut.values()){
80.             o.println(message);
81.         }
82.     }
83.     /**
84.      * 将消息发送给指定昵称的客户端
85.      * @param nickName
86.      * @param message
87.      */
88.     private synchronized void sendMessageToOne(String nickName,String message){
89.         PrintWriter out = allOut.get(nickName);
90.         if(out!=null){
91.             out.println(message);
92.         }
93.     }
94.     
95.     public static void main(String[] args) {
96.         Server server = new Server();
97.         server.start();
98.     }
100.     /**
101.      * 线程体，用于并发处理不同客户端的交互
102.      */
103.     private class ClientHandler implements Runnable {
104.         // 该线程用于处理的客户端
105.         private Socket socket;
106.         // 开客户端的昵称
107.         private String nickName;
109.         public ClientHandler(Socket socket) {
110.             this.socket = socket;
111.         }
113.         @Override
114.         public void run() {
115.             PrintWriter pw = null;
116.             try {
117.                 //将客户端的输出流存入共享集合，以便广播消息
118.                 OutputStream out = socket.getOutputStream();
119.                 OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
120.                 pw = new PrintWriter(osw,true);
121.                 /*
122.                  * 将用户信息存入共享集合
123.                  * 需要同步
124.                  */
125.                 //先获取该用户昵称
126.                 nickName = getNickName();
127.                 addOut(nickName,pw);
128.                 Thread.sleep(100);
129.                 /*
130.                  * 通知所有用户该用户已上线
131.                  */
132.                 sendMessage(nickName+"上线了");
133.                 
134.                 InputStream in = socket.getInputStream();
135.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
136.                 BufferedReader br = new BufferedReader(isr);
137.                 
138.                 String message = null;
139.                 // 循环读取客户端发送的信息
140.                 while ((message = br.readLine())!=null) {
141.                     //首先查看是不是私聊
142.                     if(message.startsWith("\")){
143.                         /*
144.                          * 私聊格式：昵称:内容
145.                          */
146.                         //找到:的位置
147.                         int index = message.indexOf(":");
148.                         if(index>=0){
149.                             //截取昵称
150.                             String name = message.substring(1,index);
151.                             //截取内容
152.                             String info = message.substring(index+1,message.length());
153.                             //拼接内容
154.                             info = nickName+"对你说:"+info;
155.                             //发送私聊信息给指定用户
156.                             sendMessageToOne(name, info);
157.                             //发送完私聊后就不在广播了。
158.                             continue;
159.                         }
160.                     }
161.                     /*
162.                      * 遍历所有输出流，将该客户端发送的信息转发给所有客户端
163.                      * 需要同步
164.                      */
165.                     sendMessage(nickName+"说:"+message);
166.                 }
167.             } catch (Exception e) {
168.                 e.printStackTrace();
169.             } finally {
170.                 /*
171.                  * 当客户端断线，要将输出流从共享集合中删除
172.                  * 需要同步
173.                  */
174.                 removeOut(nickName);
175.                 /*
176.                  * 通知所有用户该用户已下线
177.                  */
178.                 sendMessage(nickName+"下线了");
179.                 System.out.println("当前在线人数:"+allOut.size());
180.                 if (socket != null) {
181.                     try {
182.                         socket.close();
183.                     } catch (IOException e) {
184.                         e.printStackTrace();
185.                     }
186.                 }
187.             }
188.         }
189.         /**
190.          * 获取该用户的昵称
191.          * @return
192.          */
193.         private String getNickName()throws Exception{
194.             try {
195.                 //获取该用户的输出流
196.                 OutputStream out = socket.getOutputStream();
197.                 OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
198.                 PrintWriter pw = new PrintWriter(osw,true);
199.                 //获取该用户的输入流
200.                 InputStream in = socket.getInputStream();
201.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
202.                 BufferedReader br = new BufferedReader(isr);
203.                 //读取客户端发送过来的昵称
204.                 String nickName = br.readLine();
205.                 while(true){
206.                     //若昵称为空发送失败代码
207.                     if(nickName.trim().equals("")){
208.                         pw.println("FAIL");
209.                     }
210.                     //若昵称已经存在发送失败代码
211.                     if(allOut.containsKey(nickName)){
212.                         pw.println("FAIL");
213.                     //若成功，发送成功代码，并返回昵称
214.                     }else{
215.                         pw.println("OK");
216.                         return nickName;
217.                     }
218.                     //若改昵称被占用，等待用户再次输入昵称
219.                     nickName = br.readLine();
220.                 }
221.             } catch (Exception e) {
222.                 throw e;
223.             }            
224.         }
225.     }
226. }

本案例中，类Client的完整代码如下所示：

 

1. package com.tarena.homework;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.OutputStreamWriter;
9. import java.io.PrintWriter;
10. import java.net.Socket;
11. import java.util.Scanner;
13. /**
14. * 客户端应用程序
15. */
16. public class Client {
17.     //客户端Socket
18.     private Socket socket;
19.     /**
20.      * 构造方法，用于初始化
21.      */
22.     public Client(){
23.         try {
24.             socket = new Socket("localhost",8088);
25.         } catch (Exception e) {
26.             e.printStackTrace();
27.         }
28.     }
29.     /**
30.      * 客户端工作方法
31.      */
32.     public void start(){
33.         try {
34.             //创建Scanner读取用户输入内容
35.             Scanner scanner = new Scanner(System.in);
36.             //首先输入昵称
37.             inputNickName(scanner);
38.             
39.             //将接收服务端信息的线程启动
40.             ServerHander handler = new ServerHander();
41.             Thread t = new Thread(handler);
42.             t.setDaemon(true);
43.             t.start();
44.             
45.             OutputStream out = socket.getOutputStream();            
46.             OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");            
47.             PrintWriter pw = new PrintWriter(osw,true);
48.             while(true){
49.                 pw.println(scanner.nextLine());
50.             }
51.         } catch (Exception e) {
52.             e.printStackTrace();
53.         } finally{
54.             if(socket != null){
55.                 try {
56.                     socket.close();
57.                 } catch (IOException e) {
58.                     e.printStackTrace();
59.                 }
60.             }
61.         }
62.     }
63.     
64.     public static void main(String[] args) {
65.         Client client = new Client();
66.         client.start();
67.     }
68.     
69.     /**
70.      * 输入昵称
71.      */
72.     private void inputNickName(Scanner scanner)throws Exception{
73.         //定义昵称
74.         String nickName = null;
75.         //创建输出流
76.         PrintWriter pw = new PrintWriter(
77.                             new OutputStreamWriter(
78.                                 socket.getOutputStream(),"UTF-8")
79.                          ,true);
80.         //创建输入流
81.         BufferedReader br = new BufferedReader(
82.                                 new InputStreamReader(
83.                                         socket.getInputStream(),"UTF-8")
84.                          );
85.         /*
86.          * 循环以下操作
87.          * 输入用户名，并上传至服务器，等待服务器回应，若昵称可用就结束循环，否则通知用户后
88.          * 重新输入昵称
89.          */
90.         while(true){
91.             System.out.println("请输入昵称:");
92.             nickName = scanner.nextLine();
93.             if(nickName.trim().equals("")){
94.                 System.out.println("昵称不能为空");
95.             }else{
96.                 pw.println(nickName);
97.                 String pass = br.readLine();
98.                 if(pass!=null&&!pass.equals("OK")){
99.                     System.out.println("昵称已被占用，请更换。");
100.                 }else{
101.                     System.out.println("你好!"+nickName+",开始聊天吧!");
102.                     break;
103.                 }
104.             }
105.         }
106.     }
107.     
108.     /**
109.      * 该线程用于接收服务端发送过来的信息
110.      */
111.     private class ServerHander implements Runnable{
112.         @Override
113.         public void run() {
114.             try {
115.                 InputStream in = socket.getInputStream();
116.                 InputStreamReader isr = new InputStreamReader(in, "UTF-8");
117.                 BufferedReader br = new BufferedReader(isr);
118.                 while(true){
119.                     System.out.println(br.readLine());
120.                 }
121.             } catch (Exception e) {
122.                 e.printStackTrace();
123.             }
124.         }
125.     }
126. }