（四） Socket——UDP快速入门

最新推荐文章于 2021-07-08 11:40:51 发布
最新推荐文章于 2021-07-08 11:40:51 发布
阅读量291 收藏
点赞数
分类专栏： socke编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39288090/article/details/98394163
版权

1、UDP是什么

  • Internet 协议集支持一个无连接的传输协议，该协议称为用户数据报协议，又称用户数据报文协议，基于报文的协议（不同于TCP面向链接的协议）
  • 是一种简单的面向数据报的传输层协议，正式规范RFC 768，提供面向事务的简单不可靠信息传送服务

为什么不可靠

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

UDP能做什么

  • DNS、TFTP、SNMP
  • 视频、音频、普通数据（无关紧要数据）

2、UDP核心API讲解

API-DatagramSocket

  • 此类表示用来发送和接收数据包的套接字，数据报套接字是包投递服务的发送或接收点
  • 负责发送某一个UDP包，或者接收UDP包
  • 不同于TCP，UDP并没有合并到Socket API中（UDP中没有区分客户端和服务器，DatagramSocket即是客户端也是服务端，可以发送也可以接收，不需要连接）
  • DatagramSocket()创建简单实例，不指定端口与IP（使用它发送，他会自动赋予本地可用端口进行发送数据）
  • DatagramSocket( int port)创建监听固定端口的实例
  • DatagramSocket( int port，InetAddress localAddr)创建固定端口制定IP的实例

3、UDP单播、广播、多播

广播地址

4、局域网搜索案——A向B发送信息

  • 4.1、实现UDP接收消息并回送功能

UDP提供者代码：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/**
 * UDP提供者，用于提供服务
 */
public class UDPprovider {
    public static void main(String[] args) throws IOException {
        System.out.println("UDPProvider started.");
        //作为接受者，制定一个端口用于数据接收
        DatagramSocket ds = new DatagramSocket(20000);
        //构建接受实体
        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);
        //构建一份回送数据
        String responseData="\nreceive data with len:"+dataLen;
        //构建回送消息的实体
        byte[] responseDataBytes=responseData.getBytes();
        //直接根据发送者构建一份回送信息
        DatagramPacket responsePacket =new DatagramPacket(responseDataBytes,
                responseDataBytes.length,
                receivePack.getAddress(),
                receivePack.getPort());
        ds.send(responsePacket);
        //完成
        System.out.println("UDPProvider finished.");
        ds.close();
    }
}

UDP搜索者代码：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
 * UDP搜索者用于搜索支持方
 */
public class UDPsearcher {
    public static void main(String[] args) throws IOException {
        System.out.println("UDPseacher started.");
        //作为搜索方，让系统自动分配端口
        DatagramSocket ds = new DatagramSocket();
        //构建一份请求数据
        String requestData="helloworld!";
        //构建回送消息的实体
        byte[] requestDataBytes=requestData.getBytes();
        //直接构建packet
        DatagramPacket requestPacket =new DatagramPacket(requestDataBytes,requestDataBytes.length);
        //本机端口20000
        requestPacket.setAddress(InetAddress.getLocalHost());
        requestPacket.setPort(20000);
        //发送
        ds.send(requestPacket);
        //构建接受实体
        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("UDPseacher receive form ip:"+ip+"\tport:"+port+"\tdata:"+data);
        //完成
        System.out.println("UDPseacher finished.");
        ds.close();
    }
}

5、局域网搜索案例——A向局域网内所有设备发送信息

  • UDP局域网广播发送的实现
  • UDP局域网回送消息的实现
  • A作为提供者，B作为接收者

UDP提供者，用于提供服务

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();
        //读取任意键盘信息后可以退出
        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;
        }
        //Intellij Idea get/set/Override方法快捷键Alt+Insert,或直接ctrl+o
        @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 e){ //这个异常可以忽略
            }finally {
                close();
            }
            //完成
            System.out.println("UDPProvider finished.");
        }
        private  void close(){//socket进行结束操作
            if(ds!=null){
                ds.close();
                ds=null;
            }
        }
        /**
         * 提供结束
         */
        void exit(){
            done=true;
            close();
        }
    }
}

消息创建者，具备两个口令，一个搜索口令，一个回送口令

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搜索者用于搜索支持方

import java.io.IOException;
import java.net.*;
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("UDPseacher started.");
        Lisener listener = listen();//开始一个监听
        sendBroadcast();//监听之后发送一个广播
       /* //作为搜索方，让系统自动分配端口
        DatagramSocket ds = new DatagramSocket();
        //构建一份请求数据
        String requestData="helloworld!";
        //构建回送消息的实体
        byte[] requestDataBytes=requestData.getBytes();
        //直接构建packet
        DatagramPacket requestPacket =new DatagramPacket(requestDataBytes,requestDataBytes.length);
        //本机端口20000
        requestPacket.setAddress(InetAddress.getLocalHost());
        requestPacket.setPort(20000);
        //发送
        ds.send(requestPacket);
        //构建接受实体
        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("UDPseacher receive form ip:"+ip+"\tport:"+port+"\tdata:"+data);*/
        //ds.close();
        //读取任意键盘信息后可以退出
        System.in.read();
        List<Device> devices = listener.getDevicesAndClose();//结束之前拿到设备信息，从监听器中拿我们的设备信息
        for (Device device : devices) {//拿到设备之后，打印设备信息
            System.out.println("Device:"+device.toString());
        }
        //完成
        System.out.println("UDPseacher finished.");
    }
    //监听方法
    private static Lisener listen() throws InterruptedException {//监听方法
        System.out.println("UDPseacher start listen.");
        CountDownLatch countDownLatch=new CountDownLatch(1);
        Lisener lisener=new Lisener(LISTEN_PORT,countDownLatch);
        lisener.start();//启动操作
        countDownLatch.await();//等待启动完成
        return lisener;
    }
    //发送广播的方法
    public static void sendBroadcast() throws IOException {//发送广播的方法
        System.out.println("UDPseacher 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("UDPseacher sendBroadcast finished.");
    }
    private  static  class Device{//设备类信息
        final int port;//端口
        final String ip;
        final String sn;
        //三者都是必须要的东西，因此加上final
        private Device(int port, String ip, String sn) {
            this.port = port;
            this.ip = ip;
            this.sn = sn;
        }
        //同时构建一个tostring方法：快捷键Alt+Insert选择tostring（）再点击OK
        @Override
        public String toString() {
            return "Device{" +
                    "port=" + port +
                    ", ip='" + ip + '\'' +
                    ", sn='" + sn + '\'' +
                    '}';
        }
    }
    private  static  class  Lisener extends  Thread{
        private  final  int listenPort;//需要传入的端口号
        private  final CountDownLatch countDownLatch;//让外面感知到已经开始监听了
        private  final List<Device> devices=new ArrayList<>();//设备链表
        private  boolean done=false;//结束符，默认为false
        private  DatagramSocket ds=null;//搜索者
        public Lisener(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("UDPseacher receive form ip:"+ip+"\tport:"+port+"\tdata:"+data);
                    //解析操作，解析sn
                    String sn=MessageCreator.parseSn(data);
                    if(sn!=null){
                        Device device=new Device(port,ip,sn);//传入新设备端口号、ip及sn信息
                        devices.add(device);//sn解析成功，设备链表增加一个新的设备
                    }
                }
            }catch (Exception e){
            }finally {
                close();
            }
            System.out.println("UDPseacher listener finished");
        }
        private  void close(){
            if(ds!=null){
                ds.close();
                ds=null;
            }
        }
        List<Device>getDevicesAndClose(){//拿并关闭的操作
            done=true;
            close();
            return devices;
        }
    }
}

运行结果：
首先要打开提供方，再打开搜索方
在这里插入图片描述在这里插入图片描述
在搜索方输入任意字符结束搜索和提供方：
在这里插入图片描述在这里插入图片描述

qq_39288090
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SuperSocket基础一
weixin_30306905的博客
08-18 369
SuperSocket基础(一)——————基本概念 项目中之前一直使用TCPsocket服务框架，但是不利于扩展。最近刚接触到开源的superSocket感觉很不错，特记录一下。官方开源地址：http://www.supersocket.net/ 基本概念： SuperSocket：是一个可扩展的Socket开源框架，是一个轻量级、跨平台而且可扩展的.Net...
SuperSocket-master_Socket基于TCP、UDP
06-27
SuperSocket-master_Socket 、Socket、SuperSocket、TCP、UDP
SupperSocket深入浅出（一）
ba_wang_mao的专栏
07-08 1173
花了几天时间了解了SupperSocket工作原理，各种类之间的工作关系。SupperSocket大部资料网上都有，但写的都不适合初学者。 今天花点时间写下这几天的学习成果，一方面是为了将来更好的回顾知识点，另一方面想给初学者提供一份参考资料。考虑到笔功有限，如果下面有什么信息不正确或写的不好，请大家多多包容！ 首先我贴一简单的代码。后面我会详细的说明工作原理和他们之间如何调用！下面的代码我也是从网上找的，相当简单。 我今天主要是讲解下我...
基于superSocket——AForge的UDP传输摄像案例——服务端
追风筝的摆渡人
07-23 3195
服务端 业务逻辑： 准备操作： 用superSocket接受客户端发来的UDP数据， superSocket开源框架网址：https://github.com/kerryjiang/SuperSocket。 在NuGet中添加：SuperSocket,SuperSocket.Engine,SuperSocket.ProtoBase 用FFMPEG、V...
TCP/IP和UDP的入门实例——基于MFC
08-29
基于MFC开发的TCP/IP的客户端和服务器与UDP开发的客户端和服务器，能实现文字的发送与接收，入门级别请入！VS2013，SOCKET类，不过现在很多都用CSOCKET类的CAsynSocket类，个人不是很了解，所以没有用！
Python项目案例开发从入门到实战源代码第14章 网络通讯案例——基于UDP的网络五子棋.rar
01-03
在Python中，我们可以使用socket模块来实现UDP通信。socket模块提供了创建、配置和操作套接字的功能。首先，我们需要创建一个socket对象，指定其协议类型为SOCK_DGRAM，这代表UDP协议。然后，我们可以绑定IP地址和...
socket编程入门(经典版
09-14
### Socket编程入门(经典版) #### 1. 预备知识 在开始学习socket编程之前，我们需要了解一些基础知识，这些知识对于理解socket的工作原理至关重要。 ##### 1.1 网络字节序 在计算机网络通信中，数据是以流的形式...
Win32 Socket API网络编程入门演示程序
11-02
**Win32 Socket API网络编程入门演示程序** 在IT领域，网络编程是构建分布式系统、实现客户端-服务器通信的关键技术。对于Windows操作系统，Win32 Socket API（也称为Winsock）是开发网络应用程序的主要接口。这个...
Java SE编程入门教程 java网络编程（共29页）.pptx
12-04
TCP/IP模型的四层结构——应用层、传输层、网络层和链路层，为网络通信提供了结构化的框架。在Java编程中，理解这些层次的作用对于编写网络应用程序至关重要，因为不同的层负责处理不同层面的问题，比如应用层的HTTP...
IP校验和和UDP校验和代码
12-31
IP和UDP检验和代码，可以过课设的！简单易懂，就是源代码！
UDP头部结构，UDP校验和计算
热门推荐
yueyadao的博客
12-16 1万+
Udp:用户数据报协议 特点: 1.无连接,传输数据时不需要建立链接 2.尽最大努力传输,不可靠 3.面向报文的,接收到应用程序的数据时,只往数据前面加一个UDP头部就传给网络层，收到网络层传来的UDP数据时，只把UDP头部去掉就扔给应用层进程。不论数据大小都是一次发送。 4.没有拥塞控制，不管链路的畅通情况，都以不变的速率发送报文。 5.UDP支持一对一，一对多，多对一，多对多的交互通信 6.U...
UDP Socket编程
nature_XD的专栏
08-05 818
UDP编程的服务器端一般步骤是： 1、创建一个socket，用函数socket()； 3、绑定IP地址、端口等信息到socket上，用函数bind(); 4、循环接收发送数据，用函数recvfrom()、sendto(); 5、关闭网络连接； UDP编程的客户端一般步骤是： 1、创建一个socket，用函数socket()； 2、设置对方的IP地址和端口等属性; 3、连接服
【套接字编程】UDP协议详解
qq_43676757的博客
04-04 1377
【套接字编程】UDP协议（详解 + 实现） 前言： 传输层协议场景：通信中客户端与服务端进行交互 客户端：主动发起请求的一端 服务端：被动接受请求的一端 传输层协议的分类与选择 tcp协议/udp协议 两种协议的区别（面试常考） tcp协议（传输控制协议） 特点：面向连接，可靠传输，面向字节流 常用于对安全可靠性要求高于对性能要求的程序。例如:文件传输 udp协议（用户数据报协议） 特点：无连接，...
计算udp校验和例子_UDP 协议校验和计算
weixin_33945547的博客
01-14 1455
UDP 协议不具备差错恢复机制，但能通过校验和判断网络传输是否出现丢包。UDP 的校验和由三部分内容求和得到，分别是伪首部、首部以及数据报文，如下图所示为了弄清楚这些字段究竟是什么东西，下面我们使用 wireshark 来抓取一个 UDP 包来详细分析。为了制造这个 UDP 包，使用如下代码来向某 ip 地址发送一段数据(这个 ip 不一定非得实际存在，我们只需要观察基于 UDP 协议封装的数据，...
udp组播示例(发送、接收)
哦，原来你也在这里。
09-01 2510
原因不多说，目录结构扁平， data.h如下： #pragma once #include <cstring> #include <cstdint> #include <sys/types.h> #define MULTICAST_IP "234.0.0.1" #define MULTICAST_PORT 28928 #pragma pack(1) typedef struct price { int64_t mantissa; int64_
socket--TCP和UDP(笔记)
灰猫
03-08 667
UDP 什么是UDP 一种用户数据协议,又称用户数据报文协议 是一个简单的面向数据报的传输层协议,正式规范为TFC 768 用户数据协议、非连接协议 不可靠 它一旦把到数据应的数据发送出去，就不保留数据备份。 UDP在IP数据报的头部仅仅加入了复用的数据校验 结构简单、无校验、速度快、容易丢包、可广播 16位->2字节存储长度信息共65535 自身占用8字节，数据传入...
Linux下的C语言Socket编程初学者指南
本文档旨在为初学者提供一个关于C语言进行socket编程的入门指南。首先，作者介绍了socket编程可能会遇到的挑战，并表示已将这些经验整理出来，以帮助读者更好地理解和应用。文档明确指出，其目标读者是那些对C语言有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值