104-Java网络编程UDP极快入门、多发多收消息、广播、组播

一、UDP通信

1、UDP协议的特点

• UDP是一种 无连接、不可靠传输 的协议。
• 将数据源IP、目的地IP和端口以及数据封装成数据包，大小限制在64KB内，直接发送出去即可。

---

2、UDP协议通信模型演示

---

---

3、DatagramPacket：数据包对象（韭菜盘子）

---

DatagramPacket常用API

---

---

4、DatagramSocket：发送端和接收端对象（人）

---

DatagramSocket常用API

---

---

---

二、使用UDP通信实现：发送消息、接收消息

• 需求：客户端（发送端）实现步骤
  • 1、创建DatagramSocket对象（发送端对象）——>扔韭菜的人
  • 2、创建DatagramPacket对象封装需要发送的数据（数据包对象）——>韭菜盘子
  • 3、使用DatagramSocket对象的send方法传入DatagramPacket对象——>抛出韭菜
  • 4、释放资源
• 需求：服务端（接收端）实现步骤
  • 1、创建DatagramSocket对象（接收端对象）——>接韭菜的人
  • 2、创建DatagramPacket对象接收数据（数据包对象）——>韭菜盘子
  • 3、使用DatagramSocket对象的receive方法传入DatagramPacket对象——>接收抛过来的韭菜
  • 4、释放资源

---

package com.app.d2_udp1;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
    发送端（客户端）：负责发送数据给接收端（服务端）
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("=======客户端（发送端）启动========");
        // 1、创建发送端的Socket对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket();

        // 2、创建发送端的packet数据包对象（韭菜盘子）
        /**
            public DatagramPacket(byte buf[], int length,
            InetAddress address, int port)
            参数一：封装要发送的数据（韭菜）
            参数二：发送数据的大小
            参数三：接收端（服务端）的主机IP地址
            参数四：接收端（服务端）的端口号
         */
        byte[] buffer = "我是一串快乐的韭菜，你愿意吃吗？".getBytes();
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length,
                InetAddress.getLocalHost(), 8888);

        // 3、发送数据出去
        socket.send(packet);

        // 4、数据发送出去后，释放资源！！
        socket.close();
    }
}

package com.app.d2_udp1;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
    接收端（服务端）：负责接收发送端（客户端）发过来的数据
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("=======服务端（接收端）启动========");
        // 1、创建接收端的Socket对象：需要注册端口号（人）
        DatagramSocket socket = new DatagramSocket(8888);

        // 2、创建接收端的packet数据包对象（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];    // 1KB * 64 == 64KB
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 3、等待接收数据
        socket.receive(packet);

        // 4、读取多少倒出多少
        int len = packet.getLength();
        String rs = new String(buffer, 0, len);
        System.out.println("收到的数据是："   rs);

        // 5、接收完数据后，释放资源！
        socket.close();
    }
}

---

---

---

---

---

总结

1、UDP发送端和接收端的对象是哪个？

• public DatagramSocket()：创建发送端的Socket对象
• public DatagramSocket(int port)：创建接收端的Socket对象

2、数据包对象是哪个？

• DatagramPacket

3、如何发送、接收数据包？

• 使用DatagramSocket的如下API：
  • public void send(DatagramPacket p)：发送数据包
  • public void receive(DatagramPacket p)：接收数据包

4、拓展两个API

• getSocketAddress()：获取对方的IP地址

• getPort()：获取对方的端口号

---

---

---

---

三、使用UDP通信实现：多发多收消息

• 比如：
  • 爱奇艺网站就是一个服务端（接收端），每个用户都是客户端（发送端）；
  • 每个用户看到精彩的视频、电视剧、电影等，都会不由自主的发一些弹幕，此时就是多发消息；
  • 那么爱奇艺服务端就多收这些用户多发的消息。

---

1、需求

• 使用UDP通信方式开发接收端和发送端。

---

2、分析

• 发送端可以一直发送消息。
• 接收端可以不断的接收多个发送端的消息展示。
• 发送端输入了exit则结束发送端程序。

---

3、发送端实现步骤

• 创建DatagramSocket对象（发送端对象）：不指定端口时，自带默认端口——>抛韭菜的人
• 使用while死循环不断的接收用户的数据输入，如果用户输入的是exit则退出程序；
• 如果用户输入的不是exit，则将数据封装成DatagramPacket对象——>韭菜盘子
• 使用DatagramSocket对象的send方法将数据包对象进行发送——>抛出韭菜
• 释放资源

package com.app.d3_udp2;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
    发送端（客户端）
    需求：发送端可以一直发送消息，输入exit结束发送端程序。
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------客户端（发送端）启动------------------");
        // 1、创建DatagramSocket对象（发送端对象）：不指定端口时，自带默认的端口————>抛韭菜的人
        DatagramSocket socket = new DatagramSocket(5555);   // 指定发送端端口为5555

        // 2、创建键盘输入对象，用于发送弹幕
        Scanner sc = new Scanner(System.in);

        // 3、使用while死循环不断的接收用户的数据输入
        while (true){
            System.out.println("请您输入一条弹幕：");
            String data = sc.nextLine();

            // 判断条件：用户一旦输入exit，则结束发送
            if (data.equals("exit")) {
                System.out.println("您已离线！！");
                // 4、用户输入exit，结束发送后，释放资源
                socket.close();
                break;
            }

            // 5、创建字节数组，用于存储用户输入的弹幕
            byte[] buffer = data.getBytes();

            // 6、用户输入的不是exit，将数据封装成DatagramPacket对象————>韭菜盘子
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length,
                    InetAddress.getLocalHost(), 9999);

            // 7、使用DatagramSocket对象的send方法将数据包对象进行发送————>抛出韭菜
            socket.send(packet);
        }
    }
}

---

4、接收端实现步骤

• 创建DatagramSocket对象（接收端对象）：必须指定端口——>接韭菜的人
• 创建DatagramPacket对象（数据包对象）——>韭菜盘子
• 使用while死循环不断调用DatagramSocket对象的receive方法传入DatagramPacket对象——>接住抛过来的韭菜
• 每接收到一条弹幕消息，展示出来

package com.app.d3_udp2;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
    接收端（服务端）
    需求：接收端可以不断的接收多个发送端的消息展示
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------服务端（接收端）启动------------------");
        // 1、创建DatagramSocket对象（接收端对象）：必须指定端口————>接韭菜的人
        DatagramSocket socket = new DatagramSocket(9999);

        // 2、创建字节数组
        byte[] buffer = new byte[1024 * 64];    // 64KB

        // 3、创建DatagramPacket对象（数据包对象）————>韭菜盘子
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 5、使用while死循环不断调用DatagramSocket对象的receive方法传入DatagramPacket对象————>接住抛过来的韭菜
        while (true) {
            socket.receive(packet);

            // 读取多少倒出多少
            int len = packet.getLength();
            // 6、每接收到一条弹幕消息，展示出来
            String rs = new String(buffer, 0, len);
            System.out.println(rs);
        }
    }
}

---

---

5、IDEA并发执行实例

---

（1）设置IDEA工具可以支持并发执行实例

---

---

---

---

---

---

---

---

---

总结

1、UDP的接收端为什么可以接收很多发送端的消息？

• 因为接收端只负责接收数据包，无所谓是哪个发送端的数据包。

---

---

---

四、UDP的三种通信方式

• 单播：单台主机与单台主机之间的通信。

• 广播：当前主机与所在网络中的所有主机通信。

• 组播：当前主机与选定的一组主机的通信。

  

---

1、UDP如何实现广播

• 使用广播地址：255.255.255.255
• 具体操作：
  • 发送端发送的数据包的目的地写的是广播地址、且指定端口。（255.255.255.255, 9999）
  • 本机所在网段的其他主机的程序只要匹配端口成功就能收到消息了。（9999）

package com.app.d4_udp3_broadcast;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
    发送端（客户端）
    需求：发送端可以一直发送消息，输入exit结束发送端程序。
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------客户端（发送端）启动------------------");
        // 1、创建DatagramSocket对象（发送端对象）：不指定端口时，自带默认的端口————>抛韭菜的人
//        DatagramSocket socket = new DatagramSocket(5555);   // 指定发送端端口为5555
//        DatagramSocket socket = new DatagramSocket(6666);
        DatagramSocket socket = new DatagramSocket(7777);

        // 2、创建键盘输入对象，用于发送弹幕
        Scanner sc = new Scanner(System.in);

        // 3、使用while死循环不断的接收用户的数据输入
        while (true){
            System.out.println("请您输入一条弹幕：");
            String data = sc.nextLine();

            // 判断条件：用户一旦输入exit，则结束发送
            if (data.equals("exit")) {
                System.out.println("您已离线！！");
                // 4、用户输入exit，结束发送后，释放资源
                socket.close();
                break;
            }

            // 5、创建字节数组，用于存储用户输入的弹幕
            byte[] buffer = data.getBytes();

            // 6、用户输入的不是exit，将数据封装成DatagramPacket对象————>韭菜盘子
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length,
                    InetAddress.getByName("255.255.255.255"), 9999);

            // 7、使用DatagramSocket对象的send方法将数据包对象进行发送————>抛出韭菜
            socket.send(packet);
        }
    }
}

package com.app.d4_udp3_broadcast;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
    接收端（服务端）
    需求：接收端可以不断的接收多个发送端的消息展示
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------服务端（接收端）启动------------------");
        // 1、创建DatagramSocket对象（接收端对象）：必须指定端口————>接韭菜的人
        DatagramSocket socket = new DatagramSocket(9999);

        // 2、创建字节数组
        byte[] buffer = new byte[1024 * 64];    // 64KB

        // 3、创建DatagramPacket对象（数据包对象）————>韭菜盘子
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 5、使用while死循环不断调用DatagramSocket对象的receive方法传入DatagramPacket对象————>接住抛过来的韭菜
        while (true) {
            socket.receive(packet);

            // 读取多少倒出多少
            int len = packet.getLength();
            // 6、每接收到一条弹幕消息，展示出来
            String rs = new String(buffer, 0, len);
            System.out.println(rs);
        }
    }
}

---

---

2、UDP如何实现组播

• 使用组播地址：224.0.0.0 ~ 239.255.255.255
• 具体操作：
  • 发送端的数据包的目的地是组播IP（例如：224.0.0.1, 端口：9999）。
  • 接收端必须绑定该组播IP(224.0.0.1)，端口还要对应发送端的目的端口9999，这样即可接收该组播消息。
  • DatagramSocket的子类MulticastSocket可以在接收端绑定组播IP。

package com.app.d5_udp4_multicast;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
    发送端（客户端）
    需求：发送端可以一直发送消息，输入exit结束发送端程序。
 */
public class ClientDemo1 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------客户端（发送端）启动------------------");
        // 1、创建DatagramSocket对象（发送端对象）：不指定端口时，自带默认的端口————>抛韭菜的人
//        DatagramSocket socket = new DatagramSocket(5555);   // 指定发送端端口为5555
//        DatagramSocket socket = new DatagramSocket(6666);
        DatagramSocket socket = new DatagramSocket(7777);

        // 2、创建键盘输入对象，用于发送弹幕
        Scanner sc = new Scanner(System.in);

        // 3、使用while死循环不断的接收用户的数据输入
        while (true){
            System.out.println("请您输入一条弹幕：");
            String data = sc.nextLine();

            // 判断条件：用户一旦输入exit，则结束发送
            if (data.equals("exit")) {
                System.out.println("您已离线！！");
                // 4、用户输入exit，结束发送后，释放资源
                socket.close();
                return;
            }

            // 5、创建字节数组，用于存储用户输入的弹幕
            byte[] buffer = data.getBytes();

            // 6、用户输入的不是exit，将数据封装成DatagramPacket对象————>韭菜盘子
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length,
                    InetAddress.getByName("224.0.1.1"), 9999);

            // 7、使用DatagramSocket对象的send方法将数据包对象进行发送————>抛出韭菜
            socket.send(packet);
        }
    }
}

package com.app.d5_udp4_multicast;

import java.net.*;

/**
    接收端（服务端）
    需求：接收端可以不断的接收多个发送端的消息展示
 */
public class ServerDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("------------------服务端（接收端）启动------------------");
        // 1、创建DatagramSocket对象（接收端对象）：必须指定端口————>接韭菜的人
        MulticastSocket socket = new MulticastSocket(9999);

        // 把当前接收端加入到一个组播组中：绑定对应的组播消息的组播IP
        // jdk14开始淘汰了此API，但是在企业中还是可以使用的，因为企业中还用不到这么新的jdk版本
        socket.joinGroup(InetAddress.getByName("224.0.1.1"));
//        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1"), 9999),
//                NetworkInterface.getByInetAddress(InetAddress.getLocalHost())); // 新API，了解一下

        // 2、创建字节数组
        byte[] buffer = new byte[1024 * 64];    // 64KB

        // 3、创建DatagramPacket对象（数据包对象）————>韭菜盘子
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 5、使用while死循环不断调用DatagramSocket对象的receive方法传入DatagramPacket对象————>接住抛过来的韭菜
        while (true) {
            socket.receive(packet);

            // 读取多少倒出多少
            int len = packet.getLength();
            // 6、每接收到一条弹幕消息，展示出来
            String rs = new String(buffer, 0, len);
            System.out.println(rs);
        }
    }
}

---

---

总结

1、如何实现广播，具体怎么操作？

• 发送端目的IP使用广播IP：255.255.255.255，端口：9999。
• 所在网段的其他主机对应了端口（9999）即可接收消息。

2、如何实现组播，具体怎么操作？

• 发送端目的IP使用组播IP，且指定端口。
• 所在网段的其他主机注册了该组播IP和对应端口即可接收消息。

这篇好文章是转载于：学新通技术网