网络编程——UDP局域网搜索案例

UDP

User Datagram Protocol ：一种用户数据报协议，又称用户数据报文协议

是一个简单的面向数据报的传输层协议，正式规范为RFC 768

用户数据协议、非连接协议

为什么是不可靠的？

它一旦把应用程序发给网络层的数据发送出去，就不保留数据备份

UDP在IP数据报的头部仅仅加入了复用和数据校验（字段）

发送端生产数据，接收端从网络中抓取数据

结构简单、无校验、速度快、容易丢包、可广播

UDP能做什么？

DNS、TFTP、SNMP

用于视频、音频、普通数据（无关紧要数据）

UDP核心API

• DatagramSocket

用于接收与发送UDP的类

负责发送某一个UDP包，或者接收UDP包

不同于TCP，UDP并没有合并到Socket API中

DatagramSocket() ：创建简单实例，不指定端口与IP，将会使用本机的

DatagramSocket(int port) ：创建监听固定端口的实例

DatagramSocket(int port , InetAddress localAddr) ：创建固定端口指定IP的实例

receive(DatagramPacket d) ：接收

send(DatagramPacket d) ：发送

setSoTimeout(int timeout) ：设置超时，毫秒

close() ：关闭资源

• DatagramPacket

用于处理报文

将byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成byte数组

是UDP的发送实体，也是接收实体

DatagramPacket( byte[] buf, int offset ,int length , InetAddress address, int port)

前面3个参数指定buf的使用区间

后面2个参数指定目标机器地址与端口

DatagramPacket( byte[] buf, int length , SocketAddress address)

前面3个参数指定buf的使用区间

SocketAddress相当于InetAddress + Port

setData(byte[] buf , int offset , int length )

setData(byte[] buf)

setLength(int length)

getData()、getOffset()、 getlength()

setAddress( InetAddress iaddr)、setPort(int iport) //发送时有效，接收时无效的，接收时是由系统自动set

getAddress()、getPort()

setSocketAddress( SocketAddress address)

getSocketAddress()

UDP单播、广播、多播

广播地址

255.255.255.255 为受限广播地址

C网广播地址一般为：XXX.XXX.XXX.255（192.128.1.255）

D类IP地址为多播预留

IP地址构成

广播地址运算

IP：192.168.124.7

子网掩码：255.255.255.192

网络地址：192.168.124.0

广播地址：192.168.124.63

广播通信问题：不在同一个广播地址网段，是无法通信的

案例实操——局域网搜索案例

• UDP接收消息并回送功能实现
• UDP局域网广播发送实现
• UDP局域网回送消息实现

UDPProvider：服务器端，不断监听端口20000，回送消息

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.UUID;

/**
 * UDP提供者，用于提供服务，B计算机
 */
public class UDPProvider {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //生成唯一标识
        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;

        private 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 (IOException e) {
    
    
            } finally {
    
    
                //完成，关闭资源
                close();
            }
            System.out.println("UDPProvider Finished...");
        }

        private void close() {
    
    
            if (ds != null) {
    
    
                ds.close();
                ds = null;
            }
        }

        void exit() {
    
    
            done = true;
            close();
        }
    }
}

UDPSearcher：自身监听窗口为30000，向20000端口发送信息

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;

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();
        //直接构建DatagramPacket
        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;

        public 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) {
    
    
            this.listenPort = listenPort;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
    
    
            super.run();
            //通知已启动
            countDownLatch.countDown();
            try {
    
    
                //监听20000端口
                ds = new DatagramSocket(LISTEN_PORT);
                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();
            }
        }

        private void close() {
    
    
            if (ds != null) {
    
    
                ds.close();
                ds = null;
            }
        }

        List<Device> getDevicesAndClose() {
    
    
            done = true;
            close();
            return devices;
        }
    }
}

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;
    }
}