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

UDP相关概念
- UDP是什么
- 为什么不可靠
- UDP能做什么
- UDP包最大长度
UDP单播、广播、多播概念
- 1. 单播、广播、多播模型图
- 2. ip地址分类
- 3. 子网掩码的作用：
- 4. 广播地址
- 5. 网段划分
- 6. 变长子网掩码
UDP核心API
- API-DatagramSocket
- - Api方法（构造方法）
- API-DatagramPacket
- - API-DatagramPacket（常用方法）
- 局域网搜索案例

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

UDP单播、广播、多播概念

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

2. ip地址分类

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的网络位，如下图：

得出的结果转化为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发送消息没有服务端和客户端，它既是服务端也是客户端

Api方法（构造方法）

DatagramSocket()创建简单实例，不指定端口与IP
DatagramSocket(int port)创建监听固定端口的实例
DatagramSocket(int port, InetAddress localAddr)创建固定端口指定IP的实例
receive(DatagramPacket d):接收
send(DatagramPacket d):发送
setSoTimeout(int timeout):设置超时，毫秒
close():关闭、释放资源

API-DatagramPacket

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

API-DatagramPacket（常用方法）

DatagramPacket(byte[] buf, int offset, int length, InetAddressaddress, int port)
前面3个参数指定buf的使用区间
后面2个参数指定目标机器地址与端口
DatagramPacket(byte[] buf, int length, SocketAddressaddress)
前面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)
getAddress()、getPort()
setSocketAddress(SocketAddress address)
getSocketAddress()

局域网搜索案例

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

步骤如下

新建一个消息生产和解析类

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

}

新建消息提供者客户端

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

    }

}

新建消息搜寻者客户端

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