Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

QHttpServerRouterRule Class

QHttpServerRouterRule est la classe de base pour les règles QHttpServerRouter. Plus d'informations...

En-tête : #include <QHttpServerRouterRule>
CMake : find_package(Qt6 REQUIRED COMPONENTS HttpServer)
target_link_libraries(mytarget PRIVATE Qt6::HttpServer)
qmake : QT += httpserver
Depuis : Qt 6.4

Fonctions publiques

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

Membres publics statiques

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

Fonctions protégées

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

Description détaillée

QHttpServerRouterRule définit la relation entre un chemin de requête, une méthode HTTP et le rappel du gestionnaire correspondant. Un site QHttpServerRouter est une collection de ces règles, qui exécute le gestionnaire approprié lorsqu'une demande correspond à la fois au chemin et à la méthode. Le gestionnaire est responsable de la génération de la réponse.

Chemins et modèles

Chaque règle QHttpServerRouterRule comprend un chemin ou un motif qui détermine les demandes qu'elle peut traiter. Les chemins peuvent contenir des espaces réservés qui sont transmis au gestionnaire. Les exemples ci-dessous illustrent les motifs de chemin en utilisant la méthode de commodité QHttpServer::route(), bien qu'ils puissent également être définis à l'aide du constructeur de QHttpServerRouterRule.

Dans le cas le plus simple, le chemin est une chaîne de caractères précédée de "/":

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

Ce modèle de chemin définit une règle qui dirige toutes les demandes adressées à "/user" vers le gestionnaire spécifié, qui dans ce cas est une simple fonction lambda. (Notez que lorsque vous utilisez QHttpServerRouterRule directement, la syntaxe du gestionnaire diffère - voir ci-dessous).

Un "/" final dans le modèle de chemin permet à la règle de correspondre à des chemins supplémentaires avec des arguments après le "/". Lorsque vous utilisez la méthode de commodité QHttpServer::route(), l'argument est automatiquement transmis à la fonction lambda :

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

Cela correspondrait à des chemins de requête tels que "/user/1", "/user/2", et ainsi de suite.

Capture des arguments dans le chemin d'accès

Vous pouvez placer des arguments n'importe où dans le modèle de chemin en utilisant les caractères de remplacement "<arg>", et plusieurs d'entre eux sont pris en charge dans le chemin :

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

Par exemple, cela correspondrait à une requête telle que "/user/1/history/2". Tout type de données enregistré dans QHttpServerRouter::converters() peut être utilisé à la fois dans la fonction de rappel et dans les espaces réservés correspondants dans le chemin.

Méthode de requête

La méthode de requête correspond à l'une des valeurs de QHttpServerRequest::Method. Si aucune méthode n'est spécifiée lors de la construction d'une règle, celle-ci correspondra aux requêtes de n'importe quelle méthode connue.

Signature du gestionnaire

Un gestionnaire est une fonction de rappel ayant la signature suivante :

void (*)(const QRegularExpressionMatch &, const QHttpServerRequest &, QHttpServerResponder &);
  • Le premier argument reçoit tous les groupes de capture correspondant au chemin d'accès.
  • Le deuxième argument contient les détails de la demande.
  • Le troisième argument est utilisé pour envoyer la réponse.

Ajout de règles à QHttpServerRouter

L'exemple ci-dessous montre comment créer et enregistrer une nouvelle règle avec un gestionnaire dans QHttpServerRouter:

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"

Remarque : il s'agit d'une API de bas niveau. Pour des alternatives de plus haut niveau, voir QHttpServer.

Remarque : les expressions régulières ne sont pas prises en charge dans les modèles de chemin, mais vous pouvez utiliser QHttpServerRouter::addConverter() pour faire correspondre "<arg>" à un type spécifique.

Documentation des fonctions membres

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

Crée une règle de routage pour pathPattern et methods, la connectant aux receiver et slot spécifiés.

  • slot peut être un pointeur de fonction, un lambda non modifiable ou tout autre objet copiable pouvant être appelé avec l'opérateur d'appel const.
  • Si slot est appelable, receiver agit comme son objet de contexte.
  • Le gestionnaire reste valide jusqu'à ce que receiver soit détruit.

La règle peut gérer n'importe quelle combinaison de méthodes HTTP disponibles.

Voir aussi QHttpServerRequest::Methods.

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

Cette surcharge construit une règle de routage pour pathPattern et l'associe à receiver et slot.

  • Elle utilise par défaut QHttpServerRequest::Method::AnyKnown, ce qui signifie qu'elle correspondra à n'importe quelle méthode HTTP reconnue.
  • slot peut être un pointeur de fonction, un lambda non modifiable ou tout autre élément copiable pouvant être appelé avec l'opérateur d'appel const.
  • Si slot est appelable, receiver agit comme son objet de contexte.
  • Le gestionnaire reste valide jusqu'à ce que receiver soit détruit.

Il s'agit d'une fonction surchargée.

[virtual noexcept] QHttpServerRouterRule::~QHttpServerRouterRule()

Détruit un QHttpServerRouterRule.

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

Lie les adresses receiver et slot avec des arguments extraits de l'URL. La fonction renvoie un appelable lié qui prend tous les arguments restants requis par le gestionnaire et les fournit à slot après les valeurs dérivées de l'URL.

Chaque valeur capturée de l'URL (sous forme de chaîne) est convertie dans le type de paramètre correspondant dans le gestionnaire en fonction de sa position, ce qui permet de s'assurer qu'elle peut être transmise en tant que match.

QHttpServerRouter routeur ;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) { // Bind and call viewHandler with match's captured string and quint32: QHttpServerRouterRule::bindCaptured(pageView, match)() ; }) ; router.addRule<ViewHandler>(std::move(rule)) ;

const QObject *QHttpServerRouterRule::contextObject() const

Récupère l'objet contextuel associé à cette règle. Cet objet sert de récepteur responsable du traitement de la demande.

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

Exécute la règle. Traite le message request en vérifiant s'il correspond à cette règle.

  • Cette fonction est appelée par QHttpServerRouter lorsqu'un nouveau request est reçu.
  • Si l'adresse request correspond à la règle, elle traite la demande en envoyant une réponse par l'intermédiaire de l'adresse responder fournie et renvoie true.
  • S'il n'y a pas de correspondance, il renvoie false.

[protected] bool QHttpServerRouterRule::hasValidMethods() const

Valide la méthode de requête. Renvoie true si la méthode HTTP spécifiée est valide.

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

Détermine si l'adresse request fournie remplit les conditions de cette règle.

  • Cette fonction virtuelle est appelée par exec() pour évaluer la demande request.
  • Si la demande correspond, les détails sont stockés dans match (qui ne doit pas être nullptr), et la fonction renvoie true.
  • Dans le cas contraire, elle renvoie false.

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