Serveur HTTP simple

Exemple simple de configuration d'un serveur HTTP.

Affichage d'un serveur HTTP simple dans un navigateur

Le serveur HTTP simple montre comment configurer un serveur HTTP à l'aide de la classe ` QHttpServer `. Il écoute sur deux sockets : un socket TCP et un socket SSL. Différentes fonctions de rappel sont configurées pour illustrer l'utilisation de la fonction ` route()`.

Un objet ` QHttpServer ` est créé, et une simple fonction ` route()` gère le chemin "/" en renvoyant Hello world:

QCoreApplication app(argc, argv);

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

Nous enregistrons ensuite un callback qui fournit les ressources du serveur au client :

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

Ici, nous utilisons l’objet ` QHttpServerRequest ` pour renvoyer l’adresse IP du client :

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

Pour l'un des chemins d'accès, "/auth", l'authentification HTTP de base est utilisée :

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

Nous utilisons ensuite la fonction ` addAfterRequestHandler()` pour modifier l’objet ` QHttpServerResponse ` après son traitement par les callbacks enregistrés par ` route()`, en ajoutant des en-têtes HTTP à la réponse :

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

Un QTcpServer écoutant sur un port est associé au serveur HTTP à l'aide de la fonction bind() :

auto tcpserver = std::make_unique<QTcpServer>();
if (!tcpserver->listen()|| !httpServer.bind(tcpserver.get())) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Le serveur n'a pas réussi à écouter sur un port.");
    return-1;
}
quint16 port = tcpserver->serverPort();
tcpserver.release();

Ensuite, la fonction ` QSslConfiguration ` est utilisée pour créer une configuration SSL permettant à QHttpServer de gérer le trafic HTTPS :

QSslConfiguration conf = QSslConfiguration::defaultConfiguration();
const auto sslCertificateChain =
        QSslCertificate::fromPath(QStringLiteral(":/assets/certificate.crt"));
if (sslCertificateChain.empty()) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Impossible de récupérer le certificat SSL à partir du fichier.");
    return-1;
}
QFile privateKeyFile(QStringLiteral(":/assets/private.key"));
if (!privateKeyFile.open(QIODevice::ReadOnly)) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Impossible d'ouvrir le fichier en lecture : %1")
                  .arg(privateKeyFile.errorString());
    return-1;
}

conf.setLocalCertificate(sslCertificateChain.front());
conf.setPrivateKey(QSslKey(&privateKeyFile, QSsl::Rsa));
conf.setAllowedNextProtocols({ QSslConfiguration::ALPNProtocolHTTP2 }); // Ajout de la prise en charge d’HTTP/2

privateKeyFile.close();

auto sslserver = std::make_unique<QSslServer>();
sslserver->setSslConfiguration(conf);
if (!sslserver->listen()|| !httpServer.bind(sslserver.get())) {
    qWarning() << QCoreApplication::translate("QHttpServerExample",
                                             "Le serveur n'a pas réussi à écouter sur un port.");
    return-1;
}
quint16 sslPort = sslserver->serverPort();
sslserver.release();

Une fois la configuration terminée, il ne reste plus qu’à commencer à traiter les requêtes entrantes :

return app.exec();

Fichiers :

Images :

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.