自学内容网 自学内容网

Socket网络编程(二)——UDP快速入门

UDP相关概念

UDP是什么

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

为什么不可靠

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

UDP能做什么

  • DNS(域名系统)、TFTP(简单文件传输协议)、SNMP(简单网络管理协议)
  • 视频、音频、普通数据(无关紧要数据)

UDP包最大长度

  • 16位-> 2字节存储长度信息
  • 2个16-1 = 64K-1 = 65536-1 = 65535
  • 自身协议占用:32+32位=64位=8字节
  • 65535-8 = 65507 byte

20240129-162937-0z.png

UDP单播、广播、多播概念

1. 单播、广播、多播模型图

20240131-095225-YI.png

2. ip地址分类

20240131-101516-Kt.png

IP地址分以下五类:

A类 : 从1.0.0.0 到126.255.255.255 ,适用于大型网络

B类 : 从128.0.0.0到191.255.255.255 ,适用于中型网络

C类 : 从192.0.0.0到223.255.255.255 ,适用于小型网络

D类 : 从224.0.0.0到239.255.255.255,用于组播

E类 : 从240.192.0.0.0到255.255.255.255,用于科研保留

A,B,C为常用类别。其中127.x.x.x段地址空间是被保留的回环地址

网络部分(网络地址)和主机部分(主机地址)

IP地址由2部分组成:网络部分+主机部分

IP地址=网络地址+主机地址

3. 子网掩码的作用:

子网掩码不能单独存在,它必须结合IP地址一起使用。子网掩码只有一个作用,就是将某个IP地址划分成网络地址和主机地址两部分。
通俗的说,就是用来分割子网和区分那些ip是同一个网段的,那些不是同一网段的。

①通过子网掩码,就可以判断两个IP在不在一个局域网内部。

②子网掩码可以看出有多少位是网络号,有多少位是主机号

③其对应的IP地址中网络地址的所有位置都为1,对应于主机地址的所有位置都为0。

每一类IP地址都有默认的子网掩码

对于A类地址来说,默认的子网掩码是255.0.0.0;

对于B类地址来说,默认的子网掩码是255.255.0.0;

对于C类地址来说,默认的子网掩码是255.255.255.0。

网络地址就是:把IP地址转成二进制和子网掩码进行与运算
与位运算:0与任何数运算为0,1与1运算为1

示例:一个主机的IP地址是202.112.14.137,掩码是255.255.255.224,要求计算这个主机所在网络的网络地址和广播地址

子网掩码255.255.255.224 转二进制:11111111.11111111.11111111.11100000

其中网络位部分是27位,主机位部分是5位

IP地址202.112.14.137转二进制:11001010 01110000 00001110 10001001

IP地址&子网掩码(进行与运算)

11001010 01110000 00001110 10001001

11111111 11111111 11111111 11100000

11001010 01110000 00001110 10000000

注:与位运算:0与任何数运算为0,1与1运算为1

结果为:202.112.14.128
即网络地址为:202.112.14.128

网络地址的主机位全部变成1,10011111,即159 
即广播地址为:202.112.14.159

判断两个IP地址是否为同一个网段,就是分别根据对应的IP地址和子网掩码计算出对应的网络地址,网络地址相同就是在同一个网段,不相同就不在同一个网段,不在同一个网段的ip地址之间无法进行直接通信(无法收到广播消息)。

4. 广播地址

广播地址(Broadcast Address)是专门用于同时向网络中所有工作站进行发送的一个地址。
在使用TCP/IP 协议的网络中,主机标识段host ID(主机位) 为全1 的IP 地址为广播地址,广播的分组传送给host ID段所涉及的所有计算机。
例如,对于10.1.1.0 (255.255.255.0 )网段,其广播地址为10.1.1.255 (255 即为2 进制的11111111 ),当发出一个目的地址为10.1.1.255 的分组(封包)时,它将被分发给该网段上的所有计算机。

5. 网段划分

常见数字:

  2,  4,  8, 16, 32, 64,128,256
  1,  3,  7, 14, 31, 63,127,255
255,254,252,248,240,224,192,128

大部分的情况下,我们网络中只要不超过254台主机的的话,子网掩码都可以设置成255.255.255.0。
那么超过了254台主机的话怎么办呢?600个ip地址的项目如何设置子网掩码呢?
可以划分vlan,也可以设置成一个大网段。
比如下面这个例子:

假设监控网络中有600个点位,我们现在也不想把它划分vlan(实际项目中大部分是会划分vlan的),假设只想用一个大网段把这600个点位分配ip地址,如何设置ip地址,如何确实子网掩码?

分析:首先我们知道600个点位,可以使用3个254个ip地址段来分配。

可以使用

ip段一:192.168.0.1——192.168.0.254

ip段二:192.168.1.1——192.168.1.254

ip段三:192.168.2.1——192.168.2.254

每个网段有254个ip地址,完全够600个点位用的。
那么问题来了,如果要使这三个ip段在同一个网段内,那么这个大网段共同的子网掩码是多少呢?

将ip地址192.168.1.1转换为二进制

11000000 10101000 00000000 00000001

将ip地址192.168.1.1转换为二进制

11000000 10101000 00000001 00000001

将ip地址192.168.2.1转换为二进制

11000000 10101000 00000010 00000001

转换成了二进制,可以看得出,三个ip段的二进制前面22位的是不变的,那么可以将他们表示成:

ip段一:192.168.0.1/22

ip段二:192.168.1.1/22

ip段三:192.168.2.1/22

这种192.168.1.x/22形式的ip地址相信大家平时都见过,就是已经告诉了子网掩码了。

也就是说他们共同的子网掩码二进制前面22个都是1。

11111111 11111111 11111100 00000000

转换成十进制,那就是255.255.252.0,所以他们共同的子网掩码就是255.255.252.0。

注意:子网掩码越精准越好,范围不要太大,不要统一写255.255.0.0,太大的范围在分配ip地址后,容易出现一些掉线故障,实际项目中,不用做这些复杂的运算,熟悉原理过后,看到了IP地址数量基本上就可以写出来。

所以通常:

网段ip地址低于254个,子网掩码可以设置成255.255.255.0

网段ip地址低于600个,子网掩码可以设置成255.255.252.0

网段ip地址低于1000个,子网掩码可以设置成255.255.248.0

6. 变长子网掩码

定义:变长子网掩码(VLSM)是指一个网络可以用不同的掩码进行配置,将一个网络(网络地址)划分为多个子网,提供更多的灵活性,同时保证在每个子网能够有足够数量的主机。

好处:可变长子网掩码缓解了使用缺省子网掩码导致的地址浪费问题;同时也为企业网络提供了更为有效的偏址方案。

原理:其实变长子网掩码和子网划分类似,一个ip地址的网络位,是通过ip地址与子网掩码进行“与”运算得到的。我们以C类ip地址192.168.1.1为例,C类ip地址的缺省子网掩码为:255.255.255.0,转化为二进制为11111111.11111111.11111111.00000000,可用主机位为2^8-2=254个。
所以可以通过向最后8位借位的方式,将整个192.168.1.0网段划分出更多的网段。但是为什么借位就能划分出更多的网段呢?
通过计算的方式,可以得到结果:

如果我们借1位会出现以下情况:

借1位后,子网掩码变成了11111111.11111111.11111111.10000000
255.255.255.128

(注:借位时只能从最高位开始借。)

此时,我们通过ip地址与子网掩码进行“与”运算的方式,计算192.168.1.1与192.168.1.129的网络位,如下图:

20240227-181330-fi.png
得出的结果转化为10进制 为:192.168.1.0与192.168.1.128,计算出来的结果不同,意味着这两个ip在修改子网掩码后,已经成为两个不同网段的ip地址了。

我们知道了子网掩码借位可以增加网段,相应的主机位会相应减少,具体是多少呢?又如何计算呢?
总结如下:

每当子网掩码借n位,就会将原网段划分为2^n个网段,主机位为2^(8-n) -2  (减2为减去该网段的网络地址与主机位)。

例如:借1位,原网段就会被划分为2^1=2个网段,主机位为2^(8-1)-2=126个。

此时,我们就可以根据需要的网段,需要的设备进行网段划分了。

举个例子:

主机一:192.168.124.7,子网掩码:255.255.255.192
主机二:192.168.124.100,子网掩码:255.255.255.192
通过计算网络地址,得到广播地址为:
主机一广播地址:192.168.124.63
主机二广播地址:192.168.124.127

因此该两个主题无法广播通信。

UDP核心API

API-DatagramSocket

  • 用于接收与发送UDP的类
  • 负责发送某一个UDP包,或者接收UDP包
  • 不同于TCP,UDP并没有合并到Socket API中
  • 因此UDP发送消息没有服务端和客户端,它既是服务端也是客户端

DatagramSocket构造方法

  • DatagramSocket()创建简单实例,不指定端口与IP
  • DatagramSocket(int port)创建监听固定端口的实例
  • DatagramSocket(int port, InetAddress localAddr)创建固定端口指定IP的实例

DatagramSocket常用方法

  • receive(DatagramPacket d):接收一个数据报文
  • send(DatagramPacket d):发送接收一个数据报文
  • setSoTimeout(int timeout):设置超时,毫秒
  • close():关闭、释放资源

API-DatagramPacket

  • 用于处理报文
  • 将byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成byte数组
  • 是UDP的发送实体,也是接收实体

DatagramPacket构造方法

  • DatagramPacket(byte buf[], int length, InetAddress address, int port):通常用于发送数据报文时使用,前2个参数指定buf的使用区间,后面2个参数指定目标机器的地址与端口.
  • DatagramPacket(byte[]buf,int offset, int length,InetAddress address,int port):通常用于发送数据报文时使用,前3个参数指定buf的使用区间,后面2个参数指定目标机器的地址与端口.
  • DatagramPacket(byte[buf,int length,SocketAddress address]):通常用于发送数据报文时使用,前2个参数指定buf的使用区间,SocketAddress 相当于InetAddress+Port.
  • DatagramPacket(byte buf[], int length) :通常用于接收数据报文时使用,参数用于指定buf和buf的长度.

DatagramPacket常用方法

  • setData(byte[]buf,int offset,int length):设置指定长度的数据
  • setData(byte[]buf):设置buf的完整数据
  • setLength(int length):设置buf数据的长度
  • getData():获取报文中的数据
  • getOffset():获取报文中数据buf的偏移量
  • getLength():获取报文中数据buf的长度
  • setAddress(InetAddress iaddr):设置目标地址(发送端用于设置数据报的接收端地址)
  • setPort(int port):设置目标端口(发送端用于设置数据报的接收端端口)
  • getAddress():获取目标地址(发送端地址)
  • getPort():获取目标端口(发送端端口)
  • setSocketAddress(SocketAddress adress):设置目标地址+端口
  • getSocketAddress():获取目标地址+端口

局域网搜索案例

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

步骤如下

  1. 新建一个消息生产和解析类
package cn.kt.SocketDemoL3;

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

}

  1. 新建消息提供者客户端
package cn.kt.SocketDemoL3;

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 {
        // 生成一份唯一标示
        String sn = UUID.randomUUID().toString();
        Provider provider = new Provider(sn);
        provider.start();

        // 读取任意键盘信息后可以退出
        //noinspection ResultOfMethodCallIgnored
        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();
        }

    }

}
  1. 新建消息搜寻者客户端
package cn.kt.SocketDemoL3;

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();

        // 读取任意键盘信息后可以退出
        //noinspection ResultOfMethodCallIgnored
        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;
        }
    }
}

运行结果:
提供者发送暗号
20240228-133900-FT.png

搜索者收到暗号
20240228-133939-2b.png


原文地址:https://blog.csdn.net/qq_42038623/article/details/136353706

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!