Socket编程---UDP篇

已于 2024-08-30 16:33:50 修改
阅读量515 收藏 6
点赞数 15
分类专栏： Linux 文章标签： udp 网络协议 网络
于 2024-08-30 16:03:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75172965/article/details/141002780
版权

目录

一.   UDP协议

二.   Socket编程

2.1   sockaddr家族 

2.2   接口介绍 

三.   服务端实现

四.   服务端调用实现

五.   客户端实现

六.   效果展示

一.   UDP协议

何为UDP协议的含义，上篇粗略提及了一下TCP与UDP的区别：

TCP：

• 传输层协议

• 有连接

• 可靠传输

• 面向字节流

UDP：

• 传输层协议

• 无连接

• 不可靠传输

• 面向数据报

那何为可靠，何为不可靠呢？

 TCP协议是有连接的。如果两台主机想要建立通信，就必须先建立连接，通过三次握手（后续博客会讲到）建立连接，只有当连接成功后，才能进行通信。

TCP可靠性体现在：如果数据在传输过程中出现了丢包等等情况，会有相应的解决方法。

TCP可靠性实现方法：

  1. 确认和重传： TCP 使用确认和重传机制来确保数据的完整性和可靠性。接收方会发送确认（ACK）给发送方，告知已成功接收到数据，如果发送方未收到确认，会重新发送数据。
  2. 序号和顺序控制： TCP 会为每个数据段分配一个序号，并且在接收端按序重组数据，以确保数据包按正确的顺序交付。
  3. 流量控制： TCP 使用滑动窗口协议进行流量控制，确保发送方和接收方之间的数据传输速率合理，避免了数据包的过载和丢失。
  4. 拥塞控制： TCP 还实现了拥塞控制机制，通过动态调整发送速率来避免网络拥塞，以提高整体网络性能和稳定性。

UDP协议是无连接的，也就是会说，UDP通信时，无需等待建立连接，只需拿到对应通信主机的端口号+IP地址，就能唯一确定一个进程，实现通信。

 UDP不可靠机制：

UDP 不提供数据传输的确认、重传、排序等机制。如果发送端发送了数据包，不会收到接收端的确认。因此，如果一个数据包在传输中丢失或损坏，UDP 不会重传数据，接收方也无法得知数据包的丢失。

 但是，并不是说，TCP就是百利而无一害的。前面说了，TCP还有一个特性---面向字节流，这就导致了，目标主机读取到的内容可能并不是完整的源主机发送的内容。后续讲TCP实现的时候会体现出来。

二.   Socket编程

2.1   sockaddr家族 

此处我们再次引用一张图：

  • sockaddr_in结构体是用于跨网络通信的
  • sockaddr_un结构体是用于本地通信的

 为了让套接字的网络通信和本地通信能够使用同一套函数接口,于是就出现了sockaddr结构体,该结构体与sockaddr_in和sockaddr_un的结构都不相同,但这三个结构体头部的16个比特位都是一样的,这个字段叫做协议簇。

这样好处就是：

  • socket编程涉及到的接口函数传参时，只需统一传sockaddr类型的参数即可。
  • 此时通过sockaddr结构体，将套接字网络通信和本地通信在参数方面统一

注意事项：

在进行网络通信编程时，统一定义的还是sockaddr_in结构体，只不过在调用接口时需要将sockaddr_in结构强转位sockaddr类型。

2.2   接口介绍 

  • socket创建套接字
int socket(int domain, int type, int protocol);

参数说明：

1.domin：创建套接字的域或者叫做协议家族,也就是创建套接字的类型(指定通信所用到的协议家族)

相当于sockaddr结构的前16个位的内容。

如果是本地通信就选择AF_UNIX，如果是网络通信就选择AF_INET（IPV4）或者AF_INET6（IPV6），此处我们UDP通信由于是通过网络通信，所以选择AF_INET即可。后面TCP通信也是选择AF_INET。

2.type：创建套接字时所需的服务类型(指定具体的通信协议)

  • 如果是UDP通信，选择SOCK_DGRAM（用户数据报服务），UDP是面向数据报的。
  • 如果是TCP通信，选择SOCK_STREAM（流式套接字），TCP是面向字节流的。

3.protocol：创建套接字的协议类别

此处可以指明是UDP通信还是TCP通信，但是一般设置为0，表示默认。系统会自动根据前两个参数推导出是UDP通信还是TCP通信。

 返回值：

成功的话会返回打开的文件描述符。

注意事项：

  • socket函数属于系统调用接口。
  • socket函数是被进程调用的。
  • bind绑定
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

 参数说明：

1.sockfd：绑定的文件的文件描述符

我们调用socket函数后，会返回一个文件描述符，这里就需要绑定这个文件描述符。通信就依赖于这个文件描述符。sockfd是全双工的，既可以收数据，又可以发数据。

2.addr：一个包含自身网络信息的结构体

我们需要确定绑定的IP和端口号，才能通信。

3.addrlen：传入的addr结构体的长度

用sizeof求得即可。

返回值说明：

成功绑定0会被返回，失败-1会被返回，错误码会被设置。

  • 本机端口序列与网络端口序列互相转换函数
//htonl：表示将长整型的本机端口序列转换为长整型的网络端口序列。
uint32_t htonl(uint32_t hostlong);

//htons：表示将短整型的本机端口序列转换为短整型的网络端口序列。
uint16_t htons(uint16_t hostshort);

//ntohl：表示将长整型的网络端口序列转换为长整型的本机端口序列。
uint32_t ntohl(uint32_t netlong);

//ntohs：表示将短整型的网络端口序列转换为短整型的本机端口序列。
uint16_t ntohs(uint16_t netshort);

参数说明：

hostlong代表本机端口序列                                                        netlong代表网络端口序列

uint32_t即长整型                                                                       uint16_t即短整型

  • recvfrom读取数据
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);

参数说明：

1.sockfd：对应操作的文件描述符

表示从该文件描述符索引的文件当中读取数据。

2.buf： 读取数据的存放位置


3.len： 期望读取数据的字节数


4.flags：读取的方式

一般设置为0,表示阻塞读取。


5.src_addr：对端网络相关的属性信息

包括协议簇、IP地址、端口号等。


6.addrlen：期望读取的src_addr结构体的长度

代表实际读取到的src_addr结构体的长度,这是一个输入输出型参数。

返回值说明：

成功实际读到的字节数会被返回，失败-1会被返回，错误码会被设置。

  • sendto发送数据
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                 const struct sockaddr *dest_addr, socklen_t addrlen);

参数说明：

1.sockfd：对应操作的文件描述符

表示将数据写入到文件描述符索引的文件当中。

2.buf： 待写入数据的存放位置


3.len： 期望写入数据的字节数


4.flags：写入的方式

一般设置为0,表示阻塞写入。


5.dest_addr：对端网络相关的属性信息

包括协议簇、IP地址、端口号等。


6.addrlen：期望读取的dest_addr结构体的长度

代表实际读取到的dest_addr结构体的长度,这是一个输入输出型参数。

返回值说明：

成功实际写入的字节数会被返回，失败-1会被返回，错误码会被设置。 

三.   服务端实现

我们将服务端封装成一个类，并封装对应步骤在类函数中。

class UdpServer
{
public:
    UdpServer(uint16_t port)
        : _sockfd(defaultfd), _port(port)
        ,_isrunning(false)
    {}
    ~UdpServer()
    {}

private:
    int _sockfd;
    uint16_t _port; // 服务器所用的端口号
    bool _isrunning;
};

此处为什么服务端不需要IP地址呢?

这是因为服务器不好绑定一个具体的IP地址，不利于服务的广度。我们此处不设置具体的IP地址，就是为了任何IP都能连接服务器。

 服务端初始成员函数：

void InitServer()
{
    // 1.创建udp socket 套接字...必须要做的
    _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (_sockfd < 0)
    {
        LOG(FATAL, "socket error,%s,%d\n", strerror(errno), errno);
        exit(SOCKET_ERROR);
    }
    LOG(INFO, "socket create success,sockfd: %d\n", _sockfd);

    // 2.1 填充sockaddr_in结构
    struct sockaddr_in local;     // struct sockaddr_in 系统提供的数据类型，local是变量，用户栈上开辟空间
    bzero(&local, sizeof(local)); // 清空
    local.sin_family = AF_INET;
    local.sin_port = htons(_port); // port要经过网络传输给对面，即port先到网络，所以要将_port,从主机序列转化为网络序列
    //a.字符串风格的点分十进制的IP地址转成4字节IP
    //b.将主机序列转成网络序列
    //in_addr_t inet_addr(const char* cp)->同时完成a&b
    //local.sin_addr.s_addr =inet_addr(_ip.c_str());
    local.sin_addr.s_addr=INADDR_ANY;//htonl(INADDR_ANY)

    // 2.2 bind sockfd和网络信息(IP(?)+Port)
    int n = bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
    if(n<0)
    {
        LOG(FATAL, "bind error,%s,%d\n", strerror(errno), errno);
        exit(BIND_ERROR);
    }
    LOG(INFO, "socket bind success\n");

}

大概步骤就是通过socket函数创建出套接字，然后填充一个sockaddr_in结构体，最后用这个结构体绑定创建的套接字。

此处LOG函数是仿照日常生活中网络服务的思路，一些操作都有着对应的日志记录，所以创建一个日志文件，实现日志功能。

#pragma once

//日志
#include<iostream>
#include<fstream>
#include<cstdio>
#include<string>
#include<ctime>
#include<unistd.h>
#include<sys/types.h>
#include<stdarg.h>
#include<pthread.h>
#include"LockGuard.hpp"

using namespace std;

bool gIsSave=false;
const string logname="log.txt";


void SaveFile(const string& filename,const string& message)
{
    ofstream out(filename,ios::app);
    if(!out.is_open())
    {
        return;
    }
    out<<message;
    out.close();
}

//1.日志是有等级的
enum Level
{
    DEBUG=0,
    INFO,
    WARNING,
    ERROR,
    FATAL
};


string LevelToString(int level)
{
    switch(level)
    {
        case DEBUG: return "Debug";break;
        case INFO: return "Info";break;
        case WARNING: return "Warning";break;
        case ERROR: return "Error";break;
        case FATAL: return "Fatal";break;
        default: return "Unknown";break;
    }
}

string GetTimeString()
{
    time_t curr_time=time(nullptr);
    struct tm* format_time=localtime(&curr_time);
    if(format_time==nullptr) return "None";
    char time_buffer[64];
    snprintf(time_buffer,sizeof(time_buffer),"%d-%d-%d %d:%d:%d",
    format_time->tm_year+1900,format_time->tm_mon+1,format_time->tm_mday,
    format_time->tm_hour,format_time->tm_min,format_time->tm_sec);

    return time_buffer;
}

pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

//2.日志是由格式的
// 日志等级 时间 代码所在的文件名/行数 日志的内容...
void LogMessage(string filename,int line,bool issave,int level,const char* format,...)
{
    string levelstr=LevelToString(level);
    string timestr=GetTimeString();
    pid_t selfid=getpid();

    //可变参数部分处理
    char buffer[1024];
    va_list arg;
    va_start(arg,format);
    vsnprintf(buffer,sizeof(buffer),format,arg);
    va_end(arg);

    LockGuard lockguard(&lock);

    string message;
    message="["+timestr+"]"+"["+levelstr+"]"+"[pid: "
            +to_string(selfid)+"]"+"["+filename+"]"
            +"["+to_string(line)+"]"+buffer+"\n";
    if(!issave)
    {
        cout<<message;
    }
    else
    {
        SaveFile(logname,message);
    }
}


void Test(int num,...)
{
    va_list arg;
    va_start(arg,num);

    while(true)
    {
        int data=va_arg(arg,int);
        cout<<"data: "<<data<<endl;
        num--;
    }

    va_end(arg);//arg==NULL
}



//C99新特性 __VA_ARGS__
#define LOG(level,format,...) do {LogMessage(__FILE__,__LINE__,gIsSave,level,format,##__VA_ARGS__);} while(0)
#define EnableFile() do {gIsSave=true;} while(0)
#define EnableScreen() do {gIsSave=false;} while(0)

此处我们引进了锁来保护临界资源，也是仿照C++中RAII的思路，创建了一个出了作用域自动销毁的锁。内容如下：

#ifndef __lock_GUARD_HPP__
#define __lock_GUARD_HPP__

#include<iostream>
#include<pthread.h>

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mutex)
    :_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);//构造加锁
    }

    ~LockGuard()
    {
        pthread_mutex_unlock(_mutex);
    }
private:
    pthread_mutex_t* _mutex;
};


#endif

服务端启动成员函数：

我们可以发现现实生活中，一些软件好像啥时候都能用。比如今天晚上我失眠了。诶！打开抖音刷刷。好像不管我们几点失眠，抖音都能刷视频。所以我们见微知著，服务器应该是一直运行的，这样不论客户端什么时候去访问都能得到回应。

void Start()
{
    //一直运行，直到管理者不想运行了，服务器都是死循环
    _isrunning=true;
    while(true)
    {
        char buffer[1024];
        struct sockaddr_in peer;
        socklen_t len=sizeof(peer);
        //1.我们要让server先收数据
        ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
        if(n>0)
        {
            buffer[n]=0;
            InetAddr addr(peer);
            LOG(DEBUG,"get message from [%s:%d]: %s\n",addr.Ip().c_str(),addr.Port(),buffer);
            //2.我们要将server收到的数据，发回给对方
            sendto(_sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&peer,len);
        }

    }
    _isrunning=false;
}

大概思路就是，我们需要先通过recvfrom函数接收客户端发来的消息，然后再通过sendto函数发回给客户端。

我们发现这个函数里面出现了一个新的东西，即InetAddr，这其实是一个结构体，我们来看看吧！

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>

using namespace std;

class InetAddr
{
private:
    void GetAddress(string* ip,uint16_t* port)
    {
        *port=ntohs(_addr.sin_port);//网络字节序转为主机字节序
        *ip=inet_ntoa(_addr.sin_addr);//将网络字节序IP转为点分式十进制IP
    }
public:
    InetAddr(const struct sockaddr_in &addr)
    :_addr(addr)
    {
        GetAddress(&_ip,&_port);
    }

    string Ip()
    {
        return _ip;
    }

    uint16_t Port()
    {
        return _port;
    }

    ~InetAddr()
    {}
private:
    struct sockaddr_in _addr;
    string _ip;
    uint16_t _port;
};

这个结构体重包含了sockaddr_in结构对象，以及IP地址和端口号。

那么服务端代码合起来就是：

#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <strings.h>
#include <stdlib.h>
#include "Log.hpp"
#include"InetAddr.hpp"

using namespace std;

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    USAGE_ERROR
};

const static int defaultfd = -1;

class UdpServer
{
public:
    UdpServer(uint16_t port)
        : _sockfd(defaultfd), _port(port)
        ,_isrunning(false)
    {
    }

    void InitServer()
    {
        // 1.创建udp socket 套接字...必须要做的
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            LOG(FATAL, "socket error,%s,%d\n", strerror(errno), errno);
            exit(SOCKET_ERROR);
        }
        LOG(INFO, "socket create success,sockfd: %d\n", _sockfd);

        // 2.1 填充sockaddr_in结构
        struct sockaddr_in local;     // struct sockaddr_in 系统提供的数据类型，local是变量，用户栈上开辟空间
        bzero(&local, sizeof(local)); // 清空
        local.sin_family = AF_INET;
        local.sin_port = htons(_port); // port要经过网络传输给对面，即port先到网络，所以要将_port,从主机序列转化为网络序列
        //a.字符串风格的点分十进制的IP地址转成4字节IP
        //b.将主机序列转成网络序列
        //in_addr_t inet_addr(const char* cp)->同时完成a&b
        //local.sin_addr.s_addr =inet_addr(_ip.c_str());
        local.sin_addr.s_addr=INADDR_ANY;//htonl(INADDR_ANY)

        // 2.2 bind sockfd和网络信息(IP(?)+Port)
        int n = bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
        if(n<0)
        {
            LOG(FATAL, "bind error,%s,%d\n", strerror(errno), errno);
            exit(BIND_ERROR);
        }
        LOG(INFO, "socket bind success\n");

    }

    void Start()
    {
        //一直运行，直到管理者不想运行了，服务器都是死循环
        _isrunning=true;
        while(true)
        {
            char buffer[1024];
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            //1.我们要让server先收数据
            ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
            if(n>0)
            {
                buffer[n]=0;
                InetAddr addr(peer);
                LOG(DEBUG,"get message from [%s:%d]: %s\n",addr.Ip().c_str(),addr.Port(),buffer);
                //2.我们要将server收到的数据，发回给对方
                sendto(_sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&peer,len);
            }

        }
        _isrunning=false;
    }

    ~UdpServer()
    {
    }

private:
    int _sockfd;
    uint16_t _port; // 服务器所用的端口号
    bool _isrunning;
};

四.   服务端调用实现

由于我们将服务端封装成了一个类，所以需要创建出对象，然后调用初识函数以及开始函数。

#include<iostream>
#include<memory>
#include"UdpServer.hpp"
#include"Log.hpp"
using namespace std;

void Usage(string proc)
{
    cout<<"Usage:\n\t"<<proc<<" local_port\n"<<endl;
}

// ./udpserver port
int main(int argc,char *argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(USAGE_ERROR);
    }
    EnableScreen();
    //string ip=argv[1];
    uint16_t port=stoi(argv[1]);
    unique_ptr<UdpServer> usvr=make_unique<UdpServer>(port);
    usvr->InitServer();
    usvr->Start();

    return 0;
}

思路就是，创建一个对象，依次调用两个成员函数，即可创建出服务端。

五.   客户端实现

客户端的创建前面一部分还是跟服务端一样，即创建套接字，构建目标主机结构体信息，即构建sockaddr_in结构体信息。唯一不同的是，客户端是不需要显示bind的。

为什么呢？

为了防止客户端的端口冲突。如果我们直接将客户端绑定了一个确定的端口号，其他人是不知道的，每个人都绑定一个确定的端口号，势必会有冲突。

那什么时候绑定呢？

在客户端首次发送消息数据的时候，操作系统会给客户端随机分配端口号，以防端口冲突。

void Usage(string proc)
{
    cout<<"Usage:\n\t"<<proc<<" serverip serverport\n"<<endl;
}


// ./udpclient serverip serverport
int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip=argv[1];
    uint16_t serverport=stoi(argv[2]);

    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        cerr<<"socket error"<<endl;
    }

    //2.client一定要bind，client也有自己的ip和port，但是不建议显示(和server一样用bind函数)bind
    //a.那如何bind呢？当udp client首次发送数据的时候，os会自动随机的给client进行bind--为什么？要bind，必然要和port关联！防止client port冲突
    //b.什么时候bind？首次发送数据的时候

    //构建目标主机的socket信息
    struct sockaddr_in server;
    memset(&server,0,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_port=htons(serverport);
    server.sin_addr.s_addr=inet_addr(serverip.c_str());
}

下面就可以直接与服务端通信了。

string message;
//3.直接通信即可
while(true)
{
    cout<<"Please Enter# ";
    getline(cin,message);
    sendto(sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
    
    struct sockaddr_in peer;
    socklen_t len=sizeof(peer);
    char buffer[1024];
    ssize_t n=recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
    if(n>0)
    {
        buffer[n]=0;
        cout<<"server echo# "<<buffer<<endl;
    }
}

通信时，首先通过sendto将要发送的信息发送到服务端，服务端收到后会将信息发送回来，然后再用recvfrom函数收到信息即可。

客户端整体代码如下：

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

using namespace std;


void Usage(string proc)
{
    cout<<"Usage:\n\t"<<proc<<" serverip serverport\n"<<endl;
}


// ./udpclient serverip serverport
int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip=argv[1];
    uint16_t serverport=stoi(argv[2]);

    //1.创建socket
    int sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        cerr<<"socket error"<<endl;
    }

    //2.client一定要bind，client也有自己的ip和port，但是不建议显示(和server一样用bind函数)bind
    //a.那如何bind呢？当udp client首次发送数据的时候，os会自动随机的给client进行bind--为什么？要bind，必然要和port关联！防止client port冲突
    //b.什么时候bind？首次发送数据的时候

    //构建目标主机的socket信息
    struct sockaddr_in server;
    memset(&server,0,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_port=htons(serverport);
    server.sin_addr.s_addr=inet_addr(serverip.c_str());

    string message;
    //3.直接通信即可
    while(true)
    {
        cout<<"Please Enter# ";
        getline(cin,message);
        sendto(sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
        
        struct sockaddr_in peer;
        socklen_t len=sizeof(peer);
        char buffer[1024];
        ssize_t n=recvfrom(sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
        if(n>0)
        {
            buffer[n]=0;
            cout<<"server echo# "<<buffer<<endl;
        }
    }
    return 0;
}

六.   效果展示

最后服务端和客户端通信的效果如下：

可以看到服务端在创建套接字成功，bind成功之后开始工作。

客户端发送消息，服务端收到消息，并返还给客户端。 

总结：

好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。

祝大家越来越好，不用关注我（疯狂暗示）

小灵蛇
关注
  • 15
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Socket编程-UDP协议（C#）
wangjun的博客
03-22 981
1.原理及概述基于Udp协议是无连接模式通讯，占用资源少，响应速度快，延时低。至于可靠性，可通过应用层的控制来满足。(不可靠连接)　　　　(1).建立一个套接字(Socket)　　　　(2).绑定服务器端IP地址及端口号--服务器端　　　　(3).通过SendTo()方法向指定主机发送消息  (需提供主机IP地址及端口)　　　　(4).通过ReciveFrom()方法接收指定主机发送的消息(需提供...
Socket编程-④udp代码实例+解析
04-15
本篇文章将深入探讨UDP（User Datagram Protocol）协议的Socket编程实例，并对代码进行详细解析。UDP是一种无连接的传输层协议，它不保证数据包的顺序、可靠性和错误校验，但具有低开销、快速传输的特点，常用于实时...
Socket编程-UDP方式
不务正业的猿
12-06 1111
目录 基于UDP的Socket通信 编码 SocketServerUDP SocketThreadUDP SocketClientUDP 演示 基于UDP的Socket通信 Socket除了支持TCP协议，也支持UDP协议。 编码 SocketServerUDP package com.ispeasant.socket.udp; import java.net.DatagramPacket; import java.net.DatagramSocket; public class
socket 1---UDP编程
flyingcloud6的博客
01-14 899
端口号是一共2字节16位整数，范围是[0,65535];端口号用来标识一个进程，告诉操作系统，当前的这个数据要交给哪一个进程来处理，注意：一共端口号只能被一个进程所占用，一个进程可以占用多个端口号（在同一台机器当中）范围内的端口已经被一些知名的协议所使用，我们在编写代码的时候不要使用该范围内的数据作为端口号。
【网络】Socket编程-UDP篇
chuxinchangcun的博客
05-10 4332
在客户端调用recvfrom函数接收服务端发来的响应数据时,客户端同时也需要读取服务端与网络相关的各种信息,虽然客户端早已知道服务端的网络信息了,此时服务端的网络信息已经不重要了,但还是建议不要把参数设置为空,这样可能会出问题,所以我们还是用一个临时变量将服务端的网络信息读取一下,b.IP地址一般对应的就是域名,而端口号一般没有显示指明过,因此服务端的端口号一定要是一个众所周知的端口号,并且选定后不能轻易改变,否则客户端是无法知道服务端的端口号的,这就是服务端要进行绑定的原因。
socket编程-UDP各函数及其用法
weixin_45256307的博客
03-11 1962
socket编程-UDP各函数及其用法
Socket编程-udp服务端和客户端通信
10-19 1692
基于Udp协议是无连接模式通讯，占用资源少，响应速度快，延时低。至于可靠性，可通过应用层的控制来满足。(不可靠连接) 　　　　(1).建立一个套接字(Socket) 　　　　(2).绑定服务器端IP地址及端口号--服务器端 　　　　(3).通过SendTo()方法向指定主机发送消息   (需提供主机IP地址及端口) 　　　　(4).通过ReciveFrom()方法接收指定主机发送的消息 ...
Linux Socket编程 -- UDP Server 与 Client
wxfx_OT的博客
09-19 1707
UDP simple server
socket编程-----udp通信程序编写的基本流程
Hedenghui777的博客
11-29 2112
文章目录前言一、通信程序的编写二、udp通信流程1.udp流程图2.套接字接口3.字节序转换接口3.代码 前言 传输层协议的区别： tcp：传输控制协议–面向连接，可靠传输，面向字节流 udp：用户数据报协议—无连接，不可靠，面向数据报 tcp保证可靠传输，但是传输速度没有udp快 tcp应用于安全性要求高的场景/udp应用于实时性要求高的场景 一、通信程序的编写 通信中总是两端主机进行通信，并且主动发起请求的一方称为客户端，被动首先接收请求的一方称为服务端 二、udp通信流程 1.udp流程图 2.套
学习Windows 环境 socket--UDP 连接
weixin_46513031的博客
08-11 712
3.调用int sock = socket(AF_INET, SOCK_STREAM, 0);，创建socket 句柄。4.接受端需要绑定端口和IP，发送端可以不绑定端口和IP。函数发送和接收数据。
深入socket编程--ipv6适配
evilstar2015的专栏
04-24 4741
了解一下socket对协议族处理的底层逻辑，如何适配ipv6网络
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
【Linux网络编程-网络基础-socket编程-高并发服务器】 在深入探讨Linux下的网络编程之前，我们首先要理解网络通信的基础概念——协议。协议是数据传输和解释的规则，它确保了不同设备之间的通信能顺利进行。例如，...
C语言SOCKET编程--超级完整.doc
07-19
### C语言SOCKET编程知识点详解 #### 一、Socket编程概览 - **定义与概念**： - **Socket**（套接字）是一种用于进程间通信的机制，允许一个程序通过网络与其他程序进行交流。 - 在Unix系统中，一切皆视为文件，...
UDP_Demo.rar_UDP_socket-udp通讯_socket编程_udp 通讯_udp通讯
09-20
UDP_Demo.rar 是一个关于UDP通信的示例程序，通过简单的socket编程实现。 在UDP中，每个数据报文都是独立发送的，没有建立连接、确认接收或重传机制。这意味着数据可能丢失、重复或乱序到达，但同时也使得UDP比TCP...
实战linux socket编程--示例源码.rar_C++ socket_linux 源码_socket 编程 linux_s
09-22
- “实战linux socket编程--示例源码”是实际的源代码文件，包含了各种Socket编程的实例，如简单TCP服务器、客户端、UDP通信等。 - 分析这些源码，可以帮助读者理解Socket编程的具体实现，包括如何建立连接、发送...
【计算机网络】名词解释--网络专有名词详解
goldfish8848的博客
08-25 979
在网络通信中，有许多专业术语和概念，它们共同构成了网络通信的基础。
测试 UDP 端口可达性的方法
最新发布
2401_86544677的博客
08-29 363
UDP (User Datagram Protocol) 是一种无连接的传输层协议，它不像 TCP 那样提供确认机制来保证数据包的可靠传输。因此，测试 UDP 端口的可达性通常需要一些特殊的方法，因为传统的端口扫描工具（如 `nmap`）主要针对的是 TCP 协议。
python源码：基于fastapi+websocket双向信息通道的简易网页聊天室
我是你大爷
08-26 323
python源码分享：《基于fastapi+websocket双向信息通道的简易网页聊天室》，具备以下功能：用户进入退出提示、发送及广播文字消息和图片，这两个主体功能。
JavaEE 第18节 TCP&UDP优缺点（对比）
2301_80636143的博客
08-26 1107
基于TCP/IP协议栈，TCP和UDP属于传输层协议。在Java生态中也分别提供了相关套接字（Socket）1的API，方便网络编程。这两种协议各有优势，我们在网络编程中要根据他们的特性，选择合适的协议进行网络编程。接下来的文章小编会详细讲解UDP/TCP两种协议的优缺点以及相关应用场景。在选择协议时，给大家做个参考。另外，本文中有一些专业名词带有脚注，点击脚注可以查看详细解释UDP的优势在于速度快、延迟低、开销小，适用于实时性要求高、不需要保证数据可靠性的场景，如视频流、在线游戏、语音通信等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值