17.4.3 使用MulticastSocket实现多点广播（4）

17.4.3  使用MulticastSocket实现多点广播（4）

通过UserInfo类的封装，所有客户端只需要维护该UserInfo类的列表，程序就可以实现广播、发送私聊信息等功能。本程序底层通信的工具类则需要一个MulticastSocket和一个DatagramSocket，该工具类的代码如下。

程序清单：codes\17\17.4\LanTalk\ComUtil.java

1. // 聊天交换信息的工具类
2. public class ComUtil
3. {
4. // 使用常量作为本程序的多点广播IP地址
5. private static final String BROADCAST_IP
6. = "230.0.0.1";
7. // 使用常量作为本程序的多点广播目的地端口
8. // DatagramSocket所用的端口为该端口号-1
9. public static final int BROADCAST_PORT = 30000;
10. // 定义每个数据报的最大大小为4KB
11. private static final int DATA_LEN = 4096;
12. // 定义本程序的MulticastSocket实例
13. private MulticastSocket socket = null;
14. // 定义本程序私聊的Socket实例
15. private DatagramSocket singleSocket = null;
16. // 定义广播的IP地址
17. private InetAddress broadcastAddress = null;
18. // 定义接收网络数据的字节数组
19. byte[] inBuff = new byte[DATA_LEN];
20. // 以指定字节数组创建准备接收数据的DatagramPacket对象
21. private DatagramPacket inPacket =
22. new DatagramPacket(inBuff , inBuff.length);
23. // 定义一个用于发送的DatagramPacket对象
24. private DatagramPacket outPacket = null;
25. // 聊天的主界面程序
26. private LanTalk lanTalk;
27. // 构造器，初始化资源
28. public ComUtil(LanTalk lanTalk) throws Exception
29. {
30. this.lanTalk = lanTalk;
31. // 创建用于发送、接收数据的MulticastSocket对象
32. // 因为该MulticastSocket对象需要接收数据，所以有指定端口
33. socket = new MulticastSocket(BROADCAST_PORT);
34. // 创建私聊用的DatagramSocket对象
35. singleSocket = new DatagramSocket(BROADCAST_PORT + 1);
36. broadcastAddress = InetAddress.getByName(BROADCAST_IP);
37. // 将该socket加入指定的多点广播地址
38. socket.joinGroup(broadcastAddress);
39. // 设置本MulticastSocket发送的数据报被回送到自身
40. socket.setLoopbackMode(false);
41. // 初始化发送用的DatagramSocket，它包含一个长度为0的字节数组
42. outPacket = new DatagramPacket(new byte[0]
43. , 0 , broadcastAddress , BROADCAST_PORT);
44. // 启动两个读取网络数据的线程
45. new ReadBroad().start();
46. Thread.sleep(1);
47. new ReadSingle().start();
48. }
49. // 广播消息的工具方法
50. public void broadCast(String msg)
51. {
52. try
53. {
54. // 将msg字符串转换成字节数组
55. byte[] buff = msg.getBytes();
56. // 设置发送用的DatagramPacket里的字节数据
57. outPacket.setData(buff);
58. // 发送数据报
59. socket.send(outPacket);
60. }
61. // 捕获异常
62. catch (IOException ex)
63. {
64. ex.printStackTrace();
65. if (socket != null)
66. {
67. // 关闭该Socket对象
68. socket.close();
69. }
70. JOptionPane.showMessageDialog(null
71. , "发送信息异常，请确认30000端口空闲，且网络连接正常！"
72. , "网络异常", JOptionPane.ERROR_MESSAGE);
73. System.exit(1);
74. }
75. }
76. // 定义向单独用户发送消息的方法
77. public void sendSingle(String msg , SocketAddress dest)
78. {
79. try
80. {
81. // 将msg字符串转换成字节数组
82. byte[] buff = msg.getBytes();
83. DatagramPacket packet = new DatagramPacket(buff
84. , buff.length , dest);
85. singleSocket.send(packet);
86. }
87. // 捕获异常
88. catch (IOException ex)
89. {
90. ex.printStackTrace();
91. if (singleSocket != null)
92. {
93. // 关闭该Socket对象
94. singleSocket.close();
95. }
96. JOptionPane.showMessageDialog(null
97. , "发送信息异常，请确认30001端口空闲，且网络连接正常！"
98. , "网络异常", JOptionPane.ERROR_MESSAGE);
99. System.exit(1);
100. }
101. }
102. // 不断地从DatagramSocket中读取数据的线程
103. class ReadSingle extends Thread
104. {
105. // 定义接收网络数据的字节数组
106. byte[] singleBuff = new byte[DATA_LEN];
107. private DatagramPacket singlePacket =
108. new DatagramPacket(singleBuff , singleBuff.length);
109. public void run()
110. {
111. while (true)
112. {
113. try
114. {
115. // 读取Socket中的数据
116. singleSocket.receive(singlePacket);
117. // 处理读到的信息
118. lanTalk.processMsg(singlePacket , true);
119. }
120. // 捕获异常
121. catch (IOException ex)
122. {
123. ex.printStackTrace();
124. if (singleSocket != null)
125. {
126. // 关闭该Socket对象
127. singleSocket.close();
128. }
129. JOptionPane.showMessageDialog(null
130. , "接收信息异常，请确认30001端口空闲，且网络连接正常！"
131. , "网络异常", JOptionPane.ERROR_MESSAGE);
132. System.exit(1);
133. }
134. }
135. }
136. }
137. // 持续读取MulticastSocket的线程
138. class ReadBroad extends Thread
139. {
140. public void run()
141. {
142. while (true)
143. {
144. try
145. {
146. // 读取Socket中的数据
147. socket.receive(inPacket);
148. // 打印输出从Socket中读取的内容
149. String msg = new String(inBuff , 0
150. , inPacket.getLength());
151. // 读到的内容是在线信息
152. if (msg.startsWith(YeekuProtocol.PRESENCE)
153. && msg.endsWith(YeekuProtocol.PRESENCE))
154. {
155. String userMsg = msg.substring(2
156. , msg.length() - 2);
157. String[] userInfo = userMsg.split(YeekuProtocol
158. .SPLITTER);
159. UserInfo user = new UserInfo(userInfo[1]
160. , userInfo[0] , inPacket.getSocketAddress(), 0);
161. // 控制是否需要添加该用户的旗标
162. boolean addFlag = true;
163. ArrayList<Integer> delList = new ArrayList<>();
164. // 遍历系统中已有的所有用户，该循环必须循环完成
165. for (int i = 1 ; i < lanTalk.getUserNum() ; i++ )
166. {
167. UserInfo current = lanTalk.getUser(i);
168. // 将所有用户失去联系的次数加1
169. current.setLost(current.getLost() + 1);
170. // 如果该信息由指定用户发送
171. if (current.equals(user))
172. {
173. current.setLost(0);
174. // 设置该用户无须添加
175. addFlag = false;
176. }
177. if (current.getLost() > 2)
178. {
179. delList.add(i);
180. }
181. }
182. // 删除delList中的所有索引对应的用户
183. for (int i = 0; i < delList.size() ; i++)
184. {
185. lanTalk.removeUser(delList.get(i));
186. }
187. if (addFlag)
188. {
189. // 添加新用户
190. lanTalk.addUser(user);
191. }
192. }
193. // 读到的内容是公聊信息
194. else
195. {
196. // 处理读到的信息
197. lanTalk.processMsg(inPacket , false);
198. }
199. }
200. // 捕获异常
201. catch (IOException ex)
202. {
203. ex.printStackTrace();
204. if (socket != null)
205. {
206. // 关闭该Socket对象
207. socket.close();
208. }
209. JOptionPane.showMessageDialog(null
210. , "接收信息异常，请确认30000端口空闲，且网络连接正常！"
211. , "网络异常", JOptionPane.ERROR_MESSAGE);
212. System.exit(1);
213. }
214. }
215. }
216. }
217. }

转载于:https://www.cnblogs.com/senior-engineer/p/4967216.html