基于Socket编程的聊天工具【Java实现】

思路：

要实现聊天功能，我们就必须有服务器和客户端。客户端连接到服务器，然后通过发送消息到服务器及从服务器读取消息来达到多客户端通信的目的。简单来说，所有客户端都是通过服务器来进行身份验证和消息发送的。要达到通信的目的，我们首先要做的是实现多客户端与服务器的连接，当客户端连接上服务器之后，服务器需要做的就是每来一个客户端，就处理该客户端的业务，如登录，单聊等；客户端要做的就是通过读取服务器的数据、写入数据到服务器来实现与其他客户端的交互。

先通过两张图了解一下客户端与服务器的交互：

了解完大体思路之后，接下来我们来看一下各个步骤的具体实现方法：

• 客户端与服务器的连接

套接字使用TCP可以实现两台计算机之间的通信，客户端创建一个套接字，并尝试连接服务器的套接字。java.net.Socket类代表一个套接字，java.net.ServerSocket类为服务器提供了一种监听并连接的通信机制。在连接过程中：

1. 服务器会创建一个ServerSocket对象，表示通过服务器的端口进行通信。

public ServerSocket(int port) throws IOExecption  //创建绑定到特定端口的服务器套接字

2. 服务器调用ServerSocket类的accept()方法，该方法将阻塞等待客户端的连接。

public Socket accept() throws IOException  //侦听并接收到此套接字的连接

3. 当服务器在等待客户端连接时，此时一个客户端创建一个Socket对象，并指定服务器名称和端口号请求连接。

1. public Socket(String host, int port) throws UnknownHostException, IOException. 创建一个
2. 流套接字并将其连接到指定主机上的指定端口号。

4. 当客户端连接上服务器之后，在服务器端，accept()方法会返回一个新的socket引用，该socket连接到客户端的socket。

 

• 服务器的工作

当客户端连接上服务器之后，我们知道accept()方法会返回给服务器一个新的socket引用，该socket连接到客户端的socket。那么此时只要有一个客户端连接到服务器了，服务器就要处理客户端的业务。我们知道每个客户端其实都是独立的，而且每个客户端连接服务器的时间都不定，所以我们可以创建一个线程池，每来一个客户端，就将该客户端的业务提交到线程池中，由线程池执行器来执行任务。由于每个客户的业务需求不同，我们可以创建一个类(ExecuteClient)专门来处理客户的业务。

• 客户端的工作

当客户端连接上服务器之后，每一个客户端都会有一个Socket对象，该对象通过往服务器写入数据，从服务器读取数据可以实现不同客户端之间的通信。这时候我们也可以创建两个线程专门处理往服务器写入数据(WriteDataToServerThread)和从服务器读取数据(ReadDataFromServerThread)的功能。

那么服务器可以处理客户端的哪些业务呢？

由于客户端和服务器都有Socket对象，我们先来看看它们都能调用哪些方法：

1. public InputStream getInputStream() throws IOException //返回此套接字的输入流
2. public OutputStream getOutputStream() throws IOException //返回此套接字的输出流
3. public void close() throws IOException //关闭此套接字

此前我们先做如下约定：

1. 当输入register:<userName>:<password>时，表示用户注册

2. 当输入login:<userName>:<password>时，表示用户登录

3.当输入private:<userName>:<message>时，表示单聊

4.当输入group:<message>时，表示群聊

5.当输入bye时，表示用户退出

• 注册(register)

注册的时候有以下几点要求：

1. 用户名、密码均不能为空
2. 用户名、密码都仅支持字母和数字
3. 用户名长度：8-15，密码长度：6-10
4. 用户名不能重复，密码无要求
5. 注册信息存储（用户名+密码）

思路：当新用户注册时，首先会输入用户名和密码，在用户名和密码均满足上述要求时，我们需要对用户信息（用户名+密码）进行存储，以便再有新用户要注册时进行用户名是否重复的比较。在保存用户信息时，由于一个用户名对应一个密码，我们可以用Map<String,String>  USER_PASSWORD_MAP来保存，其中key为用户名，value为密码。当新用户注册成功后，告知该用户注册成功；否则将注册失败原因告知，如用户名重复，密码长度不对等。

1. //给客户端发送信息
2. private void sendMessage(Socket client, String message) {
3. try {
4. OutputStream clientOutput = client.getOutputStream();
5. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
6. writer.write(message + "\n");
7. writer.flush();
8. } catch (IOException e) {
9. e.printStackTrace();
10. }
11. }
12. 

13. //注册
14. private void register(String userName, String password, Socket client) {
15. if (userName == null) {
16. this.sendMessage(client, "用户名不能为空");
17. return;
18. }
19. if (password == null) {
20. this.sendMessage(client, "密码不能为空");
21. return;
22. }
23. 

24. char[] name = userName.toCharArray(); //字符串转数组
25. char[] passWord = password.toCharArray(); //字符串转数组
26. int nLength = name.length; //用户名的长度
27. int pLength = passWord.length; //密码的长度
28. if (!((nLength >= 8 && nLength <= 15) && (pLength >= 6 && pLength <= 10))) {
29. this.sendMessage(client, "输入的用户名或密码长度不符合要求（用户名长度8到15，密码长度6到10）");
30. return;
31. }
32. 

33. 

34. for (char n : name) {
35. if (!((n >= 'A' && n <= 'Z') || (n >= 'a' && n <= 'z') || (n >= '0' && n <= '9'))) {
36. this.sendMessage(client, "用户名仅支持字母、数字");
37. return;
38. }
39. }
40. for (char p : passWord) {
41. if (!((p >= 'A' && p <= 'Z') || (p >= 'a' && p <= 'z') || (p >= '0' && p <= '9'))) {
42. this.sendMessage(client, "密码仅支持字母、数字");
43. return;
44. }
45. }
46. 

47. 

48. for (Map.Entry<String, String> entry : USER_PASSWORD_MAP.entrySet()) {
49. if (userName.equals(entry.getKey())) {
50. this.sendMessage(client, "用户名" + userName + "已被占用");
51. return;
52. }
53. }
54. USER_PASSWORD_MAP.put(userName, password); //保存新注册的用户信息
55. this.sendMessage(this.client, "用户" + userName + "注册成功"); //通知客户端注册成功
56. }

• 登录(login)

登录的时候有以下几点要求：

 1. 用户名密码均正确
 2. 在线用户、离线用户存储
 3. 在线用户不能重复登录，离线用户可以再次登录

思路： 当用户注册并登录成功后，我们可以将其保存在在线用户中，以此来检测是否有在线用户重复登录；当用户离线后，将其保存在离线用户中。由于一个用户名对应一个用户，所以我们可以用Map<String,Socket> ONLINE_USER_MAP保存在线用户，Map<String,Socket> OFFLINE_USER_MAP保存离线用户。如果用户登录成功，则发送“用户登录成功”给该用户，否则发送未登录成功的原因，如用户名或密码不正确，在线用户不能重复登录等。

1. //给客户端发送信息
2. private void sendMessage(Socket client, String message) {
3. try {
4. OutputStream clientOutput = client.getOutputStream();
5. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
6. writer.write(message + "\n");
7. writer.flush();
8. } catch (IOException e) {
9. e.printStackTrace();
10. }
11. }
12. 

13. //登录
14. private void login(String userName, String password, Socket client) {
15. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
16. if (userName.equals(entry.getKey())) {
17. this.sendMessage(client, "用户" + userName + "已在线，不可重复登录");
18. return;
19. }
20. }
21. for (Map.Entry<String, String> entry : USER_PASSWORD_MAP.entrySet()) {
22. if (userName.equals(entry.getKey()) && password.equals(entry.getValue())) {
23. System.out.println("用户" + userName + "加入聊天室");
24. ONLINE_USER_MAP.put(userName, client); //将登录成功的用户存入 在线用户
25. printOnlineUser(); //打印在线用户
26. this.sendMessage(client, "用户" + userName + "登录成功"); //通知客户端登录成功
27. return;
28. }
29. }
30. this.sendMessage(client, "用户名或密码输入不正确");
31. return;
32. }

• 单聊(privateChat)

单聊的时候有以下几点要求：

1. 不能自己给自己发消息
2. 不支持给离线用户发送消息 

思路：我们知道单聊是一个用户(currentUserName)给另一个用户(target) 发消息(message)，那么为了用户更好的体验，在发送信息时，我们应该将发送者的用户名告知给被发送者。如果被发送者是自己，则不发送信息；如果被发送者已离线，则告知发送者被发送者已离线。

1. //获取当前用户的用户名
2. private String getCurrentUserName() {
3. String currentUserName = null;
4. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
5. if (entry.getValue().equals(this.client)) {
6. currentUserName = entry.getKey();
7. break;
8. }
9. }
10. return currentUserName;
11. }
12. 

13. //给客户端发送信息
14. private void sendMessage(Socket client, String message) {
15. try {
16. OutputStream clientOutput = client.getOutputStream();
17. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
18. writer.write(message + "\n");
19. writer.flush();
20. } catch (IOException e) {
21. e.printStackTrace();
22. }
23. }
24. 

25. //单聊
26. private void privateChat(String userName, String message) {
27. String currentUserName = this.getCurrentUserName();
28. Socket target = ONLINE_USER_MAP.get(userName);
29. if (currentUserName.equals(userName)) { //不能自己给自己发消息
30. return;
31. }
32. if (target != null) {
33. this.sendMessage(target, currentUserName + "对你说：" + message);
34. } else {
35. this.sendMessage(this.client, "用户" + userName + "已下线，此条消息未发出");
36. }
37. }

• 群聊(groupChat)

群聊的时候有以下几点要求：

1. 发送者发出的消息只显示给其他在线用户（不包括发送者本人）

思路：群聊即一个用户发了消息，其他在线用户都能收到消息并做出回应。

1. //获取当前用户的用户名
2. private String getCurrentUserName() {
3. String currentUserName = null;
4. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
5. if (entry.getValue().equals(this.client)) {
6. currentUserName = entry.getKey();
7. break;
8. }
9. }
10. return currentUserName;
11. }
12. 

13. //给客户端发送信息
14. private void sendMessage(Socket client, String message) {
15. try {
16. OutputStream clientOutput = client.getOutputStream();
17. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
18. writer.write(message + "\n");
19. writer.flush();
20. } catch (IOException e) {
21. e.printStackTrace();
22. }
23. }
24. 

25. //群聊
26. private void groupChat(String message) {
27. String currentUserName = this.getCurrentUserName();
28. for (Socket socket : ONLINE_USER_MAP.values()) {
29. if (socket.equals(this.client)) {
30. continue;
31. }
32. this.sendMessage(socket, currentUserName + "说：" + message);
33. }
34. }

• 退出(quit)

思路：因为客户端每输入一句话都会发给服务器，然后服务器根据用户输入的信息作出相应的处理。当用户输入bye时，表明用户要退出，此时用户将关闭客户端，且停止往服务器写入数据功能。当服务器收到用户发送的bye之后，服务器将该用户从在线用户中去除，之后发送bye给用户，通知用户可以退出了。

1. //获取当前用户的用户名
2. private String getCurrentUserName() {
3. String currentUserName = null;
4. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
5. if (entry.getValue().equals(this.client)) {
6. currentUserName = entry.getKey();
7. break;
8. }
9. }
10. return currentUserName;
11. }
12. 

13. //退出
14. private void quit() {
15. String currentUserName = this.getCurrentUserName();
16. System.out.println("用户" + currentUserName + "下线");
17. Socket socket = ONLINE_USER_MAP.get(currentUserName);
18. this.sendMessage(socket, "bye");
19. 

20. ONLINE_USER_MAP.remove(currentUserName);
21. printOnlineUser();
22. OFFLINE_USER_MAP.put(currentUserName, socket);
23. printOfflineUser();
24. 

25. }

完整源代码如下：

github地址：https://github.com/huiforeverlin/chat_room

服务器：

1. import java.io.IOException;
2. import java.net.ServerSocket;
3. import java.net.Socket;
4. import java.util.concurrent.ExecutorService;
5. import java.util.concurrent.Executors;
6. 

7. 

8. //服务器主类
9. public class MultiThreadServer {
10. public static void main(String[] args) {
11. final ExecutorService executorService = Executors.newFixedThreadPool(10);//核心线程10个
12. int port = 6666;//默认端口
13. try {
14. if (args.length > 0) { //命令行参数大于0，则将第一个参数作为端口值
15. port = Integer.parseInt(args[0]);
16. }
17. } catch (NumberFormatException e) {
18. System.out.println("端口参数不正确，将采用默认端口：" + port);
19. }
20. try {
21. ServerSocket serverSocket = new ServerSocket(port); //servereSocket表示服务器
22. System.out.println("等待客户端连接...");
23. while (true) {
24. Socket client = serverSocket.accept(); //支持多客户端连接
25. System.out.println("客户端连接端口号：" + client.getPort());
26. executorService.submit(new ExecuteClient(client)); //通过提交任务到线程池来执行每个客户的业务
27. }
28. } catch (IOException e) {
29. e.printStackTrace();
30. }
31. }
32. }

1. import java.io.IOException;
2. import java.io.InputStream;
3. import java.io.OutputStream;
4. import java.io.OutputStreamWriter;
5. import java.net.Socket;
6. import java.util.Map;
7. import java.util.Scanner;
8. import java.util.concurrent.ConcurrentHashMap;
9. 

10. 

11. //执行客户业务
12. public class ExecuteClient implements Runnable {
13. private final Socket client; //客户
14. private static final Map<String, Socket> ONLINE_USER_MAP = new ConcurrentHashMap<String, Socket>();//在线用户
15. private static final Map<String, Socket> OFFLINE_USER_MAP = new ConcurrentHashMap<String, Socket>();//离线用户
16. private static final Map<String, String> USER_PASSWORD_MAP = new ConcurrentHashMap<>(); //用户信息（用户名，密码）
17. 

18. public ExecuteClient(Socket client) {
19. this.client = client;
20. }
21. 

22. //实现run方法
23. public void run() {
24. try {
25. InputStream clientInput = client.getInputStream(); //从客户端读取数据
26. Scanner scanner = new Scanner(clientInput);
27. while (true) {
28. String line = scanner.nextLine();
29. if (line.startsWith("register")) { //注册
30. String[] segments = line.split("\\:");
31. String userName = segments[1]; //第一个参数表示用户名
32. String password = segments[2]; //第二个参数表示密码
33. this.register(userName, password, client);
34. continue;
35. }
36. if (line.startsWith("login")) { //登录
37. String[] segments = line.split("\\:");
38. String userName = segments[1]; //第一个参数表示用户名
39. String password = segments[2]; //第二个参数表示密码
40. this.login(userName, password, client);
41. continue;
42. }
43. if (line.startsWith("private")) { //单聊
44. String[] segments = line.split("\\:");
45. String userName = segments[1]; //第一个参数表示被发送者的名称
46. String message = segments[2]; //第二个参数表示要发送的信息
47. this.privateChat(userName, message);
48. continue;
49. }
50. if (line.startsWith("group")) { //群聊
51. String message = line.split("\\:")[1]; //要发送的信息
52. this.groupChat(message);
53. continue;
54. }
55. if (line.startsWith("bye")) { //退出
56. this.quit();
57. break;
58. }
59. }
60. } catch (IOException e) {
61. e.printStackTrace();
62. }
63. }
64. 

65. 

66. //注册
67. private void register(String userName, String password, Socket client) {
68. if (userName == null) {
69. this.sendMessage(client, "用户名不能为空");
70. return;
71. }
72. if (password == null) {
73. this.sendMessage(client, "密码不能为空");
74. return;
75. }
76. 

77. char[] name = userName.toCharArray(); //字符串转数组
78. char[] passWord = password.toCharArray(); //字符串转数组
79. int nLength = name.length; //用户名的长度
80. int pLength = passWord.length; //密码的长度
81. if (!((nLength >= 8 && nLength <= 15) && (pLength >= 6 && pLength <= 10))) {
82. this.sendMessage(client, "输入的用户名或密码长度不符合要求（用户名长度8到15，密码长度6到10）");
83. return;
84. }
85. 

86. 

87. for (char n : name) {
88. if (!((n >= 'A' && n <= 'Z') || (n >= 'a' && n <= 'z') || (n >= '0' && n <= '9'))) {
89. this.sendMessage(client, "用户名仅支持字母、数字");
90. return;
91. }
92. }
93. for (char p : passWord) {
94. if (!((p >= 'A' && p <= 'Z') || (p >= 'a' && p <= 'z') || (p >= '0' && p <= '9'))) {
95. this.sendMessage(client, "密码仅支持字母、数字");
96. return;
97. }
98. }
99. 

100. 

101. for (Map.Entry<String, String> entry : USER_PASSWORD_MAP.entrySet()) {
102. if (userName.equals(entry.getKey())) {
103. this.sendMessage(client, "用户名" + userName + "已被占用");
104. return;
105. }
106. }
107. USER_PASSWORD_MAP.put(userName, password); //保存新注册的用户信息
108. this.sendMessage(this.client, "用户" + userName + "注册成功"); //通知客户端注册成功
109. }
110. 

111. 

112. //登录
113. private void login(String userName, String password, Socket client) {
114. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
115. if (userName.equals(entry.getKey())) {
116. this.sendMessage(client, "用户" + userName + "已在线，不可重复登录");
117. return;
118. }
119. }
120. for (Map.Entry<String, String> entry : USER_PASSWORD_MAP.entrySet()) {
121. if (userName.equals(entry.getKey()) && password.equals(entry.getValue())) {
122. System.out.println("用户" + userName + "加入聊天室");
123. ONLINE_USER_MAP.put(userName, client); //将登录成功的用户存入 在线用户
124. printOnlineUser(); //打印在线用户
125. this.sendMessage(client, "用户" + userName + "登录成功"); //通知客户端登录成功
126. return;
127. }
128. }
129. this.sendMessage(client, "用户名或密码输入不正确");
130. return;
131. }
132. 

133. 

134. //单聊
135. private void privateChat(String userName, String message) {
136. String currentUserName = this.getCurrentUserName();
137. Socket target = ONLINE_USER_MAP.get(userName);
138. if (currentUserName.equals(userName)) { //不能自己给自己发消息
139. return;
140. }
141. if (target != null) {
142. this.sendMessage(target, currentUserName + "对你说：" + message);
143. } else {
144. this.sendMessage(this.client, "用户" + userName + "已下线，此条消息未发出");
145. }
146. }
147. 

148. //群聊
149. private void groupChat(String message) {
150. String currentUserName = this.getCurrentUserName();
151. for (Socket socket : ONLINE_USER_MAP.values()) {
152. if (socket.equals(this.client)) {
153. continue;
154. }
155. this.sendMessage(socket, currentUserName + "说：" + message);
156. }
157. }
158. 

159. //退出
160. private void quit() {
161. String currentUserName = this.getCurrentUserName();
162. System.out.println("用户" + currentUserName + "下线");
163. Socket socket = ONLINE_USER_MAP.get(currentUserName);
164. this.sendMessage(socket, "bye");
165. 

166. ONLINE_USER_MAP.remove(currentUserName);
167. printOnlineUser();
168. OFFLINE_USER_MAP.put(currentUserName, socket);
169. printOfflineUser();
170. 

171. }
172. 

173. 

174. //给客户端发送信息
175. private void sendMessage(Socket client, String message) {
176. try {
177. OutputStream clientOutput = client.getOutputStream();
178. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
179. writer.write(message + "\n");
180. writer.flush();
181. } catch (IOException e) {
182. e.printStackTrace();
183. }
184. }
185. 

186. //获取当前用户的用户名
187. private String getCurrentUserName() {
188. String currentUserName = null;
189. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
190. if (entry.getValue().equals(this.client)) {
191. currentUserName = entry.getKey();
192. break;
193. }
194. }
195. return currentUserName;
196. }
197. 

198. //打印在线用户
199. private void printOnlineUser() {
200. System.out.println("在线用户人数：" + ONLINE_USER_MAP.size() + ", 用户列表：");
201. for (Map.Entry<String, Socket> entry : ONLINE_USER_MAP.entrySet()) {
202. System.out.print(entry.getKey() + " ");
203. }
204. System.out.println("");
205. }
206. 

207. //打印离线用户
208. private void printOfflineUser() {
209. System.out.println("离线用户人数：" + OFFLINE_USER_MAP.size() + ", 离线用户：");
210. for (Map.Entry<String, Socket> entry : OFFLINE_USER_MAP.entrySet()) {
211. System.out.print(entry.getKey() + " ");
212. }
213. System.out.println("");
214. }
215. }

客户端：

1. import java.io.IOException;
2. import java.net.Socket;
3. 

4. 

5. //客户端主类
6. public class MultiThreadClient {
7. public static void main(String[] args) {
8. try {
9. String host = "127.0.0.1";
10. int port = 6666;
11. try {
12. if (args.length > 0) {
13. port = Integer.parseInt(args[0]);
14. }
15. } catch (NumberFormatException e) {
16. System.out.println("端口参数不正确，将采用默认端口：" + port);
17. }
18. if (args.length > 1) {
19. host = args[1];
20. }
21. 

22. final Socket client = new Socket(host, port);
23. new WriteDataToServerThread(client).start();
24. new ReadDataFromServerThread(client).start();
25. } catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29. }

1. import java.io.IOException;
2. import java.io.InputStream;
3. import java.net.Socket;
4. import java.util.Scanner;
5. 

6. 

7. //从服务器读取数据
8. public class ReadDataFromServerThread extends Thread {
9. private final Socket client;
10. 

11. public ReadDataFromServerThread(Socket client) {
12. this.client = client;
13. }
14. 

15. @Override
16. public void run() {
17. try {
18. InputStream clientInput = client.getInputStream();
19. Scanner scanner = new Scanner(clientInput);
20. while (true) {
21. String message = scanner.nextLine();
22. System.out.println("来自服务器的消息：" + message);
23. if (message.equals("bye")) {
24. break;
25. }
26. }
27. } catch (IOException e) {
28. e.printStackTrace();
29. }
30. }
31. }

1. import java.io.IOException;
2. import java.io.OutputStream;
3. import java.io.OutputStreamWriter;
4. import java.net.Socket;
5. import java.util.Scanner;
6. 

7. 

8. //往服务器写入数据
9. public class WriteDataToServerThread extends Thread {
10. private final Socket client;
11. 

12. public WriteDataToServerThread(Socket client) {
13. this.client = client;
14. }
15. 

16. @Override
17. public void run() {
18. try {
19. OutputStream clientOutput = client.getOutputStream();
20. OutputStreamWriter writer = new OutputStreamWriter(clientOutput);
21. Scanner scanner = new Scanner(System.in);
22. while (true) {
23. System.out.println("请输入消息：");
24. String message = scanner.nextLine();
25. writer.write(message + "\n");
26. writer.flush();
27. if (message.equals("bye")) {
28. client.close(); //客户端关闭退出
29. break;
30. }
31. }
32. } catch (IOException e) {
33. e.printStackTrace();
34. }
35. 

36. }
37. }