Compartir tecnología

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

Objetivos de aprendizaje: Programación de redes Qt QWebSocket

Pre-entorno de aprendizaje

Comunicación de red multiproceso QT TCP-CSDN Blog

Contenido de aprendizaje

WebSocket es una tecnología de red que proporciona un canal de comunicación full-duplex a través de una única conexión TCP. En 2011, IETF estandarizó el protocolo WebSocket como RFC6455 y QWebSocket se puede utilizar tanto en aplicaciones cliente como en aplicaciones de servidor.

Implementa comunicación full-duplex entre el navegador y el servidor, permitiendo al servidor enviar información de forma proactiva al cliente.

caracteristica principal:

1. A diferencia de HTTP, WebSocket permite que el servidor envíe datos activamente al cliente sin necesidad de que el cliente inicie una solicitud.

2. Construida sobre el protocolo TCP, la comunicación full-duplex se realiza entre el servidor y el cliente en un único puerto a través del protocolo Ws (WebSocket).

3. Admite la transmisión de datos en formato texto o binario.

4. El protocolo se basa en una única conexión TCP. El servidor y el cliente solo necesitan crear una conexión y la conexión no se cerrará.

5. Admite bibliotecas del lado del cliente y del servidor en múltiples lenguajes de programación, como JavaScript, Java, C#, Python, etc.

Escenarios de aplicación comunes:

1. Sala de chat: admite conversaciones en tiempo real de baja latencia.

2. Juego en línea: un motor de sincronización que requiere sincronización en tiempo real del estado del juego.

3. Cotizaciones de acciones: software de cotizaciones que necesita enviar cotizaciones en tiempo real al cliente.

4. Videoconferencia: se requiere comunicación de voz y vídeo en tiempo real y de baja latencia.

5. Edición colaborativa en tiempo real: por ejemplo, el editor de código en línea requiere sincronización en tiempo real.

QWebSocket es la biblioteca de funciones WebSocket proporcionada por Qt. Está construido sobre el módulo de red Qt e implementa el protocolo WebSocket en el estándar RFC6455. Debe agregar QT+=websockets al archivo Qmake

1. QWebSocket solo admite formatos de mensajes de texto/binarios y no admite otros formatos extendidos. Si es necesario agregar otros protocolos personalizados, los desarrolladores deben manejarlos ellos mismos en la capa de aplicación.

2. Admite el acceso a servicios websocket utilizando los puertos http/https estándar 80/443 y también admite el protocolo wss (websocket cifrado). Por lo que puede interactuar fácilmente con los servidores web existentes.

3. Dado que se basa en la implementación del socket QT CP, es totalmente compatible con todas las funciones de la red Qt, como la configuración de proxy, la configuración SSL, etc. Esto es más fácil de usar que algunas interfaces C de bajo nivel.

4. Admite modos de conexión tanto activos como pasivos. Las conexiones activas se realizan a través de connectToHost() y las conexiones pasivas se aceptan a través del puerto de escucha aceptar(). Ambos modos son muy convenientes.

5. Para las aplicaciones QT GUI, la recepción de mensajes y las actualizaciones de la interfaz se pueden realizar fácilmente, evitando la complejidad de la programación multiproceso. Por ejemplo, simplemente actualice la interfaz directamente en textMessageReceived().

6. Después de QT5.10, se admite E/S asíncrona y el rendimiento ha mejorado ligeramente en comparación con antes. La compatibilidad con extensiones de red también es mejor.

Funciones miembro comunes de 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可以绑定消息发送断开连接的异常处理等。

Ambas funciones sendTextMessage y writeTextMessage se pueden utilizar para enviar mensajes de texto, pero tienen algunas diferencias:

1. La definición de la función es diferente:

• sendTextMessage pertenece a la función miembro de QWebSocket;

• writeTextMessage es una función miembro de QAbstractSocket y QWebSocket hereda de QAbstractSocket.

1. La eficiencia del envío es diferente:

• Internamente, sendTextMessage primero convertirá el mensaje a QByteArray y luego lo enviará a través de la función de escritura, que es una conversión más;

• writeTextMessage escribe directamente el QString que debe enviarse, lo cual es un poco más eficiente.

1. El soporte asíncrono es diferente:

• sendTextMessage es una operación sincrónica y regresará una vez completado el envío;

• writeTextMessage admite llamadas asincrónicas y la función de devolución de llamada se puede especificar a través de Lambda.

1. El manejo de errores es diferente:

• sendTextMessage no devolverá información de error y solo se puede manejar mediante errores de señal;

• writeTextMessage puede obtener el código de error devuelto para determinar la situación del envío.

1. Diferentes escenarios de uso:

• sendTextMessage se centra en WebSocket y es adecuado para llamar a la API de WebSocket;

• writeTextMessage es más general y se puede utilizar con otras subclases de QAbstractSocket.

En general:

• sendTextMessage es más sencillo de usar, está bien encapsulado y es adecuado para uso básico;

• writeTextMessage es un poco más eficiente, admite más funciones, como el manejo asincrónico y de errores, y es adecuado para escenarios con requisitos de alto rendimiento o control.

Realizar el proyecto

Comunicación privada entre cliente y cliente, comunicación entre cliente y servidor.

código central

Servidor

Proceso: cree QWebServer, vincule una nueva devolución de llamada de conexión y escuche la desconexión.

Nueva devolución de llamada de conexión: cuando se agrega una nueva conexión a la colección, las devoluciones de llamada fuera de línea, de recepción y de error están vinculadas al nuevo socket de conexión.

Botón Enviar mensaje: clasifica todos y uno, recorre la colección establecida y envía usando 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

Haga clic en el botón para implementar el proceso de conexión de websocket: cree websocket, vincule varias devoluciones de llamada y conéctese a través de open (url)

Botón Enviar mensaje: clasifique los mensajes privados y los mensajes del servidor, encapsule los mensajes privados en formato json y luego envíelos.

#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()));
    }
}

Resumir

En general, QWebSocket, como componente de la biblioteca de red QT, proporciona un conjunto de API convenientes para desarrollar clientes y servidores WebSocket.

Sus principales ventajas son:

1. Diseño completamente orientado a objetos, API es simple y fácil de usar.

2. Altamente integrado con otros componentes de la red QT, como soporte SSL/proxy.

3. Al utilizar un modelo basado en eventos, los desarrolladores no necesitan lidiar con detalles subyacentes como los subprocesos múltiples.

4. Naturalmente integrado con las aplicaciones Qt GUI, los mensajes y las actualizaciones de la interfaz se pueden llamar directamente.

5. Proporciona una implementación completa de las especificaciones básicas de WebSocket, que se pueden utilizar de forma inmediata para facilitar el desarrollo.

6. El rendimiento también es bueno, especialmente porque QT5.10 admite llamadas de E/S asíncronas.

7. Hay ejemplos ricos y proyectos de código abierto disponibles como referencia, y la barrera de entrada es baja.

Algunos puntos a tener en cuenta incluyen:

1. Algunos formatos de protocolo websocket extendido no son compatibles y deben implementarse usted mismo.

2. Usted debe controlar el orden de coincidencia del envío y la recepción de mensajes.

3. El soporte para la transmisión de big data de archivos y streaming no es lo suficientemente amigable y sencillo.

4. Los punteros inteligentes subyacentes y los mecanismos de gestión de memoria utilizados no se pueden cambiar.

5. El soporte para nuevas características estándar de C++ es relativamente conservador.

En general, QWebSocket proporciona una opción muy buena y madura para la mayoría de las aplicaciones WebSocket basadas en TCP. Alta eficiencia de desarrollo y pocos errores. También se prefiere para aplicaciones QT. Si existen requisitos de nivel superior, se pueden considerar otras implementaciones subyacentes. Pero en la mayoría de los casos, QWebSocket es suficiente.

Finalmente, adjunte el enlace del código fuente.
Si te es útil por favor dame una estrella.

Demostración de Qt: aprendizaje del proceso qt (gitee.com)