Back to Qt.io
Contact Us Blog Download Qt

QHttpServerRouterRule Class

Die QHttpServerRouterRule ist die Basisklasse für QHttpServerRouter Regeln. Mehr...

Kopfzeile: #include <QHttpServerRouterRule>
CMake: find_package(Qt6 REQUIRED COMPONENTS HttpServer)
target_link_libraries(mytarget PRIVATE Qt6::HttpServer)
qmake: QT += httpserver
Seit: Qt 6.4

Öffentliche Funktionen

QHttpServerRouterRule(const QString &pathPattern, const QHttpServerRequest::Methods methods, const QObject *receiver, Functor &&slot)
QHttpServerRouterRule(const QString &pathPattern, const QObject *receiver, Functor &&slot)
virtual ~QHttpServerRouterRule()
const QObject *contextObject() const

Statische öffentliche Mitglieder

typename ViewTraits::BindableType bindCaptured(QObject *receiver, Functor &&slot, const QRegularExpressionMatch &match)

Geschützte Funktionen

bool exec(const QHttpServerRequest &request, QHttpServerResponder &responder) const
bool hasValidMethods() const
virtual bool matches(const QHttpServerRequest &request, QRegularExpressionMatch *match) const

Detaillierte Beschreibung

QHttpServerRouterRule definiert die Beziehung zwischen einem Anfragepfad, einer HTTP-Methode und dem entsprechenden Handler-Callback. Eine QHttpServerRouter ist eine Sammlung dieser Regeln und führt den entsprechenden Handler aus, wenn eine Anfrage sowohl dem Pfad als auch der Methode entspricht. Der Handler ist für die Generierung der Antwort verantwortlich.

Pfade und Patterns

Jede QHttpServerRouterRule enthält einen Pfad oder ein Muster, das bestimmt, welche Anfragen sie bearbeiten kann. Pfade können Platzhalter enthalten, die an den Handler übergeben werden. Die folgenden Beispiele illustrieren Pfadmuster unter Verwendung der QHttpServer::route() Methode, obwohl sie auch mit dem QHttpServerRouterRule Konstruktor gesetzt werden können.

Im einfachsten Fall ist der Pfad ein String mit einem führenden "/":

QHttpServer server;
server.route("/user", [] () { return "hello user"; } );

Dieses Pfadmuster definiert eine Regel, die alle Anfragen an "/user" an den angegebenen Handler weiterleitet, der in diesem Fall eine einfache Lambda-Funktion ist. (Beachten Sie, dass bei der direkten Verwendung von QHttpServerRouterRule die Syntax des Handlers anders ist - siehe unten.)

Ein "/" am Ende des Pfadmusters ermöglicht es der Regel, zusätzlichen Pfaden mit Argumenten nach "/" zu entsprechen. Bei der Verwendung der Komfortmethode QHttpServer::route() wird das Argument automatisch an die Lambda-Funktion übergeben:

server.route("/user/", [] ( qint64 id ) { return "hello user"; } );

Dies würde Suchpfaden wie "/user/1", "/user/2" usw. entsprechen.

Erfassen von Argumenten im Pfad

Mit den Platzhaltern "<arg>" können Sie Argumente an beliebiger Stelle im Pfadmuster platzieren, und es werden mehrere davon im Pfad unterstützt:

server.route("/user/<arg>/history", [] (qint64 id){ return "hello user"; } );
server.route("/user/<arg>/history/", [] (qint64 id, qint64 page){ return "hello user"; } );

Dies würde zum Beispiel zu einer Anfrage wie "/user/1/history/2" passen. Jeder in QHttpServerRouter::converters() registrierte Datentyp kann sowohl in der Callback-Funktion als auch in den entsprechenden Platzhaltern im Pfad verwendet werden.

Anforderungsmethode

Die Anfragemethode entspricht einem der Werte in QHttpServerRequest::Method. Wenn bei der Erstellung einer Regel keine Methode angegeben wird, passt sie auf Anfragen mit jeder bekannten Methode.

Handler-Signatur

Ein Handler ist eine Callback-Funktion mit der folgenden Signatur:

void (*)(const QRegularExpressionMatch &, const QHttpServerRequest &, QHttpServerResponder &);
  • Das erste Argument empfängt alle übereinstimmenden Capture-Gruppen aus dem Pfad.
  • Das zweite Argument enthält die Anfragedetails.
  • Das dritte Argument wird zum Senden der Antwort verwendet.

Hinzufügen von Regeln zu QHttpServerRouter

Das folgende Beispiel zeigt, wie man eine neue Regel mit einem Handler in QHttpServerRouter erstellt und registriert:

template<typename ViewHandler>
void route(const char *path, const QHttpServerRequest::Methods methods, ViewHandler &&viewHandler)
{
    auto rule = std::make_unique<QHttpServerRouterRule>(
            path, methods, [this, viewHandler = std::forward<ViewHandler>(viewHandler)]
                                            (QRegularExpressionMatch &match,
                                             const QHttpServerRequest &request,
                                             QHttpServerResponder &responder) mutable {
        auto boundViewHandler = QHttpServerRouterRule::bindCaptured<ViewHandler>(
                this, std::move(viewHandler), match);
        boundViewHandler(); // Execute the handler
    });

    // Add rule to the router
    router.addRule<ViewHandler>(std::move(rule));
}

// Valid:
route("/user/", [] (qint64 id) { } );                            // Matches "/user/1", "/user/3", etc.
route("/user/<arg>/history", [] (qint64 id) { } );               // Matches "/user/1/history", "/user/2/history"
route("/user/<arg>/history/", [] (qint64 id, qint64 page) { } ); // Matches "/user/1/history/1", "/user/2/history/2"

Hinweis: Dies ist eine Low-Level-API. Für Alternativen auf höherer Ebene, siehe QHttpServer.

Hinweis: Reguläre Ausdrücke werden in Pfadmustern nicht unterstützt, aber Sie können QHttpServerRouter::addConverter() verwenden, um "<arg>" auf einen bestimmten Typ abzustimmen.

Dokumentation der Mitgliedsfunktionen

template <typename Functor> QHttpServerRouterRule::QHttpServerRouterRule(const QString &pathPattern, const QHttpServerRequest::Methods methods, const QObject *receiver, Functor &&slot)

Erzeugt eine Routing-Regel für pathPattern und methods und verbindet sie mit den angegebenen receiver und slot.

  • slot kann ein Funktionszeiger, ein nicht-mutierbares Lambda oder ein anderes kopierbares Callable mit const call operator sein.
  • Wenn slot aufrufbar ist, fungiert receiver als sein Kontextobjekt.
  • Der Handler bleibt gültig, bis receiver zerstört wird.

Die Regel kann jede Kombination der verfügbaren HTTP-Methoden behandeln.

Siehe auch QHttpServerRequest::Methods.

template <typename Functor> QHttpServerRouterRule::QHttpServerRouterRule(const QString &pathPattern, const QObject *receiver, Functor &&slot)

Diese Überladung konstruiert eine Routing-Regel für pathPattern und verknüpft sie mit receiver und slot.

  • Die Standardeinstellung ist QHttpServerRequest::Method::AnyKnown, was bedeutet, dass sie mit jeder anerkannten HTTP-Methode übereinstimmt.
  • slot kann ein Funktionszeiger, ein nicht-mutierbares Lambda oder ein anderes kopierbares callable mit const call operator sein.
  • Wenn slot aufrufbar ist, fungiert receiver als sein Kontextobjekt.
  • Der Handler bleibt gültig, bis receiver zerstört wird.

Dies ist eine überladene Funktion.

[virtual noexcept] QHttpServerRouterRule::~QHttpServerRouterRule()

Zerstört eine QHttpServerRouterRule.

[static] template <typename Functor, typename ViewTraits = QHttpServerRouterViewTraits<Functor>> typename ViewTraits::BindableType QHttpServerRouterRule::bindCaptured(QObject *receiver, Functor &&slot, const QRegularExpressionMatch &match)

Bindet die angegebenen receiver und slot mit Argumenten, die aus der URL extrahiert wurden. Die Funktion gibt eine gebundene Callable zurück, die alle verbleibenden Argumente, die vom Handler benötigt werden, aufnimmt und sie nach den von der URL abgeleiteten Werten an slot liefert.

Jeder erfasste Wert aus der URL (als Zeichenkette) wird anhand seiner Position in den entsprechenden Parametertyp im Handler umgewandelt, damit er als match übergeben werden kann.

QHttpServerRouter router;auto pageView = [](const QString &page, const quint32 num) {    qDebug("page: %s, num: %d", qPrintable(page), num);
};using ViewHandler = decltype(pageView);auto rule = std::make_unique<QHttpServerRouterRule>( "/<arg>/<arg>/log", [&router, &pageView] (QRegularExpressionMatch &match, const QHttpServerRequest&request,             QHttpServerResponder&&responder) { // Binden und Aufrufen von viewHandler mit der erfassten Zeichenkette von match und quint32:    QHttpServerRouterRule::bindCaptured(pageView, match)(); }); router.addRule<ViewHandler>(std::move(rule));

const QObject *QHttpServerRouterRule::contextObject() const

Ruft das mit dieser Regel verbundene Kontextobjekt ab. Dieses Objekt dient als Empfänger, der für die Bearbeitung der Anfrage zuständig ist.

[protected] bool QHttpServerRouterRule::exec(const QHttpServerRequest &request, QHttpServerResponder &responder) const

Führt die Regel aus. Verarbeitet die angegebene request, indem geprüft wird, ob sie dieser Regel entspricht.

  • Diese Funktion wird von QHttpServerRouter aufgerufen, wenn eine neue request empfangen wird.
  • Wenn request mit der Regel übereinstimmt, bearbeitet sie die Anfrage, indem sie eine Antwort über die bereitgestellte responder sendet und true zurückgibt.
  • Wenn es keine Übereinstimmung gibt, wird false zurückgegeben.

[protected] bool QHttpServerRouterRule::hasValidMethods() const

Überprüft die Anfragemethode. Gibt true zurück, wenn die angegebene HTTP-Methode gültig ist.

[virtual protected] bool QHttpServerRouterRule::matches(const QHttpServerRequest &request, QRegularExpressionMatch *match) const

Ermittelt, ob die angegebene request die Bedingungen dieser Regel erfüllt.

  • Diese virtuelle Funktion wird von exec() aufgerufen, um die request auszuwerten.
  • Wenn die Anfrage übereinstimmt, werden die Details in match gespeichert (das nicht nullptr sein darf ), und die Funktion gibt true zurück.
  • Andernfalls gibt sie false zurück.

© 2025 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.