Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Obiettivi di apprendimento: Programmazione di reti Qt QWebSocket

Pre-ambiente di apprendimento

Blog di comunicazione di rete multi-thread QT TCP-CSDN

Contenuto didattico

WebSocket è una tecnologia di rete che fornisce un canale di comunicazione full-duplex su una singola connessione TCP. Nel 2011, IETF ha standardizzato il protocollo WebSocket come RFC6455 e QWebSocket può essere utilizzato sia nelle applicazioni client che nelle applicazioni server.

Implementa la comunicazione full-duplex tra il browser e il server, consentendo al server di inviare informazioni in modo proattivo al client.

caratteristica principale:

1. A differenza di HTTP, WebSocket consente al server di inviare attivamente dati al client senza richiedere al client di avviare una richiesta.

2. Basato sul protocollo TCP, la comunicazione full duplex viene eseguita tra il server e il client su un'unica porta tramite il protocollo Ws (WebSocket).

3. Supporta la trasmissione dei dati in formato testo o binario.

4. Il protocollo è basato su una singola connessione TCP. Il server e il client devono creare solo una connessione e la connessione non verrà chiusa.

5. Supporta librerie lato client e lato server in più linguaggi di programmazione, come JavaScript, Java, C#, Python, ecc.

Scenari applicativi comuni:

1. Chat room: supporta conversazioni in tempo reale a bassa latenza.

2. Gioco online: un motore di sincronizzazione che richiede la sincronizzazione in tempo reale dello stato del gioco.

3. Quotazioni azionarie: software di quotazione che deve inviare quotazioni in tempo reale al cliente.

4. Videoconferenza: è necessaria la comunicazione in tempo reale a bassa latenza di voce e video.

5. Modifica collaborativa in tempo reale: ad esempio, l'editor di codice online richiede la sincronizzazione in tempo reale.

QWebSocket è la libreria di funzioni WebSocket fornita da Qt. È costruito sul modulo di rete Qt e implementa il protocollo WebSocket nello standard RFC6455. È necessario aggiungere QT+=websocket al file Qmake

1. QWebSocket supporta solo formati di messaggi di testo/binari e non supporta altri formati estesi. Se è necessario aggiungere altri protocolli personalizzati, gli sviluppatori devono gestirli autonomamente a livello di applicazione.

2. Supporta l'accesso ai servizi websocket utilizzando le porte http/https standard 80/443 e supporta anche il protocollo wss (websocket crittografato). Quindi può facilmente interagire con i server web esistenti.

3. Poiché si basa sull'implementazione del socket QT CP, supporta completamente tutte le funzioni di rete Qt, come le impostazioni proxy, la configurazione SSL, ecc. Questo è più facile da usare rispetto ad alcune interfacce C di basso livello.

4. Supporta sia la modalità di connessione attiva che quella passiva. Le connessioni attive avvengono tramite connectToHost() e le connessioni passive vengono accettate tramite la porta di ascolto Accept(). Entrambe le modalità sono molto convenienti.

5. Per le applicazioni QT GUI, la ricezione dei messaggi e gli aggiornamenti dell'interfaccia possono essere eseguiti facilmente, evitando la complessità della programmazione multi-thread. Ad esempio, aggiorna semplicemente l'interfaccia direttamente in textMessageReceived().

6. Dopo QT5.10, è supportato l'I/O asincrono e le prestazioni sono leggermente migliorate rispetto a prima. Anche il supporto per le estensioni di rete è migliore.

Funzioni membro comuni di QWebSocket

 
origin()
即 websocket=new QWebSocket("C1我是客户端",QWebSocketProtocol::VersionLatest,this);
websocket->origin()  -》 C1我是客户端
 
void connectToHost(const QUrl &url) - 用于连接到指定主机的websocket服务,这个函数是异步的。
void close() - 关闭与服务器的连接。
void textMessageReceived(const QString &message) - 收到文本消息时触发的信号,其参数就是收到的文本消息内容。
void binaryMessageReceived(const QByteArray &message) - 收到二进制消息时触发的信号,参数是原始二进制数据。
void error(QAbstractSocket::SocketError socketError) - 发生错误时触发的信号,参数是错误类型。
void stateChanged(QAbstractSocket::SocketState state) - 连接状态变化时触发,可以得知连接是否建立等。
void textMessageSent(qint64 numBytes) - 发送文本消息完成后触发,numBytes是字节数。
void bytesWritten(qint64 bytes) - 消息发送过程中的写入回调, bytes是一个部分发送出去的字节数。
void abort() - 主动断开连接。
bool waitForConnected(int msec = 30000) - 阻塞等待连接建立成功。
QString hostName() - 获取当前连接的主机名,常用于判断连接是否成功。
quint16 port() - 获取主机端口号。
bool openMode() - 判断当前是否为主动连接还是被动接受模式。
void writeTextMessage(const QString &text) - 发送文本消息,相比textMessage等更直观。
void writeMessage(const QByteArray &data) - 发送二进制数据。
qint64 bytesAvailable() - 查看接收缓存中可读取字节数。
qint64 readBufferSize() - 设置双向数据接收缓存大小。
void pauseIncomingPayload() - 暂停接收消息流。
void resumeIncomingPayload() - 恢复接收。
bool isValid() - 检查连接是否有效。
另外,作为QT套接字,它还支持一些通用功能:
void setProxy() - 设置代理。
void encrypt() - 设置SSL安全连接。
void flush() - 强制输出缓存写出。
bool waitForBytesWritten() - 等待数据发送完毕。
 
void QWebSocket::sendTextMessage(const QString &message)  用于发送文本消息
使用这个函数发送文本消息主要有以下几点需要注意的地方:
1发送文本消息前请确保WebSocket连接已经建立。可以通过ReadyState判断连接状态。
2发送的消息内容必须是纯文本,不支持转义编码等更多格式。
3一条消息发送完毕后,会触发textMessageSent()信号通知。
4可以通过waitForBytesWritten()等待数据完全发送出去。
5发送数据顺序可能与收到响应顺序不一致,需要应用层自己处理序号等。
6若消息较大,建议使用write或send到套接字后flush,而不是sendTextMessage。
7跨平台考虑,消息内容编码最好使用QString而不是QByteArray。
8使用该函数发送的文本消息类型,服务端一般对应文本框接受。
9可以绑定消息发送断开连接的异常处理等。

Entrambe le funzioni sendTextMessage e writeTextMessage possono essere utilizzate per inviare messaggi di testo, ma presentano alcune differenze:

1. La definizione della funzione è diversa:

• sendTextMessage appartiene alla funzione membro di QWebSocket;

• writeTextMessage è una funzione membro di QAbstractSocket e QWebSocket eredita da QAbstractSocket.

1. L'efficienza di invio è diversa:

• Internamente sendTextMessage convertirà prima il messaggio in QByteArray, quindi lo invierà tramite la funzione di scrittura, che è un'altra conversione;

• writeTextMessage scrive direttamente la QString che deve essere inviata, il che è leggermente più efficiente.

1. Il supporto asincrono è diverso:

• sendTextMessage è un'operazione sincrona e verrà restituita al termine dell'invio;

• writeTextMessage supporta chiamate asincrone e la funzione di callback può essere specificata tramite Lambda.

1. La gestione degli errori è diversa:

• sendTextMessage non restituirà informazioni sull'errore e potrà essere gestito solo tramite errori di segnale;

• writeTextMessage può ottenere il codice di errore restituito per determinare la situazione di invio.

1. Diversi scenari di utilizzo:

• sendTextMessage si concentra su WebSocket ed è adatto per chiamare l'API WebSocket;

• writeTextMessage è più generale e può essere utilizzato con altre sottoclassi QAbstractSocket.

Generalmente:

• sendTextMessage è più semplice da usare, ben incapsulato e adatto all'utilizzo di base;

• writeTextMessage è leggermente più efficiente, supporta più funzionalità come la gestione asincrona e degli errori ed è adatto a scenari con requisiti di prestazioni o controllo elevati.

Realizzare il progetto

Comunicazione privata tra client e client, comunicazione tra client e server.

codice fondamentale

server

Processo: crea QWebServer, associa il nuovo callback di connessione e ascolta la disconnessione.

Callback di nuova connessione: quando una nuova connessione viene aggiunta alla raccolta, i callback offline, di ricezione e di errore vengono associati al nuovo socket di connessione.

Pulsante Invia messaggio: classifica tutti e uno, attraversa la raccolta di set e invia utilizzando sendTextMesg

#include "widget.h"
#include "ui_widget.h"
//这个是服务器端
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    /*
     * mode
NonSecureMode: 不安全模式,即不使用SSL/TLS进行通信。这是默认值。
SecureMode: 安全模式,以SSL/TLS安全通信。客户端和服务端之间的连接将使用SSL握手建立安全通道。
AutomaticallyAcceptServerCertificates: 自动接受服务器证书。在SecureMode下,客户端无法验证证书时,自动接受服务器发来的证书以建立连接。
VerifyNone: 不验证证书。以SecureMode运行,但不会验证客户端和服务端使用的证书。
*/
    webServer = new QWebSocketServer("testWebServer",QWebSocketServer::NonSecureMode,this);
    QObject::connect(webServer,&QWebSocketServer::newConnection,this,&Widget::MyselfNewConnectCallBackSlot);
 
    webServer->listen(QHostAddress::Any,8888);
}
void Widget::MyselfNewConnectCallBackSlot(){//新连接回调
 
    if(webServer->hasPendingConnections()){
        QWebSocket* websocket=webServer->nextPendingConnection();
        ui->msgtext->append(websocket->origin()+"客户端已连接到服务器");
        sockets<<websocket;
 
        QListWidgetItem * item =new QListWidgetItem;
        item->setText(websocket->origin());
        ui->clinetls->addItem(item);
 
 
        //绑定离开
        QObject::connect(websocket,&QWebSocket::disconnected,this,[websocket,this](){
            ui->msgtext->append(websocket->origin()+"客户端断开服务器连接");
            sockets.removeOne(websocket);
            for(int i=0;i<ui->clinetls->count();i++)
            {
                QListWidgetItem *item=ui->clinetls->item(i);
 
                if(item->text()==websocket->origin())
                {
                    ui->clinetls->removeItemWidget(item);
                    delete item;
                    break;
                }
            }
 
            websocket->deleteLater();
 
        });
 
 
        //接受消息回调
        QObject::connect(websocket,&QWebSocket::textMessageReceived,this,[this](const QString &msg){
            QJsonDocument doc =QJsonDocument::fromJson(msg.toLatin1().data());
            if(doc.isNull()){
                QWebSocket* websocket =qobject_cast<QWebSocket*>(sender());//sender 触发信号的源头
                ui->msgtext->append("收到客户端消息["+websocket->origin()+"]--->"+msg);
 
            }else{
                //客户端之间的单发消息
                QJsonObject obj=doc.object();
                QString dst=doc["dst"].toString();
                for (auto& socket : sockets) {
                    if(dst == socket->origin()){
                        socket->sendTextMessage(msg);
                    }
                }
            }
        });
 
 
        QObject::connect(websocket,QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
                         this,[this](QAbstractSocket::SocketError error){
            QWebSocket* web =qobject_cast<QWebSocket*>(sender());
            ui->msgtext->append(web->origin()+"出错"+web->errorString());
        });
    }
 
 
 
}
Widget::~Widget()
{
    delete ui;
    for(auto socket:sockets)
    {
        socket->close();
    }
 
    webServer->close();
}
 
 
void Widget::on_sendpb_clicked()
{
    QString send =ui->sendtext->toPlainText().trimmed();
    if(send.isEmpty())return;
    if(ui->allradio->isChecked()){
        //群发
        if(sockets.size()==0)return;
        foreach(auto &socket,sockets){
            socket->sendTextMessage(send);
        }
        ui->msgtext->append("服务器给所有连接发送："+send);
    }else{ //私发  取客户端名称 找 发
        if(!ui->clinetls->currentItem())return;
        QString cname =ui->clinetls->currentItem()->text();
 
        for(auto &socket:sockets)
        {
            if(socket->origin()==cname)
            {
                socket->sendTextMessage(send);
                ui->msgtext->append("服务端给["+socket->origin()+"]发送--->"+send);
 
                break;
            }
        }
    }
 
 
    ui->sendtext->clear();
}

cliente

Fare clic sul pulsante per implementare il processo di connessione websocket: creare websocket, associare vari callback e connettersi tramite open(url)

Pulsante Invia messaggio: classifica i messaggi privati ​​e i messaggi del server, incapsula i messaggi privati ​​in formato json e quindi invia.

#include "widget.h"
#include "ui_widget.h"
#include<QMessageBox>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
 
    websocket=nullptr;
 
}
 
Widget::~Widget()
{
    delete ui;
}
 
 
void Widget::on_sendpb_clicked()
{
    if(!websocket && !websocket->isValid())
            return;
 
    QString send=ui->sendtext->toPlainText().trimmed();
    if(send.isEmpty())return;
 
 
    QString cname =ui->onetextmsg->text().trimmed();
    if(cname.isEmpty()){ //发给服务器
        websocket->sendTextMessage(send);
        ui->msgtext->append("发送消息："+send);
    }else{
        //私聊发
        QJsonObject obj;
        obj["src"]=websocket->origin();
        obj["dst"]=cname;
        obj["msg"]=send;
        //将一个QJsonObject类型的obj转换成JSON字符串。 Compact参数指定格式化方式为紧凑格式(每个元素占一行)。紧凑格式输出结构清晰,容量小,适合传输和存储。
        QString str(QJsonDocument(obj).toJson(QJsonDocument::Compact));
        websocket->sendTextMessage(str);
    }
    ui->sendtext->clear();
 
 
}
 
void Widget::on_connect_clicked()
{
 
    if(websocket == nullptr){
        if(ui->server_addr->text().trimmed().isEmpty()){
            QMessageBox::critical(this,"错误","服务器名称不能为空，请重新检查!",QMessageBox::Yes);
            return;
        }
        //用于移除字符串开头和结尾处的空白字符。 输入: " test " trimmed()后的结果: "test"  VersionLatest使用最新的websocket协议版本。
        websocket=new QWebSocket(ui->client_name->text().trimmed(),QWebSocketProtocol::VersionLatest,this);
 
        //连接回调
        QObject::connect(websocket,&QWebSocket::connected,this,[this](){
            ui->msgtext->append("已经连接上"+websocket->peerAddress().toString());
            isConnecting=true;
            ui->connect->setText("断开服务器");
        });
        //断开回调
        QObject::connect(websocket,&QWebSocket::disconnected,this,[this](){
            ui->msgtext->append("已"+websocket->peerAddress().toString()+"断开连接");
            isConnecting=false;
            ui->connect->setText("连接服务器");
        });
 
        QObject::connect(websocket,QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error)
                         ,this,[this](QAbstractSocket::SocketError){
            ui->msgtext->append(websocket->origin()+"出错"+websocket->errorString());
 
        });
 
 
        //接受消息回调 网上知名bug 当你连续发送 A:A*100 B:200时 接收方：A*100200 通过消息队列方式发送即可
        connect(websocket,&QWebSocket::textMessageReceived
                ,this,[this](const QString &msg){
            QJsonDocument jsd=QJsonDocument::fromJson(msg.toUtf8().data());
 
            if(jsd.isNull()) //解析失败 即没有 c1:c2 客户端与客户端私聊
            {
                ui->msgtext->append("收到消息:"+msg);
            }
            else
            {
                QJsonObject jsobj=jsd.object();
                ui->msgtext->append("收到来自"+jsobj["src"].toString()+"的消息:"+jsobj["msg"].toString());
            }
        },Qt::QueuedConnection);
 
 
 
    }
 
    if(isConnecting){ //连接是成功的
        websocket->close();
        websocket->deleteLater();
        websocket=nullptr;
 
    } else
    {
        websocket->open(QUrl(ui->server_addr->text().trimmed()));
    }
}

Riassumere

In generale, QWebSocket, come componente nella libreria di rete QT, fornisce una serie di API utili per lo sviluppo di client e server WebSocket.

I suoi principali vantaggi sono:

1. Design completamente orientato agli oggetti, l'API è semplice e facile da usare.

2. Altamente integrato con altri componenti di rete QT, come il supporto SSL/proxy.

3. Utilizzando un modello basato sugli eventi, gli sviluppatori non devono occuparsi dei dettagli sottostanti come il multi-threading.

4. Naturalmente integrato con le applicazioni GUI Qt, i messaggi e gli aggiornamenti dell'interfaccia possono essere richiamati direttamente.

5. Fornisce un'implementazione completa delle specifiche di base di WebSocket, che possono essere utilizzate immediatamente per facilitare lo sviluppo.

6. Anche le prestazioni sono buone, soprattutto perché QT5.10 supporta le chiamate I/O asincrone.

7. Sono disponibili numerosi esempi e progetti open source come riferimento e la barriera all'ingresso è bassa.

Alcuni punti da notare includono:

1. Alcuni formati di protocollo websocket estesi non sono supportati e devono essere implementati dall'utente.

2. La corrispondenza dell'ordine di invio e ricezione dei messaggi deve essere controllata dall'utente.

3. Il supporto per la trasmissione di file e streaming di big data non è abbastanza semplice e intuitivo.

4. I puntatori intelligenti sottostanti e i meccanismi di gestione della memoria utilizzati non possono essere modificati.

5. Il supporto per le nuove funzionalità standard C++ è relativamente conservativo.

Nel complesso, QWebSocket fornisce una scelta molto valida e matura per la maggior parte delle applicazioni WebSocket basate su Tcp. Elevata efficienza di sviluppo e pochi bug. Preferito anche per applicazioni QT. Se sono presenti requisiti di livello superiore, è possibile prendere in considerazione altre implementazioni sottostanti. Ma nella maggior parte dei casi QWebSocket è abbastanza buono.

Infine, allega il collegamento al codice sorgente
Se ti è stato utile, per favore, dammi una stella

Demo Qt: imparare il processo qt (gitee.com)