QT：用QWebSocket实现webchannel，实现C++与HTML通信

基本原理是通过channel将C++对象暴露给HTML，在HTML中调用qwebchannel.js。前提是建立transport，QT只提供了一个抽象基类QWebChannelAbstractTransport，需要自己进行实现，官方建议用QWebSocket实现，并给出了实例。

1、实现Transport类，内置一个WebSocket套接字；

2、实现新的channel类，内置一个WebSocketServer;

3、利用新的channel注册C++对象，从而HTML可以使用该对象；

4、通过以下三种方式进行C++与HTML的交互：

4.1 在HTML中l连接C++ signal与js函数的

object.signal.connect(function(){});

4.2 在HTML中调用C++ public slots函数；

4.3 在HTML中调用C++ Q_INVOKABLE修饰的函数；

下面给出实例代码

5.1 WebSocketTransport类

websockettransport.h

 #ifndef WEBSOCKETTRANSPORT_H
 #define WEBSOCKETTRANSPORT_H

 #include <QWebChannelAbstractTransport>

 QT_BEGIN_NAMESPACE
 class QWebSocket;
 QT_END_NAMESPACE

 class WebSocketTransport : public QWebChannelAbstractTransport
 {
     Q_OBJECT
 public:
     explicit WebSocketTransport(QWebSocket *socket);
     virtual ~WebSocketTransport();

     void sendMessage(const QJsonObject &message) override;

 private slots:
     void textMessageReceived(const QString &message);

 private:
     QWebSocket *m_socket;
 };

 #endif // WEBSOCKETTRANSPORT_H

websockettransport.cpp

 #include "websockettransport.h"

 #include <QDebug>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QWebSocket>

 /*!
     Construct the transport object and wrap the given socket.

     The socket is also set as the parent of the transport object.
 */
 WebSocketTransport::WebSocketTransport(QWebSocket *socket)
 : QWebChannelAbstractTransport(socket)
 , m_socket(socket)
 {
     connect(socket, &QWebSocket::textMessageReceived,
             this, &WebSocketTransport::textMessageReceived);
     connect(socket, &QWebSocket::disconnected,
             this, &WebSocketTransport::deleteLater);
 }

 /*!
     Destroys the WebSocketTransport.
 */
 WebSocketTransport::~WebSocketTransport()
 {
     m_socket->deleteLater();
 }

 /*!
     Serialize the JSON message and send it as a text message via the WebSocket to the client.
 */
 void WebSocketTransport::sendMessage(const QJsonObject &message)
 {
     QJsonDocument doc(message);
     m_socket->sendTextMessage(QString::fromUtf8(doc.toJson(QJsonDocument::Compact)));
 }

 /*!
     Deserialize the stringified JSON messageData and emit messageReceived.
 */
 void WebSocketTransport::textMessageReceived(const QString &messageData)
 {
     QJsonParseError error;
     QJsonDocument message = QJsonDocument::fromJson(messageData.toUtf8(), &error);
     if (error.error) {
         qWarning() << "Failed to parse text message as JSON object:" << messageData
                    << "Error is:" << error.errorString();
         return;
     } else if (!message.isObject()) {
         qWarning() << "Received JSON message that is not an object: " << messageData;
         return;
     }
     emit messageReceived(message.object(), this);
 }

5.2 WebSocketChannel类

websocketchannel.h

#ifndef WEBSOCKETCHANNEL_H
#define WEBSOCKETCHANNEL_H

#include <QWebChannel>

class QWebSocketServer;
class WebSocketTransport;

//继承QWebchannel类，在内部建立socket server与transport中socket的连接

class WebSocketChannel : public QWebChannel
{
    Q_OBJECT
public:
    WebSocketChannel(QWebSocketServer *server);

signals:
    void clientConnected(WebSocketTransport *client);

private slots:
    void handleNewConnection();

private:
    QWebSocketServer *_server;
};

#endif // WEBSOCKETCHANNEL_H

websocketchannel.cpp

#include "websocketchannel.h"
#include <QWebSocketServer>
#include "websockettransport.h"

WebSocketChannel::WebSocketChannel(QWebSocketServer *server)
    :_server(server)
{
    connect(server, &QWebSocketServer::newConnection,
            this, &WebSocketChannel::handleNewConnection);

    connect(this, &WebSocketChannel::clientConnected,
            this, &WebSocketChannel::connectTo);//connectTo槽继承自QWebchannel
}

void WebSocketChannel::handleNewConnection()
{
    emit clientConnected(new WebSocketTransport(_server->nextPendingConnection()));
}

main.cpp

#include <QApplication>
#include <QDesktopServices>
#include <QDialog>
#include <QDir>
#include <QFileInfo>
#include <QUrl>
#include <QWebChannel>
#include <QWebSocketServer>

int main(int argc, char** argv)
{
    QApplication app(argc, argv);

    //建立QWebSocketServer，url是ws://localhost:12345

    QWebSocketServer server(QStringLiteral("QWebChannel Standalone Example Server"), QWebSocketServer::NonSecureMode);
    if (!server.listen(QHostAddress::LocalHost, )) {
        qFatal("Failed to open web socket server.");
        return ;
    }

    //建立websocketchannl,该channel就可以用来通信了
    WebSocketChannel channel(&server);

    // setup the UI
    Dialog dialog;

    // setup the core and publish it to the QWebChannel
    Core core(&dialog);

    //注册C++对象，该类要继承自QObject
    channel.registerObject(QStringLiteral("core"), &core);

    // open a browser window with the client HTML page
    QUrl url = QUrl::fromLocalFile(BUILD_DIR "/index.html");
    QDesktopServices::openUrl(url);

    dialog.displayMessage(Dialog::tr("Initialization complete, opening browser at %1.").arg(url.toDisplayString()));
    dialog.show();

    return app.exec();
}

index.html

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
         //使用qwebchannel.js
        <script type="text/javascript" src="./qwebchannel.js"></script>
        <script type="text/javascript">
            //BEGIN SETUP
            function output(message) {
                var output = document.getElementById("output");
                output.innerHTML = output.innerHTML + message + "\n";
            }
            window.onload = function() {
                var baseUrl = "ws://localhost:12345";

                output("Connecting to WebSocket server at " + baseUrl + ".");
                var socket = new WebSocket(baseUrl);

                socket.onclose = function() {
                    console.error("web channel closed");
                };
                socket.onerror = function(error) {
                    console.error("web channel error: " + error);
                };
                socket.onopen = function() {
                    output("WebSocket connected, setting up QWebChannel.");
                    new QWebChannel(socket, function(channel) {
                        // make core object accessible globally
                        window.core = channel.objects.core;

                        document.getElementById("send").onclick = function() {
                            var input = document.getElementById("input");
                            var text = input.value;
                            if (!text) {
                                return;
                            }

                            output("Sent message: " + text);
                            input.value = "";

                            //调用C++公有槽函数
                            core.receiveText(text);
                            core.hello(text);
                        }

                        //连接C++信号与javascript函数
                        core.sendText.connect(function(message) {
                            output("Received message: " + message);
                        });

                        core.receiveText("Client connected, ready to send/receive messages!");
                        output("Connected to WebChannel, ready to send/receive messages!");
                    });
                }
            }
            //END SETUP
        </script>
        <style type="text/css">
            html {
                height: 100%;
                width: 100%;
            }
            #input {
                width: 400px;
                margin: 0 10px 0 0;
            }
            #send {
                width: 90px;
                margin: 0;
            }
            #output {
                width: 500px;
                height: 300px;
            }
        </style>
    </head>
    <body>
        <textarea id="output"></textarea><br />
        <input id="input" /><input type="submit" id="send" value="Send" onclick="javascript:click();" />
    </body>
</html>

结果如下：