项目开发中，有个需求是接收udp的组播信息，获取帧并解析其中的内容。之前没有接触过udp的通讯以及数据帧。查阅资料对udp的通讯间的发送与接收实现记录如下。

UDP有三种通讯方式，分别是，单播 、广播、还有组播。

1. 单播: 单机与单机之间的通讯

2. 广播: 当前主机与所在网络中的所有主机通讯

3. 组播: 当前主机与选定的一组主机通讯

一、单播

• 发送端代码

public class UdpServer {
    /**
     * 发送端
     */
    public static void main(String[] args) throws Exception {
        System.out.println("=============发送端启动===========");
        // 1.创建发送端对象 参数是绑定本地地址和一个特定的端口号
        DatagramSocket socket = new DatagramSocket(6666);

        // 2.创建一个数据包对象封装数据
        /**
         * 参数1:封装要发送的数据
         * 参数2:发送数据的大小
         * 参数3:服务端的IP地址
         * 参数4:服务端的端口
         */
        byte[] bytes = "这是一条yyt的测试数据".getBytes();
        InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
        int port = 8888 ;
        DatagramPacket packet = new DatagramPacket(bytes,bytes.length, inetAddress,port);

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

        // 4.关闭管道
        socket.close();
    }
}

• 接收端代码

public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("=============客户端启动===========");

        // 1.创建接受对象  参数是绑定本地地址和一个特定的端口号
        DatagramSocket socket = new DatagramSocket(8888);

        // 2.创建一个数据包接收数据
        byte [] bytes = new byte[1024];
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);

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

        // 4.取出数据
        int len = packet.getLength();
        String rs = new String(bytes,0,len);
        System.out.println("收到的数据:" + rs);
        // 获取发送端的ip和端口
        String ip = packet.getSocketAddress().toString();
        System.out.println("发送端的IP地址: " + ip);

        int port = packet.getPort();
        System.out.println("发送端端口为: "+port);

        // 关闭管道
        socket.close();
    }
}

二、广播

1. 发送广播消息需要使用广播地址: 255.255.255.255

2. 发送端的数据包的目的地址是广播地址+指定端口号(255.255.255.255,9999)

3. 本机所在网段的其他主机只要匹配到端口即可接受消息(9999)

• 发送端代码

public class UdpSend {
    /**
     * 发送端
     */
    public static void main(String[] args) throws Exception {
        System.out.println("=============发送端启动===========");
        // 1.创建发送端对象
        DatagramSocket socket = new DatagramSocket(6666);
        // 下面通过键盘输入测试，按需读取文件等操作自己修改
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入您要发送的消息: ");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("退出成功!");
                socket.close();
                break;
            }

            // 2.创建一个数据包对象封装数据
            byte[] buffer = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer,buffer.length, InetAddress.getByName("255.255.255.255"),9999);

            // 3.发送数据
            socket.send(packet);
        }
    }
}

• 接收端代码

public class UdpReceive {
    /**
     * 接收端
     */
    public static void main(String[] args) throws Exception {
        System.out.println("=============客户端启动===========");

        // 1.创建接受对象
        DatagramSocket socket = new DatagramSocket(9999);

        // 2.创建一个数据包接收数据
        byte [] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        while (true) {

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

            // 4.取出数据
            int len = packet.getLength();
            String rs = new String(buffer,0,len);
            System.out.println("收到来自: "+ packet.getAddress()+ ",对方端口号为: "+ packet.getPort()+"的消息: " + rs);
        }
    }
}

三、组播

1. 使用组播地址: 224.0.0.0~239.255.255.255

2. 发送端的数据包的目的目的地址是组播ip(224.0.1.1,6000)

3. 接收端必须绑定该组播ip(224.0.1.1),端口还要对应发送端的目的端口(6000)

• 发送端代码

public class UdpGroupServer {

    public boolean closed = false;
    public String ip = "224.0.0.1";//组播虚拟地址
    public int port = 6000;//组播Ip
    public int MessageIndex = 0;
    // 项目的需求需要我接收数据通过websocket发送给前端 这里我开启一个线程执行其他类定时任务调用该方法
    public void start(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("UdpTestServer start ");
                runServer();
            }
        }).start();
    }

    private void runServer(){
        // 这里真正是接收组播数据的地方
        try {
            InetAddress group = InetAddress.getByName(ip);
            MulticastSocket s = new MulticastSocket(port);
            byte[] arb = new byte[1024];
            s.joinGroup(group);//加入该组
            while(!closed){
                send();
                DatagramPacket datagramPacket =new DatagramPacket(arb,arb.length);
                s.receive(datagramPacket);
                System.out.println("received packet from " + datagramPacket.getAddress().getHostAddress() + " : " + datagramPacket.getPort());
                System.out.println(new String(arb));
                Thread.sleep(2000);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("UdpTestServer run Exception: "+e.toString());
        }
    }




    public void send(){
        try{
            String sendMessage="hello ,message from server,"+MessageIndex++;
            byte[] message = sendMessage.getBytes(); //发送信息
            InetAddress inetAddress = InetAddress.getByName(ip); //指定组播地址
            DatagramPacket datagramPacket = new DatagramPacket(message, message.length, inetAddress, port); //发送数据包囊
            MulticastSocket multicastSocket = new MulticastSocket();//创建组播socket
            multicastSocket.send(datagramPacket);
        }catch (Exception e) {
            System.out.println("UdpTestServer send Exception: "+e.toString());
        }

        if(MessageIndex>=50){
            closed = true;
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        UdpGroupServer server = new UdpGroupServer();
        server.start();
    }

• 接收端代码

public class UdpGroupClient {

    Logger logger = LoggerFactory.getLogger(UdpGroupClient.class);

    private int MessageIndex = 0;
    private String ip = "224.0.0.1";//组播地址
    private int port = 6000;//指定数据接收端口
    private boolean closed = false;

    Map<String,Object> map = new HashMap();
    // 开启线程实时推送websocket数据   只接收数据的话不用看这部分
    public void start() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("UpdGroupClient start ");
                runClient();
            }
        }).start();
    }

    MulticastSocket socket = null;

    public void runClient() {
        try {
            byte[] receiveBuffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
            InetAddress group = InetAddress.getByName(ip);
            socket = new MulticastSocket(port);
            socket.joinGroup(group);//加入组播地址
            while (!closed) {
                socket.receive(receivePacket);
                System.out.println("received packet from " + receivePacket.getAddress().getHostAddress() + " : " + receivePacket.getPort());
                String msg = new String(receivePacket.getData(), receivePacket.getOffset(), receivePacket.getLength());
                receiveBuffer = receivePacket.getData();
                //  以上是接收的数据，下面是我解析数据帧的内容  就不具体展示了 
                Map map = new HashMap();
             XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
                // 将解析结果通过websocket发送给前端
                    WebSocketServer.sendInfo(JSONObject.toJSON(map).toString(),"1");
                    System.out.println("map长度"+map.size());
                    System.out.println("*******************"+ JSONObject.toJSON(map).toString());
                }else {
                    logger.info("数据包有错！");
                }
                Thread.sleep(2000);
            }
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

四、UDP帧结构

UDP 头定义，共 8 个字节 所以解析数据时一般从第八个字节开始解析自己要取的数据

源端口、目的端口、udp长度、udp校验和占了八个字节。

根据自己需求判断udp是否正确。

以上就是对udp三种通讯方式的简单总结，初步使用，如有错误还望指正。