Compartilhamento de tecnologia

Programação de rede Qt QWebSocket

2024-07-12

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

Objetivos de aprendizagem: programação de rede Qt QWebSocket

Pré-ambiente de aprendizagem

Comunicação de rede multithread QT TCP - CSDN Blog

Conteúdo de aprendizagem

WebSocket é uma tecnologia de rede que fornece um canal de comunicação full-duplex em uma única conexão TCP. Em 2011, a IETF padronizou o protocolo WebSocket como RFC6455, e o QWebSocket pode ser usado tanto em aplicativos cliente quanto em aplicativos de servidor.

Ele implementa comunicação full-duplex entre o navegador e o servidor, permitindo que o servidor envie informações proativamente ao cliente.

Característica principal:

  1. Ao contrário do HTTP, o WebSocket permite que o servidor envie dados ativamente ao cliente sem exigir que o cliente inicie uma solicitação.

  2. Construída no protocolo TCP, a comunicação full-duplex é realizada entre o servidor e o cliente em uma única porta através do protocolo Ws (WebSocket).

  3. Suporta transmissão de dados em formato texto ou binário.

  4. O protocolo é construído em uma única conexão TCP. O servidor e o cliente só precisam criar uma conexão e a conexão não será fechada.

  5. Suporta bibliotecas do lado do cliente e do servidor em várias linguagens de programação, como JavaScript, Java, C#, Python, etc.

Cenários de aplicação comuns:

  1. Sala de bate-papo: suporta conversas em tempo real de baixa latência.

  2. Jogo online: um mecanismo de sincronização que requer sincronização em tempo real do status do jogo.

  3. Cotações de ações: software de cotação que precisa enviar cotações em tempo real ao cliente.

  4. Videoconferência: É necessária comunicação de voz e vídeo em tempo real e baixa latência.

  5. Edição colaborativa em tempo real: por exemplo, o editor de código online requer sincronização em tempo real.

QWebSocket é a biblioteca de funções WebSocket fornecida pelo Qt. Ele é construído no módulo de rede Qt e implementa o protocolo WebSocket no padrão RFC6455. Você precisa adicionar QT+=websockets ao arquivo Qmake

  1. QWebSocket oferece suporte apenas a formatos de mensagem de texto/binários e não oferece suporte a outros formatos estendidos. Se outros protocolos personalizados precisarem ser adicionados, os desenvolvedores precisarão cuidar disso na camada de aplicativo.

  2. Ele suporta acesso a serviços websocket usando portas http/https padrão 80/443 e também suporta protocolo wss (websocket criptografado). Assim, ele pode interagir facilmente com servidores web existentes.

  3. Uma vez que é baseado na implementação do soquete QT CP, ele suporta totalmente todas as funções da rede Qt, como configurações de proxy, configuração SSL, etc. Isso é mais fácil de usar do que algumas interfaces C de baixo nível.

  4. Ele suporta modos de conexão ativos e passivos. As conexões ativas são feitas por meio de connectToHost() e as conexões passivas são aceitas por meio da porta de escuta accept(). Ambos os modos são muito convenientes.

  5. Para aplicações QT GUI, a recepção de mensagens e atualizações de interface podem ser facilmente realizadas, evitando a complexidade da programação multithread. Por exemplo, basta atualizar a interface diretamente em textMessageReceived().

  6. Após o QT5.10, a E/S assíncrona é suportada e o desempenho é ligeiramente melhorado em comparação com antes. O suporte para extensões de rede também é melhor.

Funções de membro comuns QWebSocket

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

As funções sendTextMessage e writeTextMessage podem ser usadas para enviar mensagens de texto, mas têm algumas diferenças:

  1. A definição da função é diferente:

  • sendTextMessage pertence à função membro de QWebSocket;

  • writeTextMessage é uma função membro de QAbstractSocket e QWebSocket herda de QAbstractSocket.

  1. A eficiência de envio é diferente:

  • Internamente, sendTextMessage converterá primeiro a mensagem em QByteArray e depois a enviará por meio da função de gravação, que é mais uma conversão;

  • writeTextMessage grava diretamente o QString que precisa ser enviado, o que é um pouco mais eficiente.

  1. O suporte assíncrono é diferente:

  • sendTextMessage é uma operação síncrona e retornará após a conclusão do envio;

  • writeTextMessage oferece suporte a chamadas assíncronas e a função de retorno de chamada pode ser especificada por meio do Lambda.

  1. O tratamento de erros é diferente:

  • sendTextMessage não retornará informações de erro e só poderá ser tratado por meio de erros de sinal;

  • writeTextMessage pode obter o código de erro retornado para determinar a situação de envio.

  1. Diferentes cenários de uso:

  • sendTextMessage concentra-se em WebSocket e é adequado para chamar a API WebSocket;

  • writeTextMessage é mais geral e pode ser usado com outras subclasses QAbstractSocket.

Em geral:

  • sendTextMessage é mais simples de usar, bem encapsulado e adequado para uso básico;

  • writeTextMessage é um pouco mais eficiente, oferece suporte a mais recursos, como tratamento assíncrono e de erros, e é adequado para cenários com alto desempenho ou requisitos de controle.

Realize o projeto

Comunicação privada entre cliente e cliente, comunicação entre cliente e servidor.

código principal

Servidor

Processo: Crie QWebServer, vincule o novo retorno de chamada de conexão e ouça a desconexão.

Novo retorno de chamada de conexão: quando uma nova conexão é adicionada à coleção, os retornos de chamada offline, de recebimento e de erro são vinculados ao novo soquete de conexão.

Botão Enviar mensagem: classifique todos e um, percorra a coleção definida e envie usando sendTextMesg

  1. #include "widget.h"
  2. #include "ui_widget.h"
  3. //这个是服务器端
  4. Widget::Widget(QWidget *parent)
  5.     : QWidget(parent)
  6.     , ui(new Ui::Widget)
  7. {
  8.     ui->setupUi(this);
  9.     /*
  10.      * mode
  11. NonSecureMode: 不安全模式,即不使用SSL/TLS进行通信。这是默认值。
  12. SecureMode: 安全模式,以SSL/TLS安全通信。客户端和服务端之间的连接将使用SSL握手建立安全通道。
  13. AutomaticallyAcceptServerCertificates: 自动接受服务器证书。在SecureMode下,客户端无法验证证书时,自动接受服务器发来的证书以建立连接。
  14. VerifyNone: 不验证证书。以SecureMode运行,但不会验证客户端和服务端使用的证书。
  15. */
  16.     webServer = new QWebSocketServer("testWebServer",QWebSocketServer::NonSecureMode,this);
  17.     QObject::connect(webServer,&QWebSocketServer::newConnection,this,&Widget::MyselfNewConnectCallBackSlot);
  18.  
  19.     webServer->listen(QHostAddress::Any,8888);
  20. }
  21. void Widget::MyselfNewConnectCallBackSlot(){//新连接回调
  22.  
  23.     if(webServer->hasPendingConnections()){
  24.         QWebSocket* websocket=webServer->nextPendingConnection();
  25.         ui->msgtext->append(websocket->origin()+"客户端已连接到服务器");
  26.         sockets<<websocket;
  27.  
  28.         QListWidgetItem * item =new QListWidgetItem;
  29.         item->setText(websocket->origin());
  30.         ui->clinetls->addItem(item);
  31.  
  32.  
  33.         //绑定离开
  34.         QObject::connect(websocket,&QWebSocket::disconnected,this,[websocket,this](){
  35.             ui->msgtext->append(websocket->origin()+"客户端断开服务器连接");
  36.             sockets.removeOne(websocket);
  37.             for(int i=0;i<ui->clinetls->count();i++)
  38.             {
  39.                 QListWidgetItem *item=ui->clinetls->item(i);
  40.  
  41.                 if(item->text()==websocket->origin())
  42.                 {
  43.                     ui->clinetls->removeItemWidget(item);
  44.                     delete item;
  45.                     break;
  46.                 }
  47.             }
  48.  
  49.             websocket->deleteLater();
  50.  
  51.         });
  52.  
  53.  
  54.         //接受消息回调
  55.         QObject::connect(websocket,&QWebSocket::textMessageReceived,this,[this](const QString &msg){
  56.             QJsonDocument doc =QJsonDocument::fromJson(msg.toLatin1().data());
  57.             if(doc.isNull()){
  58.                 QWebSocket* websocket =qobject_cast<QWebSocket*>(sender());//sender 触发信号的源头
  59.                 ui->msgtext->append("收到客户端消息["+websocket->origin()+"]--->"+msg);
  60.  
  61.             }else{
  62.                 //客户端之间的单发消息
  63.                 QJsonObject obj=doc.object();
  64.                 QString dst=doc["dst"].toString();
  65.                 for (auto& socket : sockets) {
  66.                     if(dst == socket->origin()){
  67.                         socket->sendTextMessage(msg);
  68.                     }
  69.                 }
  70.             }
  71.         });
  72.  
  73.  
  74.         QObject::connect(websocket,QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
  75.                          this,[this](QAbstractSocket::SocketError error){
  76.             QWebSocket* web =qobject_cast<QWebSocket*>(sender());
  77.             ui->msgtext->append(web->origin()+"出错"+web->errorString());
  78.         });
  79.     }
  80.  
  81.  
  82.  
  83. }
  84. Widget::~Widget()
  85. {
  86.     delete ui;
  87.     for(auto socket:sockets)
  88.     {
  89.         socket->close();
  90.     }
  91.  
  92.     webServer->close();
  93. }
  94.  
  95.  
  96. void Widget::on_sendpb_clicked()
  97. {
  98.     QString send =ui->sendtext->toPlainText().trimmed();
  99.     if(send.isEmpty())return;
  100.     if(ui->allradio->isChecked()){
  101.         //群发
  102.         if(sockets.size()==0)return;
  103.         foreach(auto &socket,sockets){
  104.             socket->sendTextMessage(send);
  105.         }
  106.         ui->msgtext->append("服务器给所有连接发送："+send);
  107.     }else{ //私发  取客户端名称 找 发
  108.         if(!ui->clinetls->currentItem())return;
  109.         QString cname =ui->clinetls->currentItem()->text();
  110.  
  111.         for(auto &socket:sockets)
  112.         {
  113.             if(socket->origin()==cname)
  114.             {
  115.                 socket->sendTextMessage(send);
  116.                 ui->msgtext->append("服务端给["+socket->origin()+"]发送--->"+send);
  117.  
  118.                 break;
  119.             }
  120.         }
  121.     }
  122.  
  123.  
  124.     ui->sendtext->clear();
  125. }

cliente

Clique no botão para implementar o processo de conexão do websocket: crie o websocket, vincule vários retornos de chamada e conecte-se por meio de open(url)

Botão Enviar mensagem: classifica mensagens privadas e mensagens do servidor, encapsula mensagens privadas no formato JSON e depois envia.

  1. #include "widget.h"
  2. #include "ui_widget.h"
  3. #include<QMessageBox>
  4. Widget::Widget(QWidget *parent)
  5.     : QWidget(parent)
  6.     , ui(new Ui::Widget)
  7. {
  8.     ui->setupUi(this);
  9.  
  10.     websocket=nullptr;
  11.  
  12. }
  13.  
  14. Widget::~Widget()
  15. {
  16.     delete ui;
  17. }
  18.  
  19.  
  20. void Widget::on_sendpb_clicked()
  21. {
  22.     if(!websocket && !websocket->isValid())
  23.             return;
  24.  
  25.     QString send=ui->sendtext->toPlainText().trimmed();
  26.     if(send.isEmpty())return;
  27.  
  28.  
  29.     QString cname =ui->onetextmsg->text().trimmed();
  30.     if(cname.isEmpty()){ //发给服务器
  31.         websocket->sendTextMessage(send);
  32.         ui->msgtext->append("发送消息："+send);
  33.     }else{
  34.         //私聊发
  35.         QJsonObject obj;
  36.         obj["src"]=websocket->origin();
  37.         obj["dst"]=cname;
  38.         obj["msg"]=send;
  39.         //将一个QJsonObject类型的obj转换成JSON字符串。 Compact参数指定格式化方式为紧凑格式(每个元素占一行)。紧凑格式输出结构清晰,容量小,适合传输和存储。
  40.         QString str(QJsonDocument(obj).toJson(QJsonDocument::Compact));
  41.         websocket->sendTextMessage(str);
  42.     }
  43.     ui->sendtext->clear();
  44.  
  45.  
  46. }
  47.  
  48. void Widget::on_connect_clicked()
  49. {
  50.  
  51.     if(websocket == nullptr){
  52.         if(ui->server_addr->text().trimmed().isEmpty()){
  53.             QMessageBox::critical(this,"错误","服务器名称不能为空，请重新检查!",QMessageBox::Yes);
  54.             return;
  55.         }
  56.         //用于移除字符串开头和结尾处的空白字符。 输入: " test " trimmed()后的结果: "test"  VersionLatest使用最新的websocket协议版本。
  57.         websocket=new QWebSocket(ui->client_name->text().trimmed(),QWebSocketProtocol::VersionLatest,this);
  58.  
  59.         //连接回调
  60.         QObject::connect(websocket,&QWebSocket::connected,this,[this](){
  61.             ui->msgtext->append("已经连接上"+websocket->peerAddress().toString());
  62.             isConnecting=true;
  63.             ui->connect->setText("断开服务器");
  64.         });
  65.         //断开回调
  66.         QObject::connect(websocket,&QWebSocket::disconnected,this,[this](){
  67.             ui->msgtext->append("已"+websocket->peerAddress().toString()+"断开连接");
  68.             isConnecting=false;
  69.             ui->connect->setText("连接服务器");
  70.         });
  71.  
  72.         QObject::connect(websocket,QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error)
  73.                          ,this,[this](QAbstractSocket::SocketError){
  74.             ui->msgtext->append(websocket->origin()+"出错"+websocket->errorString());
  75.  
  76.         });
  77.  
  78.  
  79.         //接受消息回调 网上知名bug 当你连续发送 A:A*100 B:200时 接收方：A*100200 通过消息队列方式发送即可
  80.         connect(websocket,&QWebSocket::textMessageReceived
  81.                 ,this,[this](const QString &msg){
  82.             QJsonDocument jsd=QJsonDocument::fromJson(msg.toUtf8().data());
  83.  
  84.             if(jsd.isNull()) //解析失败 即没有 c1:c2 客户端与客户端私聊
  85.             {
  86.                 ui->msgtext->append("收到消息:"+msg);
  87.             }
  88.             else
  89.             {
  90.                 QJsonObject jsobj=jsd.object();
  91.                 ui->msgtext->append("收到来自"+jsobj["src"].toString()+"的消息:"+jsobj["msg"].toString());
  92.             }
  93.         },Qt::QueuedConnection);
  94.  
  95.  
  96.  
  97.     }
  98.  
  99.     if(isConnecting){ //连接是成功的
  100.         websocket->close();
  101.         websocket->deleteLater();
  102.         websocket=nullptr;
  103.  
  104.     } else
  105.     {
  106.         websocket->open(QUrl(ui->server_addr->text().trimmed()));
  107.     }
  108. }

Resumir

Em geral, QWebSocket, como um componente da biblioteca de rede QT, fornece um conjunto de APIs convenientes para desenvolver clientes e servidores WebSocket.

Suas principais vantagens são:

  1. Design totalmente orientado a objetos, a API é simples e fácil de usar.

  2. Altamente integrado com outros componentes de rede QT, como suporte SSL/proxy.

  3. Usando um modelo orientado a eventos, os desenvolvedores não precisam lidar com detalhes subjacentes, como multithreading.

  4. Naturalmente integrado com aplicativos Qt GUI, mensagens e atualizações de interface podem ser chamadas diretamente.

  5. Fornece uma implementação completa das especificações básicas do WebSocket, que podem ser usadas imediatamente para facilitar o desenvolvimento.

  6. O desempenho também é bom, especialmente porque o QT5.10 suporta chamadas de E/S assíncronas.

  7. Exemplos ricos e projetos de código aberto estão disponíveis para referência e a barreira de entrada é baixa.

Alguns pontos a serem observados incluem:

  1. Alguns formatos de protocolo websocket estendidos não são suportados e precisam ser implementados por você mesmo.

  2. A correspondência da ordem de envio e recebimento de mensagens precisa ser controlada por você mesmo.

  3. O suporte à transmissão de big data de arquivos e streaming não é amigável e direto o suficiente.

  4. Os ponteiros inteligentes subjacentes e os mecanismos de gerenciamento de memória usados ​​não podem ser alterados.

  5. O suporte para novos recursos padrão do C++ é relativamente conservador.

No geral, QWebSocket oferece uma escolha muito boa e madura para a maioria dos aplicativos WebSocket baseados em TCP. Alta eficiência de desenvolvimento e poucos bugs. Também preferido para aplicações QT. Se houver requisitos de nível superior, outras implementações subjacentes poderão ser consideradas. Mas, na maioria dos casos, QWebSocket é bom o suficiente.

Por fim, anexe o link do código-fonte
Se for útil para você, por favor me dê uma estrela

Demonstração Qt: aprendendo o processo qt (gitee.com)

Perfil pessoal

Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.

minhas informações de contato

Correspondência