UDP的广播实例

小鱼儿 2022-03-02 13:08 285阅读 0赞

# 运行环境 #

** IDEA**

# 目录结构 #

*      MessageCreator 数据构造器，用于信息发送的数据格式化
 *      UDPProvider 用于提供数据，即广播的接收者
 *      UDPSearcher 用于搜索支持方，即广播发送者

# MessageCreator类 #

public class MessageCreator {
        //发送数据包的头部
        private static final String SN_HEADER = "收到暗号，我是（SN）:";
        private static final String PORT_HEADER = "这是暗号，请回电端口（Port）:";
    
        //端口构造
        public static String buildWithPort(int port) {
            return PORT_HEADER + port;
        }
    
        //端口解析
        public static int parsePort(String data) {
            if (data.startsWith(PORT_HEADER)) {
                return Integer.parseInt(data.substring(PORT_HEADER.length()));
            }
    
            return -1;
        }
    
        //数据构造
        public static String buildWithSn(String sn) {
            return SN_HEADER + sn;
        }
    
        //数据解析
        public static String parseSn(String data) {
            if (data.startsWith(SN_HEADER)) {
                return data.substring(SN_HEADER.length());
            }
            return null;
        }
    
    }

UDPProvider类

import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.util.UUID;
    
    /**
     * UDP 提供者，用于提供服务
     */
    public class UDPProvider {
    
        public static void main(String[] args) throws IOException {
            // 使用UUID生成一份唯一标示
            String sn = UUID.randomUUID().toString();
            //数据构造线程
            Provider provider = new Provider(sn);
            provider.start();
    
            // 读取任意键盘信息后可以退出
            System.in.read();
            provider.exit();
        }
    
        private static class Provider extends Thread {
            private final String sn;
            private boolean done = false;
            private DatagramSocket ds = null;
    
            public Provider(String sn) {
                super();
                this.sn = sn;
            }
    
            @Override
            public void run() {
                super.run();
    
                System.out.println("UDPProvider Started.");
    
                try {
                    // 监听20000 端口
                    ds = new DatagramSocket(20000);
    
                    while (!done) {
    
                        // 构建接收实体
                        final byte[] buf = new byte[512];
                        DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
    
                        // 接收
                        ds.receive(receivePack);
    
                        // 打印接收到的信息与发送者的信息
                        // 发送者的IP地址
                        String ip = receivePack.getAddress().getHostAddress();
                        int port = receivePack.getPort();
                        int dataLen = receivePack.getLength();
                        String data = new String(receivePack.getData(), 0, dataLen);
                        System.out.println("UDPProvider receive form ip:" + ip
                                + "\tport:" + port + "\tdata:" + data);
    
                        // 解析端口号
                        int responsePort = MessageCreator.parsePort(data);
                        if (responsePort != -1) {
                            // 构建一份回送数据
                            String responseData = MessageCreator.buildWithSn(sn);
                            byte[] responseDataBytes = responseData.getBytes();
                            // 直接根据发送者构建一份回送信息
                            DatagramPacket responsePacket = new DatagramPacket(responseDataBytes,
                                    responseDataBytes.length,
                                    receivePack.getAddress(),
                                    responsePort);
    
                            ds.send(responsePacket);
                        }
    
                    }
    
                }
                //抛出的异常忽略
                catch (Exception ignored) {
                } finally {
                    close();
                }
    
                // 完成
                System.out.println("UDPProvider Finished.");
            }
    
    
            //关闭，释放资源
            private void close() {
                if (ds != null) {
                    ds.close();
                    ds = null;
                }
            }
    
    
            /**
             * 提供结束
             */
            void exit() {
                done = true;
                close();
            }
    
        }
    
    }

# UDPSearcher类 #

import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    
    /**
     * UDP 搜索者，用于搜索服务支持方
     */
    public class UDPSearcher {
        private static final int LISTEN_PORT = 30000;
    
    
        public static void main(String[] args) throws IOException, InterruptedException {
            System.out.println("UDPSearcher Started.");
    
            //监听设备
            Listener listener = listen();
            //发送广播
            sendBroadcast();
    
            // 读取任意键盘信息后可以退出
            System.in.read();
    
            //设备信息存储列表
            List<Device> devices = listener.getDevicesAndClose();
    
            for (Device device : devices) {
                System.out.println("Device:" + device.toString());
            }
    
            // 完成
            System.out.println("UDPSearcher Finished.");
        }
    
        private static Listener listen() throws InterruptedException {
            System.out.println("UDPSearcher start listen.");
            //阻塞主线程，子线程全部运行完后才运行主线程，数字代表子线程数量
            //此时等待设备连接
            CountDownLatch countDownLatch = new CountDownLatch(1);
            Listener listener = new Listener(LISTEN_PORT, countDownLatch);
            listener.start();
            //开启子线程后必须立即调用该方法阻塞主线程
            countDownLatch.await();
            return listener;
        }
    
        private static void sendBroadcast() throws IOException {
            System.out.println("UDPSearcher sendBroadcast started.");
    
            // 作为搜索方，让系统自动分配端口
            DatagramSocket ds = new DatagramSocket();
    
    
            // 构建一份请求数据
            String requestData = MessageCreator.buildWithPort(LISTEN_PORT);
            byte[] requestDataBytes = requestData.getBytes();
            // 直接构建packet
            DatagramPacket requestPacket = new DatagramPacket(requestDataBytes,
                    requestDataBytes.length);
            // 20000端口, 广播地址
            requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
            requestPacket.setPort(20000);
    
            // 发送
            ds.send(requestPacket);
            ds.close();
    
            // 完成
            System.out.println("UDPSearcher sendBroadcast finished.");
        }
    
        //设备信息表示类
        private static class Device {
            final int port;
            final String ip;
            final String sn;
    
            private Device(int port, String ip, String sn) {
                this.port = port;
                this.ip = ip;
                this.sn = sn;
            }
    
            @Override
            public String toString() {
                return "Device{" +
                        "port=" + port +
                        ", ip='" + ip + '\'' +
                        ", sn='" + sn + '\'' +
                        '}';
            }
        }
    
        private static class Listener extends Thread {
            private final int listenPort;
            private final CountDownLatch countDownLatch;
            private final List<Device> devices = new ArrayList<>();
            private boolean done = false;
            private DatagramSocket ds = null;
    
    
            public Listener(int listenPort, CountDownLatch countDownLatch) {
                super();
                this.listenPort = listenPort;
                this.countDownLatch = countDownLatch;
            }
    
            @Override
            public void run() {
                super.run();
    
                // 通知已启动，表示子线程已完成任务
                countDownLatch.countDown();
                try {
                    // 监听回送端口
                    ds = new DatagramSocket(listenPort);
    
    
                    while (!done) {
                        // 构建接收实体
                        final byte[] buf = new byte[512];
                        DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
    
                        // 接收
                        ds.receive(receivePack);
    
                        // 打印接收到的信息与发送者的信息
                        // 发送者的IP地址
                        String ip = receivePack.getAddress().getHostAddress();
                        int port = receivePack.getPort();
                        int dataLen = receivePack.getLength();
                        String data = new String(receivePack.getData(), 0, dataLen);
                        System.out.println("UDPSearcher receive form ip:" + ip
                                + "\tport:" + port + "\tdata:" + data);
    
                        String sn = MessageCreator.parseSn(data);
                        if (sn != null) {
                            Device device = new Device(port, ip, sn);
                            devices.add(device);
                        }
                    }
                } catch (Exception ignored) {
    
                } finally {
                    close();
                }
                System.out.println("UDPSearcher listener finished.");
    
            }
    
            //关闭，释放资源
            private void close() {
                if (ds != null) {
                    ds.close();
                    ds = null;
                }
            }
    
            List<Device> getDevicesAndClose() {
                done = true;
                close();
                return devices;
            }
        }
    }

# 运行结果 #

先运行UDPProvider，后运行UDPSearcher。双方均按任意键结束

<table> 
 <tbody> 
  <tr> 
   <td>UDPProvider</td> 
   <td>UDPSearcher</td> 
  </tr> 
  <tr> 
   <td><img alt="" height="19" src="https://img-blog.csdnimg.cn/20190320163513733.png" width="173"></td> 
   <td><img alt="" height="77" src="https://img-blog.csdnimg.cn/20190320163534211.png" width="791"></td> 
  </tr> 
  <tr> 
   <td><img alt="" height="84" src="https://img-blog.csdnimg.cn/20190320163548225.png" width="632"></td> 
   <td><img alt="" height="140" src="https://img-blog.csdnimg.cn/2019032016355120.png" width="783"></td> 
  </tr> 
 </tbody> 
</table>