weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

Qt实现UDP单播、组播和广播功能_qt udp组播

作者：weixin_40725706 | 2024-08-06 08:36:36

踩

qt udp组播

一、UDP单播、广播和组播的说明

UDP是不可靠、无连接的，所以划分为发送方和接收方更好理解

1、单播

UDP是无连接的，进行单播通信时，必须要绑定接收方端口，发送方直接通过接收方的ip和绑定的端口进行通信。发送方可以绑定端口也可以不用绑定端口，不绑定端口的话，系统会随机分配端口。

对于多网卡来说，需要指定网卡，绑定一个网卡的ip。如果不进行显式的绑定操作，QUdpSocket 对象将会使用默认的绑定方式，自动选择一个可用的 ip 地址进行绑定。

2、广播

对于只有1个网卡的主机来说，可以不用显示绑定ip，发送方直接发送广播就行，接收方绑定广播端口就行，这样才能看到收到的消息。

对于多网卡来说，要指定唯一的网卡ip并且在广播前要绑定广播端口。ip可以不用绑定，这样系统会随机分配一个网卡ip。

3、组播

对于只有1个网卡的主机来说，可以不用绑定ip，直接绑定端口后加入组播就行。系统分配任意一个ip ，相当于 QHostAddress::AnyIPv4。

对于多网卡来说，要指定唯一的网卡并且在加入组播前要绑定组播端口，ip可以不用绑定，系统分配任意一个ip。

注意：指定网卡不等于指定ip！！！

1、使用 setMulticastInterface 方法可以指定一个明确的网卡，但并不意味着只有一个 IP 地址。一个网卡可以绑定多个 IP 地址，例如在同一台主机上同时存在有线网卡和无线网卡，它们可能都连接到同一局域网，并分别配置了不同的 IP 地址。此时，通过 setMulticastInterface 方法指定了一个明确的网卡后，并不确定使用哪个 IP 地址来进行组播通信。

如果需要确保使用特定的 IP 地址进行组播通信，则需要使用 bind 方法来将 QUdpSocket 对象绑定到具体的 IP 地址和端口上，这样每次进行组播通信时，都会使用该 IP 地址来发送和接收数据报文。

2、使用 QHostAddress::AnyIPv4 参数可以将 QUdpSocket 对象绑定到本机的所有 IPv4 地址。这意味着，该 QUdpSocket 对象可以接收通过本机的任意一个 IPv4 地址发送到指定端口的数据包。

然而，需要注意的是，绑定到多个 IPv4 地址并不意味着可以同时从多个地址接收数据包。在任何给定的时刻，QUdpSocket 对象只能通过一个 IP 地址接收数据包。

当有多个 IPv4 地址可用时，QUdpSocket 对象会选择其中一个地址来接收数据包。这个选择通常由操作系统或网络栈决定，并且可能会受到各种因素的影响，例如网络接口的优先级、路由表等。

因此，使用 QHostAddress::AnyIPv4 参数可以让 QUdpSocket 对象绑定到本机的所有 IPv4 地址，但实际上它只能通过其中一个地址接收数据包。具体使用哪个地址取决于操作系统和网络环境。

二、遇到的UDP通信的问题参考

关于QT UDP组播的几个问题https://blog.csdn.net/tom06/article/details/52163665?spm=1001.2014.3001.5506

UDP多播/组播通信，同一局域网下的两台机器通信接收不到数据https://blog.csdn.net/qq_43290013/article/details/117288296?spm=1001.2014.3001.5506

QT读取网卡列表多网卡绑定组播网卡https://blog.csdn.net/qq_30727593/article/details/127441711?spm=1001.2014.3001.5506

三、效果与代码

1、在.pro文件中添加如下内容：

QT       += network

2、在.h文件中添加串口所用的头文件


#include <QUdpSocket>
#include <QNetworkInterface>

3、添加一个QUdpSocket* socket的类成员，并在.cpp中实例化对象：

socket = new QUdpSocket;

4、扫描可用网口


QList<QNetworkInterface> interfaceList = QNetworkInterface::allInterfaces();
    foreach (QNetworkInterface nif, interfaceList) {
        // 检查网卡是否有效并已经启用
        if (nif.isValid() && nif.flags().testFlag(QNetworkInterface::IsUp)) {
            // 将已经启用的网卡名称添加到列表中
            enabledInterfaceList.append(nif);
            QList<QNetworkAddressEntry> entries = nif.addressEntries();
            foreach (QNetworkAddressEntry entry, entries) {
                if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {
                    ui->nif_config->addItem(entry.ip().toString());
                }
            }
        }
    }

5、对组播进行设置（可以忽略）


//组播的数据的生存期，数据报没跨1个路由就会减1.表示多播数据报只能在同一路由下的局域网内传播
socket->setSocketOption(QAbstractSocket::MulticastTtlOption,1);
//1是允许loopback模式（自发自收）,0是阻止。
socket->setSocketOption(QAbstractSocket::MulticastLoopbackOption, true);

6、初始化组播设置


int MainWindow::init_group(QUdpSocket *socket, QNetworkInterface &currentInterface, QHostAddress &localAddress, QHostAddress &targetAddress, int localPort)
{
    if (targetAddress.isMulticast()) {//isMulticast()判断是否是组播地址
        if (localPort == 0) {//判断是否指定本地端口
//bind(localAddress, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)可以换成bind(QHostAddress::AnyIPv4, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)
            if (socket->bind(localAddress, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)) {
                socket->setMulticastInterface(currentInterface);
                if (socket->joinMulticastGroup(targetAddress, currentInterface)) {
                    qDebug() << "未指定本地端口,加入组播成功";
                    return 1;
                } else {
                    qDebug() << "未指定本地端口,加入组播失败";
                    return -1;
                }
            } else {
                qDebug() << "未指定本地端口,绑定失败";
                return -1;
            }
        } else {
            if (socket->bind(localAddress, localPort, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)) {
                socket->setMulticastInterface(currentInterface);
                if (socket->joinMulticastGroup(targetAddress, currentInterface)) {
                    qDebug() << "指定本地端口,加入组播成功";
                    return 1;
                } else {
                    qDebug() << "指定本地端口,加入组播失败";
                    return -1;
                }
            } else {
                qDebug() << "指定本地端口,绑定失败";
                return -1;
            }
        }
    } else {
        qDebug() << "目标地址不是组播地址";
        return -1;
    }
 
    // 如果执行到这里，说明没有通过任何返回语句，应该是一个错误
    qDebug() << "init_group 函数执行路径错误";
    return -1; // 或者抛出异常，取决于您希望如何处理这种情况
}

1、QUdpSocket::ShareAddress：

这个选项告诉操作系统允许多个 QUdpSocket 对象绑定到同一个地址和端口上。在默认情况下，操作系统可能会阻止多个 socket 绑定到相同的地址和端口，但是如果设置了 ShareAddress 选项，Qt 会尝试在可能的情况下共享这个地址和端口。
在实际应用中，如果需要多个 QUdpSocket 对象同时监听相同的地址和端口，可以使用 ShareAddress 选项来避免绑定失败的问题。
想象一下你和朋友们想在同一个电话号码上收发短信。默认情况下，操作系统可能会阻止多个程序或者多个 QUdpSocket 对象同时使用同一个网络地址（IP 地址）和端口号。但是如果你打开了 ShareAddress 选项，就像是你和朋友们一起共享一个电话号码，大家可以同时收发信息。
这个选项让多个 QUdpSocket 对象可以在同一个网络地址和端口上工作，而不会相互干扰或者造成绑定失败的问题。

2、QUdpSocket::ReuseAddressHint：

这个选项告诉操作系统允许在 UDP Socket 关闭之后，立即重新使用相同的地址和端口。如果没有设置这个选项，操作系统会在 QUdpSocket 关闭后一段时间内保持端口的占用状态，这可能会导致稍后尝试重新绑定失败。
设置 ReuseAddressHint 可以避免在关闭一个 QUdpSocket 后立即重新绑定时遇到 Address already in use 的错误。
想象一下你用一个电话号码打电话，然后挂了电话。在一段时间内，电话号码可能会被暂时保留，不允许其他人再用。这就好比默认情况下，当一个 QUdpSocket 关闭后，操作系统可能会暂时保留使用的网络地址和端口号，不让其他程序立即使用。
如果你设置了 ReuseAddressHint，就像是告诉操作系统，“我关掉电话后，如果其他人想用这个电话号码，可以立刻用，不用等。” 这个选项允许在一个 QUdpSocket 关闭后，立即重新使用相同的网络地址和端口号，而不会遇到“地址已经被占用”的错误。

总结：使用后可以重复ip和端口

7、发送消息

socket->writeDatagram(str,targetAddress,targetPort);

8、接收消息


//接收消息
connect(udpSocket,&QUdpSocket::readyRead,this,[&](){
    QByteArray datagram;
    datagram.resize(udpSocket->pendingDatagramSize());
    udpSocket->readDatagram(datagram.data(), datagram.size());
    ui->recvTextEdit->append(datagram);
});

9、退出组播


int MainWindow::exit_group(QUdpSocket *socket ,QNetworkInterface &currentInterface, QHostAddress &targetAddress)
{
    if(socket->leaveMulticastGroup(targetAddress，currentInterface)){
        socket->abort();
        qDebug() << "退出组播成功";
        return 1;
    }else{
        qDebug() << "退出组播失败";
        return -1;
    }
}

四、自定义UDP工具类

MyUdpTools.h


#ifndef MYUDPTOOLS_H
#define MYUDPTOOLS_H
 
#include <QObject>
#include <QThread>
#include <QComboBox>
#include <QUdpSocket>
#include <QMessageBox>
#include <QApplication>
#include <QNetworkDatagram>
#include <QNetworkInterface>
 
class MyUdpTools : public QObject
{
    Q_OBJECT
public:
    explicit MyUdpTools(QObject *parent = nullptr);
    ~MyUdpTools();
 
    // 单播相关方法
    int setupUnicast(QString currentNetInterfacrAddress, quint16 port = 0);
    void sendUnicastData(QString targetAddress,quint16 port,const QByteArray &data);
    int exitUnicast();
 
    // 组播相关方法
    int setupMulticast(QNetworkInterface *netInterface,QString currentNetInterfacrAddress,QString groupAddress, quint16 port = 0);
    void sendMulticastData(QString targetAddress,quint16 port,const QByteArray &data);
    int exitMulticast();
 
    // 广播相关方法
    int setupBroadcast(QString currentNetInterfacrAddress,QString targetAddress,quint16 port = 0);
    void sendBroadcastData(QString targetAddress,quint16 port,const QByteArray &data);
    int exitBroadcast();
 
    //添加或刷新combox的网卡信息
    void init_or_flash_NetInterfaceInfoToCombox(QList<QNetworkInterface> &list,QComboBox *combox);
 
signals:
    void sig_RecvData(QByteArray data);
 
private slots:
    void processPendingDatagrams();//接收数据槽函数
    void handleSocketError(QAbstractSocket::SocketError socketError);//Udp错误日志
 
private:
    QThread *thread;
    QHostAddress localAddress;//本机当前网卡ip
 
    QUdpSocket *unicastSocket;//单播
    quint16 unicastPort_Local;//单播本地端口
    quint16 unicastPort_Target;//单播目标端口
    QHostAddress targetAddress_Unicast;//单播目标地址
 
    QUdpSocket *multicastSocket;//组播
    QHostAddress multicastGroupAddress;//组播地址
    quint16 multicastPort_Local;//组播本地端口
    quint16 multicastPort_Target;//组播目标端口
 
    QUdpSocket *broadcastSocket;//广播
    QHostAddress broadcastGroupAddress;//广播地址
    quint16 broadcastPort_Local;//广播本地端口
    quint16 broadcastPort_Target;//广播目标端口
 
};
 
#endif // MYUDPTOOLS_H

MyUdpTools.cpp


#include "myudptools.h"
 
MyUdpTools::MyUdpTools(QObject *parent)
    : QObject(parent),unicastSocket(nullptr),multicastSocket(nullptr),broadcastSocket(nullptr)
{
    thread = new QThread();
    moveToThread(thread);
 
    //应用程序关闭后触发
    connect(qApp,&QApplication::aboutToQuit,thread, &QThread::quit);
    //线程退出后触发
    connect(thread, &QThread::finished, thread, &QThread::deleteLater);
    connect(thread,&QThread::finished,this,&MyUdpTools::deleteLater);
 
    // 在子线程中直接调用函数
    QMetaObject::invokeMethod(this, "init_or_flash_NetInterfaceInfoToCombox", Qt::QueuedConnection);
 
    //启动线程
    thread->start();
}
 
MyUdpTools::~MyUdpTools()
{
    if(unicastSocket){
        delete unicastSocket;
    }
    if(multicastSocket){
        delete multicastSocket;
    }
    if(broadcastSocket){
        delete broadcastSocket;
    }
}
 
//===========================单播相关方法实现===========================
int MyUdpTools::setupUnicast(QString currentNetInterfacrAddress, quint16 port)
{
    if (!unicastSocket) {
        unicastSocket = new QUdpSocket(this);//将父对象设置为当前对象
        connect(unicastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);
        connect(unicastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));
        qInfo() << "创建单播socket";
    }
    localAddress = QHostAddress(currentNetInterfacrAddress);
    unicastPort_Local = port;
 
    if(port == 0){
        if (!unicastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {
            qCritical() << "单播绑定失败:" << unicastSocket->errorString();
            return -1;
        }
    }else{
        if (!unicastSocket->bind(localAddress, unicastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {
            qCritical() << "单播绑定失败:" << unicastSocket->errorString();
            return -1;
        }
    }
 
    qInfo() << "单播连接成功";
 
    return 1;
}
 
void MyUdpTools::sendUnicastData(QString targetAddress, quint16 port, const QByteArray &data)
{
    if(unicastSocket){
        targetAddress_Unicast = QHostAddress(targetAddress);
        unicastPort_Target = port;
        if(unicastSocket->writeDatagram(data,targetAddress_Unicast,unicastPort_Target) == -1){
            qCritical() << "发送单播数据失败:" << unicastSocket->errorString();
        }
    }
}
 
int MyUdpTools::exitUnicast()
{
    if (unicastSocket) {
        unicastSocket->close();
        qCritical() << "退出成功";
        return 1;
    }else{
        qCritical() << "已退出单播，无需再退出";
        return -1;
    }
}
 
//===========================组播相关方法实现===========================
int MyUdpTools::setupMulticast(QNetworkInterface *netInterface,QString currentNetInterfacrAddress, QString groupAddress, quint16 port)
{
    if(!multicastSocket){
        multicastSocket = new QUdpSocket(this);
        connect(multicastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);
        connect(multicastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));
        qInfo() << "创建组播socket";
    }
    localAddress = QHostAddress(currentNetInterfacrAddress);
    multicastGroupAddress = QHostAddress(groupAddress);
    multicastPort_Local = port;
 
    if(!multicastGroupAddress.isMulticast()){
        qWarning() <<  "不是组播地址";
        return -1;
    }
 
    if(port == 0){
        if(!multicastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)){
            qCritical() << "组播绑定失败:" << multicastSocket->errorString();
            return -1;
        }
    }else{
        if(!multicastSocket->bind(localAddress,multicastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)){
            qCritical() << "组播绑定失败:" << multicastSocket->errorString();
            return -1;
        }
    }
 
    multicastSocket->setMulticastInterface(*netInterface);
    if(!multicastSocket->joinMulticastGroup(multicastGroupAddress,*netInterface)){
        qCritical() << "加入组播失败:" << multicastSocket->errorString();
        return -1;
    }
 
    qInfo() << "组播连接成功";
 
    return 1;
}
 
void MyUdpTools::sendMulticastData(QString targetAddress, quint16 port, const QByteArray &data)
{
    if(multicastSocket){
        multicastGroupAddress = QHostAddress(targetAddress);
        multicastPort_Target = port;
        if(multicastSocket->writeDatagram(data,multicastGroupAddress,multicastPort_Target) == -1){
            qCritical() << "发送组播数据失败:" << multicastSocket->errorString();
        }
    }
}
 
int MyUdpTools::exitMulticast()
{
    if (multicastSocket) {
        multicastSocket->leaveMulticastGroup(multicastGroupAddress);
        multicastSocket->close();
        qInfo() << "退出组播成功";
        return 1;
    }else{
        qCritical() << "已退出组播,无需再退出";
        return -1;
    }
}
 
//===========================广播相关方法实现===========================
int MyUdpTools::setupBroadcast(QString currentNetInterfaceAddress,QString targetAddress, quint16 port)
{
    if (!broadcastSocket) {
        broadcastSocket = new QUdpSocket(this);//将父对象设置为当前对象
        connect(broadcastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);
        connect(broadcastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));
        qInfo() << "创建广播socket";
    }
    localAddress = QHostAddress(currentNetInterfaceAddress);
    broadcastPort_Local = port;
    broadcastGroupAddress = QHostAddress(targetAddress);
 
    if(!broadcastGroupAddress.isBroadcast()){
        qCritical() << "不是广播地址";
        return -1;
    }
 
    if(port == 0){
        if (!broadcastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {
            qCritical() << "广播绑定失败:" << broadcastSocket->errorString();
            return -1;
        }
    }else{
        if (!broadcastSocket->bind(localAddress, broadcastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {
            qCritical() << "广播绑定失败:" << broadcastSocket->errorString();
            return -1;
        }
    }
 
    qInfo() << "连接成功";
 
    return 1;
}
 
void MyUdpTools::sendBroadcastData(QString targetAddress, quint16 port, const QByteArray &data)
{
    if(broadcastSocket){
        broadcastGroupAddress = QHostAddress(targetAddress);
        broadcastPort_Target = port;
        if(broadcastSocket->writeDatagram(data,broadcastGroupAddress,broadcastPort_Target) == -1){
            qCritical() << "发送广播数据失败:" << broadcastSocket->errorString();
        }
    }
}
 
int MyUdpTools::exitBroadcast()
{
    if (broadcastSocket) {
        broadcastSocket->close();
        qInfo() << "退出成功";
        return 1;
    }else{
        qDebug() << "已退出广播,无需再退出";
        return -1;
    }
}
 
//===========================添加或刷新combox的网卡信息函数实现===========================
void MyUdpTools::init_or_flash_NetInterfaceInfoToCombox(QList<QNetworkInterface> &list, QComboBox *combox)
{
    list.clear();
    combox->clear();
 
    QList<QNetworkInterface> interfaceList = QNetworkInterface::allInterfaces();
    foreach (QNetworkInterface nif, interfaceList) {
        // 检查网卡是否有效并已经启用
        if (nif.isValid() && nif.flags().testFlag(QNetworkInterface::IsUp)) {
            // 将已经启用的网卡名称添加到列表中
            list.append(nif);
            QList<QNetworkAddressEntry> entries = nif.addressEntries();
            foreach (QNetworkAddressEntry entry, entries) {
                if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {
                    combox->addItem(entry.ip().toString());
                }
            }
        }
    }
}
 
//===========================接收数据槽函数实现===========================
void MyUdpTools::processPendingDatagrams()
{
    QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender());//sender()发送信号的对象的指针
    if (!socket) return;
 
    while (socket->hasPendingDatagrams()) {
#if 1
        QByteArray datagram;
        datagram.resize(socket->pendingDatagramSize());
        socket->readDatagram(datagram.data(), datagram.size());
        qDebug() << "Received Data:" << datagram;
        emit sig_RecvData(datagram);
#else
        QNetworkDatagram datagram = socket->receiveDatagram();
        QByteArray data = datagram.data();
        emit sig_RecvData(data);
#endif
    }
}
 
//===========================Udp错误日志信息===========================
void MyUdpTools::handleSocketError(QAbstractSocket::SocketError socketError)
{
    QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender());
    if (!socket) return;
 
    switch (socketError) {
    case QAbstractSocket::HostNotFoundError:
        qCritical() << "Host not found error:" << socket->errorString();
        break;
    case QAbstractSocket::ConnectionRefusedError:
        qCritical() << "Connection refused error:" << socket->errorString();
        break;
    case QAbstractSocket::DatagramTooLargeError:
        qCritical() << "Datagram too large error:" << socket->errorString();
        break;
    default:
        qCritical() << "Socket error:" << socket->errorString();
        break;
    }
}

注意：

为什么new QThread();不能指定父对象为this？

如果指定父对象为this的话， QThread 的生命周期就由其父对象MyUdpTools管理，不是由QThread直接管理，这不是推荐的做法。

不同线程之间的通信要用信号与槽进行通信。

在子线程中不能调用函数，会影响线程安全，可以在主线程中使用函数QMetaObject::invokeMethod 使得子线程能直接调用函数。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/936700