Einfacher HTTP-Server

Einfaches Beispiel für die Einrichtung eines HTTP-Servers.

Einfache HTTP-Serverausgabe im Browser

Der einfache HTTP-Server zeigt, wie man mithilfe der Klasse „ QHttpServer “ einen HTTP-Server einrichtet. Er überwacht zwei Sockets: einen TCP-Socket und einen SSL-Socket. Es werden verschiedene Callbacks eingerichtet, um die Verwendung der Funktion „ route()“ zu veranschaulichen.

Es wird ein ` QHttpServer `-Objekt erstellt, und ein einfacher ` route()`-Callback verarbeitet den Pfad ` "/" `, indem er ` Hello world` zurückgibt:

QCoreApplication app(argc, argv);

QHttpServer httpServer;
httpServer.route("/", []() {
    return "Hello world";
});

Anschließend registrieren wir einen Callback, der die Assets des Servers an den Client ausliefert:

httpServer.route("/assets/<arg>", [] (const QUrl &url) {
    return QHttpServerResponse::fromFile(u":/assets/"_s + url.path());
});

Hier verwenden wir das Objekt „ QHttpServerRequest “, um die IP-Adresse des Clients zurückzugeben:

httpServer.route("/remote_address", [](const QHttpServerRequest &request) {
    return request.remoteAddress().toString();
});

Für einen der Pfade, "/auth", wird die einfache HTTP-Authentifizierung verwendet:

httpServer.route("/auth", [](const QHttpServerRequest &request) {
    auto auth = request.value("authorization").simplified();

    if (auth.size() > 6 && auth.first(6).toLower() == "basic ") {
        auto token = auth.sliced(6);
        auto userPass = QByteArray::fromBase64(token);

        if (auto colon = userPass.indexOf(':'); colon > 0) {
            auto userId = userPass.first(colon);
            auto password = userPass.sliced(colon + 1);

            if (userId == "Aladdin" && password == "open sesame")
                return QHttpServerResponse("text/plain", "Success\n");
        }
    }
    QHttpServerResponse resp("text/plain", "Authentication required\n",
                             QHttpServerResponse::StatusCode::Unauthorized);
    auto h = resp.headers();
    h.append(QHttpHeaders::WellKnownHeader::WWWAuthenticate,
             R"(Basic realm="Simple example", charset="UTF-8")");
    resp.setHeaders(std::move(h));
    return std::move(resp);
});

Anschließend verwenden wir die Funktion ` addAfterRequestHandler()` , um das ` QHttpServerResponse `-Objekt zu ändern, nachdem es von den durch ` route()` registrierten Callbacks verarbeitet wurde, indem wir der Antwort HTTP-Header hinzufügen:

httpServer.addAfterRequestHandler(&httpServer, [](const QHttpServerRequest &, QHttpServerResponse &resp) {
    auto h = resp.headers();
    h.append(QHttpHeaders::WellKnownHeader::Server, "Qt HTTP Server");
    resp.setHeaders(std::move(h));
});

Ein „ QTcpServer “, der auf einem Port lauscht, wird mithilfe der Funktion „ bind()“ an den HTTP-Server gebunden:

auto tcpserver = std::make_unique<QTcpServer>();
if (!tcpserver->listen()|| !httpServer.bind(tcpserver.get())) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Der Server konnte nicht auf einem Port lauschen.");
    return-1;
}
quint16 port = tcpserver->serverPort();
tcpserver.release();

Anschließend wird mit ` QSslConfiguration ` eine SSL-Konfiguration für einen ` QHttpServer ` erstellt, um HTTPS-Datenverkehr zu bedienen:

QSslConfiguration conf = QSslConfiguration::defaultConfiguration();
const auto sslCertificateChain =
        QSslCertificate::fromPath(QStringLiteral(":/assets/certificate.crt"));
if (sslCertificateChain.empty()) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Das SSL-Zertifikat konnte nicht aus der Datei abgerufen werden.");
    return-1;
}
QFile privateKeyFile(QStringLiteral(":/assets/private.key"));
if (!privateKeyFile.open(QIODevice::ReadOnly)) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Datei konnte nicht zum Lesen geöffnet werden: %1")
                  .arg(privateKeyFile.errorString());
    return-1;
}

conf.setLocalCertificate(sslCertificateChain.front());
conf.setPrivateKey(QSslKey(&privateKeyFile, QSsl::Rsa));
conf.setAllowedNextProtocols({ QSslConfiguration::ALPNProtocolHTTP2 }); // HTTP/2-Unterstützung hinzufügen

privateKeyFile.close();

auto sslserver = std::make_unique<QSslServer>();
sslserver->setSslConfiguration(conf);
if (!sslserver->listen()|| !httpServer.bind(sslserver.get())) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Der Server konnte nicht auf einem Port empfangen.");
    return-1;
}
quint16 sslPort = sslserver->serverPort();
sslserver.release();

Nachdem alles eingerichtet ist, müssen nur noch eingehende Anfragen bearbeitet werden:

return app.exec();

Dateien:

Bilder:

simple/assets/qt-logo.png

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.