Struct HttpRequest 

pub struct HttpRequest(/* private fields */);

An HTTP Request

Implementations

impl HttpRequest

pub fn head(&self) -> &RequestHead

This method returns reference to the request head

pub fn uri(&self) -> &Url

Request’s uri.

pub fn method(&self) -> &Method

Read the Request method.

pub fn version(&self) -> Version

Read the Request Version.

pub fn headers(&self) -> &HeaderMap

Returns request’s headers.

pub fn path(&self) -> &str

The target path of this Request.

pub fn query_string(&self) -> &str

The query string in the URL.

E.g., id=10

pub fn io(&self) -> Option<&IoRef>

Io reference for current connection

pub fn peer_addr(&self) -> Option<SocketAddr>

Peer socket address

Peer address is actual socket address, if proxy is used in front of ntex http server, then peer address would be address of this proxy.

pub fn match_info(&self) -> &Path<Url>

Get a reference to the Path parameters.

Params is a container for url parameters. A variable segment is specified in the form {identifier}, where the identifier can be used later in a request handler to access the matched value for that segment.

pub fn extensions(&self) -> Ref<'_, Extensions>

Request extensions

pub fn extensions_mut(&self) -> RefMut<'_, Extensions>

Mutable reference to a the request’s extensions

pub fn url_for<U, I>( &self, name: &str, elements: U, ) -> Result<Url, UrlGenerationError>

where U: IntoIterator<Item = I>, I: AsRef<str>,

Generate url for named resource.

Each element is percent-encoded as one literal URL component before it replaces a dynamic segment.

async fn index(req: HttpRequest) -> HttpResponse {
    let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
    HttpResponse::Ok().into()
}

fn main() {
    let app = App::default()
        .service(web::resource("/test/{one}/{two}/{three}")
             .name("foo")  // <- set resource name, then it could be used in `url_for`
             .route(web::get().to(index))
        );
}

pub fn url_for_static(&self, name: &str) -> Result<Url, UrlGenerationError>

Generate url for named resource

This method is similar to HttpRequest::url_for() but it can be used for urls that do not contain variable parts.

pub fn resource_map(&self) -> &ResourceMap

Get a reference to a ResourceMap of current application.

pub fn connection_info(&self) -> Ref<'_, ConnectionInfo>

Get ConnectionInfo for the current request.

This method panics if request’s extensions container is already borrowed.

pub fn app_config(&self) -> &WebAppConfig

App config

pub fn app_state<T: 'static>(&self) -> Option<&T>

Get an application state object stored with WebAppConfig.

Trait Implementations

impl Clone for HttpRequest

fn clone(&self) -> HttpRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for HttpRequest

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<St: State> FromRequest<St> for HttpRequest

It is possible to get HttpRequest as an extractor handler parameter

Example

use ntex::web::{self, App, HttpRequest};

/// extract `HttpRequest` from request
async fn index(req: HttpRequest) -> String {
   format!("Got thing: {req:?}")
}

fn main() {
    let app = App::default().service(
        web::resource("/users/{first}").route(
            web::get().to(index))
    );
}

type Error = Infallible

The error returned when extraction fails.

async fn from_request( _: &St, req: &HttpRequest, _: &mut Payload, ) -> Result<Self, Self::Error>

Creates the extractor value for this request.

impl HttpMessage for HttpRequest

fn message_headers(&self) -> &HeaderMap

Returns Request’s headers.

fn message_extensions(&self) -> Ref<'_, Extensions>

Request extensions

fn message_extensions_mut(&self) -> RefMut<'_, Extensions>

Mutable reference to a the request’s extensions

fn content_type(&self) -> &str

Returns the media type from the Content-Type header.

fn encoding(&self) -> Result<&'static Encoding, ContentTypeError>

Returns the character encoding declared by Content-Type.

fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError>

Parses the Content-Type header as a MIME type.

fn chunked(&self) -> Result<bool, DecodeError>

Returns whether Transfer-Encoding contains chunked.

fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, ParseError>

Parses and caches cookies from the Cookie headers.

fn cookie(&self, name: &str) -> Option<Cookie<'static>>

Returns the first request cookie with the given name.