En esta página

QHttpServerRouterRule Class

QHttpServerRouterRule es la clase base de las reglas de « QHttpServerRouter ». Más información...

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

Funciones públicas

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

Miembros públicos estáticos

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

Funciones protegidas

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

Descripción detallada

QHttpServerRouterRule define la relación entre una ruta de solicitud, un método HTTP y la llamada de retorno del controlador correspondiente. Un ` QHttpServerRouter ` es una colección de estas reglas que ejecuta el controlador adecuado cuando una solicitud coincide tanto con la ruta como con el método. El controlador se encarga de generar la respuesta.

Rutas y patrones

Cada QHttpServerRouterRule incluye una ruta o patrón que determina qué solicitudes puede gestionar. Las rutas pueden contener marcadores de posición que se pasan al controlador. Los ejemplos siguientes ilustran patrones de ruta utilizando el método de conveniencia QHttpServer::route(), aunque también se pueden configurar mediante el constructor de QHttpServerRouterRule.

En el caso más sencillo, la ruta es una cadena que comienza por "/":

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

Este patrón de ruta define una regla que dirige todas las solicitudes a "/user" al controlador especificado, que en este caso es una sencilla función lambda. (Ten en cuenta que, al utilizar QHttpServerRouterRule directamente, la sintaxis del controlador es diferente; véase más abajo).

Un « "/" » al final del patrón de ruta permite que la regla coincida con rutas adicionales que incluyan argumentos después de « "/" ». Al utilizar el método de conveniencia « QHttpServer::route()», el argumento se pasa automáticamente a la función lambda:

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

Esto coincidiría con rutas de solicitud como "/user/1", "/user/2", etc.

Captura de argumentos en la ruta

Puedes colocar argumentos en cualquier parte del patrón de ruta utilizando los marcadores de posición "<arg>", y se admiten varios de ellos en la ruta:

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

Por ejemplo, esto coincidiría con una solicitud como "/user/1/history/2". Cualquier tipo de datos registrado en QHttpServerRouter::converters() se puede utilizar tanto en la función de devolución de llamada como en los marcadores de posición correspondientes de la ruta.

Método de solicitud

El método de solicitud se corresponde con uno de los valores de QHttpServerRequest::Method. Si no se especifica ningún método al crear una regla, esta coincidirá con solicitudes de cualquier método conocido.

Firma del controlador

Un controlador es una función de devolución de llamada con la siguiente firma:

  • El primer argumento recibe cualquier grupo de captura coincidente de la ruta.
  • El segundo argumento contiene los detalles de la solicitud.
  • El tercer argumento se utiliza para enviar la respuesta.

Añadir reglas a QHttpServerRouter

El siguiente ejemplo muestra cómo crear y registrar una nueva regla con un controlador en 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"

Nota: Se trata de una API de bajo nivel. Para alternativas de mayor nivel, consulta QHttpServer.

Nota: No se admiten expresionesregulares en los patrones de ruta, pero puedes utilizar QHttpServerRouter::addConverter() para hacer coincidir "<arg>" con un tipo específico.

Documentación de funciones de miembro

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

Crea una regla de enrutamiento para pathPattern y methods, conectándola a las direcciones especificadas receiver y slot.

  • slot puede ser un puntero a una función, una lambda no mutable o cualquier otro objeto ejecutable copiable con el operador de llamada const.
  • Si slot es una entidad invocable, receiver actúa como su objeto de contexto.
  • El controlador sigue siendo válido hasta que se destruya ` receiver `.

La regla puede gestionar cualquier combinación de métodos HTTP disponibles.

Véase también QHttpServerRequest::Methods.

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

Esta sobrecarga crea una regla de enrutamiento para pathPattern y la asocia con receiver y slot.

  • Por defecto, se establece en QHttpServerRequest::Method::AnyKnown, lo que significa que coincidirá con cualquier método HTTP reconocido.
  • slot puede ser un puntero a función, una lambda no mutable o cualquier otro objeto ejecutable copiable con el operador de llamada ` const `.
  • Si slot es un objeto invocable, receiver actúa como su objeto de contexto.
  • El controlador sigue siendo válido hasta que se destruya ` receiver `.

Esta es una función sobrecargada.

[virtual noexcept] QHttpServerRouterRule::~QHttpServerRouterRule()

Destruye un « QHttpServerRouterRule ».

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

Asigna los valores de receiver y slot con los argumentos extraídos de la URL. La función devuelve una función ejecutable asignada que toma cualquier argumento restante que requiera el controlador, y los pasa a slot después de los valores derivados de la URL.

Cada valor capturado de la URL (en forma de cadena) se convierte al tipo de parámetro correspondiente en el controlador en función de su posición, lo que garantiza que pueda pasarse como ` match`.

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) {
    // Vincula y llama a viewHandler con la cadena capturada y el valor quint32 de match:
    QHttpServerRouterRule::bindCaptured(pageView, match)();
});

router.addRule<ViewHandler>(std::move(rule));

const QObject *QHttpServerRouterRule::contextObject() const

Recupera el objeto de contexto asociado a esta regla. Este objeto actúa como receptor encargado de gestionar la solicitud.

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

Ejecuta la regla. Procesa el request proporcionado comprobando si se ajusta a esta regla.

  • QHttpServerRouter llama a esta función cuando se recibe un nuevo request.
  • Si el request coincide con la regla, gestiona la solicitud enviando una respuesta a través del responder facilitado y devuelve true.
  • Si no hay coincidencia, devuelve false.

[protected] bool QHttpServerRouterRule::hasValidMethods() const

Comprueba la validez del método de solicitud. Devuelve « true » si el método HTTP especificado es válido.

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

Determina si el objeto ` request ` proporcionado cumple las condiciones de esta regla.

  • Esta función virtual es llamada por exec() para evaluar request.
  • Si la solicitud coincide, los detalles se almacenan en ` match ` (que no debe ser ` nullptr`), y la función devuelve ` true`.
  • En caso contrario, devuelve 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.