QHttpServer Class

Dokumentation der Mitgliederfunktionen

[explicit] QHttpServer::QHttpServer(QObject *parent = nullptr)

Erzeugt eine Instanz von QHttpServer mit übergeordnetem parent.

[override virtual noexcept] QHttpServer::~QHttpServer()

Zerstört eine QHttpServer.

template <typename Functor> void QHttpServer::addAfterRequestHandler(const QObject *context, Functor &&slot)

Registrieren Sie context und slot, die nach jeder Bearbeitung einer Anfrage aufgerufen werden.

Die slot muss die Signatur void (*)(const QHttpServerRequest &, QHttpServerResponse &) implementieren.

Die slot kann auch ein Funktionszeiger, ein nicht veränderbares Lambda oder eine andere kopierbare aufrufbare Variable mit dem Operator const call sein. In diesem Fall ist context ein Kontextobjekt und der Handler ist gültig, bis das Kontextobjekt zerstört wird.

Beispiel:

server.addAfterRequestHandler(&server, [] (const QHttpServerRequest &req, QHttpServerResponse &resp) {
    auto h = resp.headers();
    h.append(QHttpHeaders::WellKnownHeader::Cookie, "PollyWants=Cracker");
    resp.setHeaders(std::move(h));
}

void QHttpServer::clearMissingHandler()

Setzt den Handler auf den Standard-Handler zurück, der Antworten mit dem Status 404 Not Found erzeugt.

Siehe auch setMissingHandler.

template <typename Rule = QHttpServerRouterRule, typename Functor> Rule *QHttpServer::route(const QString &pathPattern, QHttpServerRequest::Methods method, const QObject *context, Functor &&slot)

Diese Methode fügt ein neues Routing Rule zum QHttpServerRouter Member des Servers hinzu. Der Schablonenparameter Rule kann eine beliebige von QHttpServerRouterRule abgeleitete Klasse sein. Die Parameter werden an Rule übergeben. Der Server vergleicht eingehende HTTP-Anfragen mit registrierten Regeln, die auf dem URL-Pfad und der HTTP-Methode basieren, und die erste Übereinstimmung von beiden wird ausgeführt.

Der Parameter pathPattern wird mit dem path() der URL der eingehenden Anfrage verglichen. Der Parameter method wird mit der HTTP-Methode der eingehenden Anfrage verglichen. Der Parameter slot ist der Request-Handler. Er kann ein Zeiger auf eine Mitgliedsfunktion von context, ein Funktionszeiger, ein nicht veränderbares Lambda oder eine kopierbare aufrufbare Funktion mit einem const-Aufrufoperator sein. Wenn context angegeben wird, bleibt die Regel so lange gültig, wie der Kontext existiert. context muss die gleiche Thread-Affinität haben wie QHttpServer.

Die slot nimmt als Argumente eine beliebige Anzahl von geparsten Argumenten, die aus der pathPattern durch Übereinstimmung mit den "<arg>" Platzhaltern extrahiert werden, gefolgt von einem optionalen QHttpServerRequest und einem optionalen QHttpServerResponder. Diese beiden Klassen werden als "specials" bezeichnet.

Die slot kann einen QHttpServerResponse oder einen konvertierbaren Typ zurückgeben:

QHttpServer server;
server.route("/test/", this, [] () { return ""; });

Wenn alternativ ein optionales QHttpServerResponder Argument angegeben wird, muss die Antwort mit diesem geschrieben werden und die Funktion muss void oder QFuture<void> zurückgeben. QFuture<void> Unterstützung wurde in Qt 6.11 hinzugefügt. QHttpServerResponder ist nicht kopierbar und kann als Referenz oder rvalue-Referenz übergeben werden, außer wenn ein QFuture<void> zurückgegeben wird, in diesem Fall muss es als rvalue-Referenz übergeben werden, um zu verhindern, dass es den Gültigkeitsbereich verlässt.

server.route("/test2", this,
             [] (QHttpServerResponder &&responder) {
                responder.write(QHttpServerResponder::StatusCode::Forbidden);
             });

Außerdem kann QHttpServerRequest als letztes Argument oder, wenn es ein QHttpServerResponder Argument gibt, als vorletztes Argument verwendet werden, um detaillierte Informationen über die Anfrage zu erhalten. Es kann als const-Referenz (nur für nicht-konkurrierende Rückrufe) oder als Wert übergeben werden und kann für den Zugriff auf den Körper der Anfrage verwendet werden:

server.route("/test3", QHttpServerRequest::Method::Post, this,
             [] (QHttpServerRequest request, QHttpServerResponder &&responder) {
                responder.write(request.body(), "text/plain"_ba);
             });

Jeder Platzhalter ( "<arg>" ) in pathPattern wird automatisch konvertiert, um den Argumenttypen des Handlers zu entsprechen. Zu den unterstützten Typen gehören Ganzzahlen, Gleitkommazahlen, QString, QByteArray und QUrl. Die Klasse QUrl kann als letzter Parameter verwendet werden, um das Ende der pathPattern zu behandeln, und durch Aufteilung kann eine beliebige Anzahl von Argumenten unterstützt werden. Benutzerdefinierte Konverter können mit QHttpServerRouter::addConverter() hinzugefügt werden.

Jedem registrierten Typ ist ein Regex zugeordnet, der zum Abgleichen und Konvertieren von Platzhaltern in der pathPattern verwendet wird. Diese Regex-Muster werden kombiniert, um einen Parser für den gesamten Pfad zu erstellen. Der resultierende Parser wird dann verwendet, um zu überprüfen, ob der Pfad mit dem Muster übereinstimmt. Wenn das Parsing erfolgreich ist, wird die entsprechende Funktion mit den umgewandelten Parametern aufgerufen. Schlägt das Parsing fehl, wird der nächste registrierte Rückruf versucht. Schlägt das Parsing für alle Rückrufe fehl, wird der missingHandler aufgerufen.

Im folgenden Beispiel wird der Wert im Anforderungspfad, der "<arg>" ersetzt, in int umgewandelt, da das Lambda einen Parameter int erwartet. Wenn eine HTTP-Anfrage mit der Route übereinstimmt, wird der konvertierte Wert an das Argument page des Lambdas übergeben:

QHttpServer server;
server.route("/showpage/<arg>", this, [] (int page) { return getPage(page); });

Diese Funktion gibt im Erfolgsfall einen Zeiger auf die neu erstellte Regel zurück, andernfalls einen nullptr. Der Zeiger kann verwendet werden, um Parameter für eine beliebige benutzerdefinierte QHttpServerRouter Klasse zu setzen:

auto rule = server.route<MyRule>("/test4", this, [] () {return "";});
rule->setParameter("test");

Anfragen werden standardmäßig sequentiell innerhalb des Threads von QHttpServer verarbeitet. Der Request-Handler kann QFuture<QHttpServerResponse> zurückgeben, wenn eine gleichzeitige Verarbeitung gewünscht ist:

server.route("/feature/<arg>", [] (int ms) {
    return QtConcurrent::run(pool, [ms] () {
        QThread::msleep(ms);
        return QHttpServerResponse("the future is coming");
    });
});

Das Lambda von QtConcurrent::run() wird nebenläufig ausgeführt, aber die gesamte Netzwerkkommunikation wird in dem Thread ausgeführt, zu dem QHttpServer gehört.

Routes, die Futures zurückgeben, werden nur auf einer HTTP/2-Verbindung vollständig gleichzeitig ausgeführt. Frühere Versionen von HTTP unterstützen keine Verschachtelung von Teilen verschiedener Antworten: Die Antworten müssen vollständig in der gleichen Reihenfolge zurückkommen, in der die Anfragen eingehen. Selbst wenn also ein Route-Handler ein QFuture<void> zurückgibt, wird die nächste auf dieser HTTP/1-Verbindung eingehende Anfrage nicht bearbeitet, bevor die aktuelle nicht bearbeitet wurde. Route-Handler auf verschiedenen Verbindungen können jedoch gleichzeitig ausgeführt werden.

Wenn ein Route-Handler seine Arbeit in einem gleichzeitigen Lauf ausführt, kann dies für alle Versionen von HTTP von Vorteil sein, da der Thread, zu dem QHttpServer gehört, von der Arbeit, die der gleichzeitige Lauf ausführt, entlastet wird.

QHttpServerRequest ist kopierbar und muss als Wert erfasst werden, wenn ein Future zurückgegeben wird, da die Variablen, die an slot übergeben werden, den Gültigkeitsbereich verlassen können, bevor der Future beendet ist.

server.route("/test4", QHttpServerRequest::Method::Post, this,
             [] (QHttpServerRequest request) {
                return QtConcurrent::run(pool, [request]() {
                    return QHttpServerResponse("text/plain"_ba, request.body());
                }
             });

Eine slot, die QHttpServerRequest oder QHttpServerResponder durch Verweis erfasst, wenn eine Zukunft zurückgegeben wird, verursacht eine Behauptung mit einer Erklärung, warum es verboten ist.

Nicht alle Plattformen unterstützen das Verschieben von QHttpServerResponder in ein veränderbares Lambda, das an QConcurrent::run übergeben wird, daher besteht die Abhilfe darin, QHttpServerResponder in einen std::shared_ptr zu verschieben und diesen zu kopieren.

server.route("/concurrent-multipart-back/<arg>",
             [](QString message, QHttpServerResponder &&responder) {
                return QtConcurrent::run(pool,
                    [=, r = std::make_shared<QHttpServerResponder>(std::move(responder))] {
                        QByteArray ba = message.toUtf8();
                        r->writeBeginChunked("text/plain"_ba);
                        for (ushort i = 1; i < 8; ++i) {
                            r->writeChunk(ba);
                        }
                        r->writeEndChunked(ba);
                    });
            });

Siehe auch QHttpServerRouter::addRule und addAfterRequestHandler.

template <typename Rule = QHttpServerRouterRule, typename Functor> Rule *QHttpServer::route(const QString &pathPattern, Functor &&handler)

Überladung von QHttpServer::route zur Erstellung einer Regel für pathPattern und QHttpServerRequest::Method::AnyKnown. Alle Anfragen werden an handler weitergeleitet, das ein Funktionszeiger, ein nicht veränderbares Lambda oder eine andere kopierbare aufrufbare Variable mit const call-Operator sein kann. Die Regel ist so lange gültig, bis die QHttpServer zerstört wird.

template <typename Rule = QHttpServerRouterRule, typename Functor> Rule *QHttpServer::route(const QString &pathPattern, QHttpServerRequest::Methods method, Functor &&handler)

Überladung von QHttpServer::route zur Erstellung einer Regel für pathPattern und method. Alle Anfragen werden an handler weitergeleitet, das ein Funktionszeiger, ein nicht veränderbares Lambda oder eine andere kopierbare aufrufbare Variable mit const call-Operator sein kann. Die Regel ist so lange gültig, bis die QHttpServer zerstört wird.

template <typename Rule = QHttpServerRouterRule, typename Functor> Rule *QHttpServer::route(const QString &pathPattern, const QObject *context, Functor &&slot)

Überladung von QHttpServer::route, um eine Regel für pathPattern und die Methode QHttpServerRequest::Method::AnyKnown zu erstellen. Alle Anfragen werden an context und slot weitergeleitet.

QHttpServerRouter *QHttpServer::router()

Gibt einen Zeiger auf das Router-Objekt zurück.

const QHttpServerRouter *QHttpServer::router() const

Gibt einen Zeiger auf das konstante Router-Objekt zurück.

template <typename Functor> void QHttpServer::setMissingHandler(const QObject *context, Functor &&slot)

Legen Sie einen Handler für unbehandelte Anfragen fest.

Alle unbehandelten Anfragen werden an den context's slot weitergeleitet.

Die slot muss die Signatur void (*)(const QHttpServerRequest &, QHttpServerResponder &) implementieren. Die slot kann auch ein Funktionszeiger, ein nicht veränderbares Lambda oder eine andere kopierbare aufrufbare Variable mit dem Operator const call sein. In diesem Fall ist die context ein Kontextobjekt. Der Handler ist so lange gültig, bis das Kontextobjekt zerstört wird.

Der Standard-Handler antwortet mit dem Status 404 Not Found.

Siehe auch clearMissingHandler.