设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java网络编程（3）：使用 UDP 探测局域网内特定类型的机器

2016-12-20 13:12| 发布者: zhangjf| 查看: 448| 评论: 0

摘要: 记得以前我们使用类似“快牙”这些文件分享工具的时候，一开始就是先在 手机A 上创建一个“房间”，然后连接上 手机A WiFi 热点的其他手机（即这些手机处于一个局域网内）就可以发现到这个房间并加入到这个房间里面 ...

记得以前我们使用类似“快牙”这些文件分享工具的时候，一开始就是先在 手机A 上创建一个“房间”，然后连接上 手机A WiFi 热点的其他手机（即这些手机处于一个局域网内）就可以发现到这个房间并加入到这个房间里面，然后就可以互相分享文件了。那没有建立连接的情况下，“发现房间”这个功能是怎么实现的呢？
首先，既然 手机A 处于局域网中，那么根据 手机A 当前在局域网的 IP 地址和子网掩码，就可以获得这个局域网内所有机器的 IP 地址 的范围。如果在没有建立连接的情况下，手机A 就可以给这个范围内的每个 IP 地址都发送一个消息 —— 那么如果某个 IP 地址的机器（设为 手机B）会对这个消息做出回应，便说明 手机B 是 手机A 的“自己人”，那么 手机A 便可以告诉 手机B 它在当前的局域网建了一个“房间”，房间号是个啥，然后 手机B 可以选择是否加入到这个“房间”。

在Java网络编程（1）中，我们已经知道可以使用 NetworkInterface 来获得机器在局域网内 IP 地址；

在Java网络编程（2）中，我们知道使用 UDP，便可以在不建立连接的情况下，直接向某个 IP 地址发送消息；

如果每次都是遍历这个局域网内所有的 IP 地址，并使用 UDP 向每个 IP 发送消息，那样就有点麻烦了。事实上，我们可以使用广播。每个局域网都有一个对应的广播地址，向广播地址发送的数据包通过网关设备（比如路由器）时，网关设备会向局域网的每台设备发送一份该数据包的副本。通过 IP 和子网掩码计算广播地址的方法简单的形容就是 （IP地址）|（~子网掩码）—— 将子网掩码按位取反再和IP地址进行或运算，比如当前机器在局域网内的地址为 192.168.1.3，子网掩码为 255.255.255.0（取反后为 0.0.0.255），那么广播地址为 192.168.1.255。广播也是在不建立连接的情况下就发送数据，所以广播不能通过 TCP 实现，只能是 UDP。在 Java 中，通过 UDP 进行广播和单播（即只向一个 IP 地址发送数据包）的程序几乎没有区别，只是地址由一个特定的单播地址（如 192.168.1.3)变为了其对应的广播地址（192.168.1.255）。

现在让我们来实现下面的功能：
1、Broadcaster 创建一个房间，并每隔 1 秒向局域网广播一个特定的消息；
2、同一个局域网的 Device 如果收到了 3 次这个特定的消息，之后便向 Broadcaster 发送加入房间的消息；
3、Broadcaster 收到 Device 请求加入房间的消息后，将 Device 加入房间。

首先定义发送者类和接收者类，他们都实现了 Runnable，分别可以用来发送和接收：

Sender.java

  1. import java.io.IOException;
  2. import java.net.*;
  4. public class Sender implements Runnable {
  6. private static final byte[] EMPTY_DATA = new byte[0];
  8. private final DatagramSocket socket;
  9. private final SocketAddress broadcastAddress;
  10. private final long sendingInterval; // unit is ms
  12. public Sender(DatagramSocket socket,
  13. SocketAddress broadcastAddress, int sendingInterval) {
  14. this.socket = socket;
  15. this.broadcastAddress = broadcastAddress;
  16. this.sendingInterval = sendingInterval;
  17. }
  19. @Override
  20. public void run() {
  21. while (true) {
  22. byte[] data = getNextData();
  23. if (data == null || data.length == 0) {
  24. break;
  25. }
  27. DatagramPacket outPacket = new DatagramPacket(
  28. data, data.length, broadcastAddress);
  29. try {
  30. socket.send(outPacket);
  31. System.out.println("Sender: Data has been sent");
  33. Thread.sleep(sendingInterval);
  34. } catch (IOException | InterruptedException ex) {
  35. System.err.println("Sender: Error occurred while sending packet");
  36. break;
  37. }
  39. }
  40. System.out.println("Sender: Thread is end");
  41. }
  43. /**
  44. * 获得下一次发送的数据<br>
  45. * 子类需要重写这个方法，返回下一次要发送的数据
  46. *
  47. * @return 下一次发送的数据
  48. */
  49. public byte[] getNextData() {
  50. return EMPTY_DATA;
  51. }
  52. }
复制代码

Receiver.java

  1. import java.io.IOException;
  2. import java.net.*;
  4. public class Receiver implements Runnable {
  6. private final int BUF_SIZE = 512;
  8. private final DatagramSocket socket;
  10. public Receiver(DatagramSocket socket) {
  11. this.socket = socket;
  12. }
  14. @Override
  15. public void run() {
  16. byte[] inData = new byte[BUF_SIZE];
  17. DatagramPacket inPacket = new DatagramPacket(inData, inData.length);
  19. while (true) {
  20. try {
  21. socket.receive(inPacket);
  22. if (!handlePacket(inPacket)) {
  23. break;
  24. }
  25. } catch (IOException ex) {
  26. System.out.println("Receiver: Socket was closed.");
  27. break;
  28. }
  29. }
  30. System.out.println("Receiver: Thread is end");
  31. }
  33. /**
  34. * 处理接收到的数据报<br>
  35. * 子类需要重写这个方法，处理接收到的数据包，并返回是否继续接收
  36. *
  37. * @param packet 接收到的数据报
  38. * @return 是否需要继续接收
  39. */
  40. public boolean handlePacket(DatagramPacket packet) {
  41. return false;
  42. }
  43. }
复制代码

然后我们定义 Device 和 Broadcaster：

Device.java

  1. import java.io.IOException;
  2. import java.net.*;
  4. public class Device {
  6. private static final int DEFAULT_LISTENING_PORT = 10000;
  8. private final InetAddress address;
  9. private final int port;
  11. private DatagramSocket socket;
  13. public Device(int port) throws IOException {
  14. this.port = port;
  15. this.address = InetAddress.getLocalHost();
  16. }
  18. public Device(InetAddress address, int port) {
  19. this.address = address;
  20. this.port = port;
  21. }
  23. public void start() throws SocketException, InterruptedException {
  24. System.out.println("Device has been started...");
  25. InetAddress lanAddr = LANAddressTool.getLANAddressOnWindows();
  26. if (lanAddr != null) {
  27. System.out.println("Device: LAN Address: " + lanAddr.getHostAddress());
  28. }
  30. socket = new DatagramSocket(port);
  31. Receiver receiver = new Receiver(socket) {
  32. int recvCount = 0;
  34. @Override
  35. public boolean handlePacket(DatagramPacket packet) {
  36. String recvMsg = new String(packet.getData(), 0, packet.getLength());
  37. if ("ROOM".equals(recvMsg)) {
  38. System.out.printf("Device: Received msg '%s'n", recvMsg);
  39. recvCount++;
  40. if (recvCount == 3) {
  41. byte[] data = "JOIN".getBytes();
  42. DatagramPacket respMsg = new DatagramPacket(
  43. data, data.length, packet.getSocketAddress()); // 此时 packet 包含了发送者地址和监听端口
  44. try {
  45. socket.send(respMsg);
  46. System.out.println("Device: Sent response 'JOIN'");
  47. } catch (IOException ex) {
  48. ex.printStackTrace(System.err);
  49. }
  50. return false; // 停止接收
  51. }
  52. }
  53. return true;
  54. }
  55. };
  57. Thread deviceThread = new Thread(receiver);
  58. deviceThread.start(); // 启动接收数据包的线程
  59. deviceThread.join();
  61. close();
  63. System.out.println("Device has been closed.");
  64. }
  66. public void close() {
  67. if (socket != null) {
  68. socket.close();
  69. }
  70. }
  72. @Override
  73. public String toString() {
  74. return "Device {" + "address=" + address + ", port=" + port + '}';
  75. }
  77. public static void main(String[] args) throws Exception {
  78. Device device = new Device(DEFAULT_LISTENING_PORT);
  79. device.start();
  80. }
  81. }
复制代码

Broadcaster.java

  1. import java.net.*;
  3. public class Broadcaster {
  5. private static final int DEFAULT_BROADCAST_PORT = 10000;
  7. private final InetAddress bcAddr;
  8. private final int bcPort;
  10. private DatagramSocket socket;
  12. public Broadcaster(InetAddress broadcastAddress, int broadcastPort) {
  13. this.bcAddr = broadcastAddress;
  14. this.bcPort = broadcastPort;
  15. }
  17. public void start() throws SocketException, InterruptedException {
  18. System.out.println("Broadcaster has been started...");
  20. final Room room = new Room("Test");
  21. System.out.printf("Broadcaster: Created room '%s'nn", room.getName());
  23. socket = new DatagramSocket();
  24. SocketAddress bcSocketAddr = new InetSocketAddress(bcAddr, bcPort);
  26. Sender sender = new Sender(socket, bcSocketAddr, 1000) {// 每隔 1000ms 广播一次
  27. final byte[] DATA = "ROOM".getBytes();
  29. @Override
  30. public byte[] getNextData() {
  31. return DATA;
  32. }
  33. };
  35. Receiver recver = new Receiver(socket) {
  37. @Override
  38. public boolean handlePacket(DatagramPacket packet) {
  39. String recvMsg = new String(packet.getData(), 0, packet.getLength());
  40. if ("JOIN".equals(recvMsg)) {
  41. Device device = new Device(packet.getAddress(), packet.getPort());
  42. room.addDevice(device);
  43. room.listDevices();
  44. }
  45. return true; // 一直接收
  46. }
  47. };
  49. Thread senderThread = new Thread(sender);
  50. Thread recverThread = new Thread(recver);
  51. senderThread.start(); // 启动发送（广播）数据包的线程
  52. recverThread.start(); // 启动接收数据包的线程
  54. senderThread.join();
  55. recverThread.join();
  57. close();
  58. }
  60. public void close() {
  61. if (socket != null) {
  62. socket.close();
  63. }
  64. }
  66. public static void main(String[] args) throws Exception {
  67. InetAddress bcAddr = LANAddressTool.getLANBroadcastAddressOnWindows();
  69. if (bcAddr != null) {
  70. System.out.println("Broadcast Address: " + bcAddr.getHostAddress());
  71. Broadcaster broadcaster = new Broadcaster(bcAddr, DEFAULT_BROADCAST_PORT);
  72. broadcaster.start();
  73. } else {
  74. System.out.println("Please check your LAN~");
  75. }
  76. }
  77. }
复制代码

Room.java

  1. import java.util.*;
  3. public class Room {
  5. private final String name;
  6. private final List<Device> devices;
  8. public Room(String name) {
  9. this.name = name;
  10. this.devices = new ArrayList<>();
  11. }
  13. public boolean addDevice(Device device) {
  14. return devices.add(device);
  15. }
  17. public String getName() {
  18. return name;
  19. }
  21. public void listDevices() {
  22. System.out.printf("Room (%s), current devices:n", name);
  23. for (Device device : devices) {
  24. System.out.println(device);
  25. }
  26. }
  27. }
复制代码

（完整的 Demo 可以访问：https://github.com/mizhoux/LA...）

我们将这个 Demo 打包成 jar，然后开始运行：
1、首先我们在本机上启动 Broadcaster：

2、我们将本机作为一个 Device 启动：

可以看到此时 Broadcaster 创建的房间已经有了一个 Device：

3、我们启动局域网内的另外一台设备：

此时 Broadcaster 创建的房间便有两个 Device：

4、再启动局域网内的一台设备：

此时房间里则有三个 Device：

因为 UDP 在不需要建立连接的基础上就可以发送消息，所以它可以方便的用来探测局域网内特定类型的机器 —— 这是个很有用的功能 —— 又比如一个集群当中可能会突然有机器宕机，为了检测这一事件的发生，就需要集群 master机器 每隔一定的时间向每台机器发送若干心跳检测包，如果有回复说明机器正常，否则说明该机器出现了故障，此时不需要连接而且高效的 UDP 就十分适合这种场合。当然，我们始终还是要考虑到 UDP 是不可靠的协议，它并不能代替 TCP —— 永远需要根据环境，来选择最合适的技术。

收藏 邀请
上一篇：译文-Minor GC vs Major GC vs Full GC下一篇：搭建https服务--获取https证书（1）

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 21:08

Copyright 2015-2025 djqfx

返回顶部