Socket - UDP快速入门

CodeNeil

Socket - UDP快速入门

UDP是什么

  • 英语:User Datagram Protocol,缩写为UDP。
  • 一种用户数据报协议,又称用户数据报文协议
  • 是一个简单的面向数据报传输层协议,正式规范为 RFC 768。
  • 用户数据协议、非连接协议。

为什么UDP是不可靠的

  • 它一旦把应用程序发给网络层的数据发送出去,就不保留数据备份。
  • UDP在IP数据报的头部仅仅加入了复用和数据校验字段。
  • 发送端生产数据,接收端从网络中抓取数据。
  • 结构简单、无校验、速度快、容易丢包、可广播。

UDP能做什么

UDP是面向消息的协议,通信时不需要建立连接,数据的传输自然是不可靠的,UDP一般用于多点通信和实时的数据业务,比如:

  • 语音广播
  • 视频
  • QQ
  • TFTP(简单文件传送)
  • SNMP(简单网络管理协议)
  • RIP(路由信息协议,如报告股票市场,航空信息)
  • DNS(域名解释)
  • 注重速度流畅

UDP操作简单,而且仅需要较少的监护,因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统,并不要求音频视频数据绝对的正确,只要保证连贯性就可以了,这种情况下显然使用UDP会更合理一些。

UDP通信模型

UDP通信模型中,在通信开始之前,不需要建立相关的链接,只需要发送数据即可,类似于生活中,"写信""

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数组。
  • DatagramPacket是UDP的发送实体,也是接受实体。
  • DatagramPacket(byte[] buf , int offset , int length , InetAddress address , int port ) :指定byte数组和使用区间,后两个指定目标机器地址与端口。
  • DatagramPacket(byte[] buf , int length , SocketAddress address) :SocketAddress相当于InetAddress + Port。
  • setData(byte[] buf , int offset , int length):传入byte数据和长度信息。
  • setData(byte buf):传入整个byte数组的信息。
  • seLength(int length):设置有效区间。
  • getData() 、getOffset() 、getLength() :返回对应上述信息。
  • setAddress(InetAddress addr):目标地址。
  • setPort(int port):目标端口。
  • 对应的getAddress()、getPort()。
  • setSocketAddress(SocketAddress address):传入InetAddress + Port。
  • getSocketAddress():获取socket地址。

UDP 单播、广播、多播

  • 单播:用于两个主机之间的端对端通信。
  • 广播:用于一个主机对整个局域网上所有的主机上的数据通信。
  • 多播:对一组特定的主机进行通信,而不是整个局域网上的所有主机。

单播、广播、多播

IP地址

IP地址

  • A类:前8位表示网络ID,后24位表示主机ID;该地址分配给政府机关单位使用。
  • B类:前16位表示网络ID,后16位表示主机ID;该地址分配给中等规模的企业使用。
  • C类:前24位表示网络ID,后8位表示主机ID;该地址分配给任何需要的人使用。
  • D类:不分网络ID和主机ID;该地址用于多播。
  • E类:不分网络ID和主机ID;该地址用于实验。

地址区分

IP地址被分类以后,如何判断一个IP地址是A类、B类还是C类地址呢?为了更好地进行区分,将每类地址的开头部分设置为固定数值。如下:

地址区分

从图中可以看出,每类IP地址都是以32位的二进制格式显示的,每类地址的区别如下:

  • A类:网络ID的第一位以0开始的地址。
  • B类:网络ID的第一位以10开始的地址。
  • C类:网络ID的第一位以110开始的地址。
  • D类:地址以1110开始的地址。
  • E类:地址以11110开始的地址。

地址范围

由于每类地址的开头是固定的,因此每类地址都有自己的范围:

  • A类:IP地址范围为0.0.0.0~127.255.255.255。
  • B类:IP地址范围为128.0.0.0~191.255.255.255。
  • C类:IP地址范围为192.0.0.0~223.255.255.255。
  • D类:IP地址范围为224.0.0.0~239.255.255.255。
  • E类:IP地址范围为240.0.0.0~255.255.255.254。

广播地址

  • 255.255.255.255 为受限广播地址,如果向该地址的2000端口号发送一个信息,其实只有局域网内的设备能够收到。
  • C 网广播地址一般为:XXX.XXX.XXX.255(192.168.1.255)。
  • D类地址一般为多播预留。

IP地址构成

IP地址构成是使用短整型来存储的。一共四位,也就是一个int值。

IP地址构成

局域网搜索代码案例

/**
 * 
 * 消息构建
 * @author Jack
 */
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;
    }
}
/**
 * UDP 提供者,用于提供服务
 * @author Jack
 */
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;

        public Provider(String sn) {
            this.sn = sn;
        }

        @Override
        public void 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 + ", port:" + port + ", data:" + 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();
        }
    }
}
/**
 * UDP 搜索者,用于搜索服务支持方
 * @author Jack
 */
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) {
            this.listenPort = listenPort;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void 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;
        }
    }
}
阅读 204

Java菜鸟程序员
Be a good developer .微信公众号:Java菜鸟程序员

codeing.....

532 声望
301 粉丝
0 条评论

codeing.....

532 声望
301 粉丝
宣传栏