Struct actix_web::HttpRequest

pub struct HttpRequest { /* fields omitted */ }

An HTTP Request

Implementations

impl HttpRequest

pub fn head(&self) -> &RequestHead

This method returns reference to the request head

pub fn uri(&self) -> &Uri

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 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 match_pattern(&self) -> Option<String>

The resource definition pattern that matched the path. Useful for logging and metrics.

For example, when a resource with pattern /user/{id}/profile is defined and a call is made to /user/123/profile this function would return Some("/user/{id}/profile").

Returns a None when no resource is fully matched, including default services.

pub fn match_name(&self) -> Option<&str>

The resource name that matched the path. Useful for logging and metrics.

Returns a None when no resource is fully matched, including default services.

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

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::new()
        .service(web::resource("/test/{one}/{two}/{three}")
             .name("foo")  // <- set resource name, then it could be used in `url_for`
             .route(web::get().to(|| HttpResponse::Ok()))
        );
}

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 peer_addr(&self) -> Option<SocketAddr>

Peer socket address.

Peer address is the directly connected peer’s socket address. If a proxy is used in front of the Actix Web server, then it would be address of this proxy.

To get client connection information .connection_info() should be used.

Will only return None when called in unit tests.

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) -> &AppConfig

App config

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

Get an application data object stored with App::data or App::app_data methods during application configuration.

If App::data was used to store object, use Data<T>:

let opt_t = req.app_data::<Data<T>>();

Trait Implementations

impl Clone for HttpRequest

fn clone(&self) -> HttpRequest

Returns a copy of the value.

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

impl FromRequest for HttpRequest

It is possible to get HttpRequest as an extractor handler parameter

Example

use actix_web::{web, App, HttpRequest};
use serde_derive::Deserialize;

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

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

type Config = ()

Configuration for this extractor.

type Error = Error

The associated error which can be returned.

type Future = Ready<Result<Self, Error>>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.

fn configure<F>(f: F) -> Self::Config where
    F: FnOnce(Self::Config) -> Self::Config, 

Create and configure config instance.

impl HttpMessage for HttpRequest

type Stream = ()

Type of message payload stream

fn headers(&self) -> &HeaderMap

Returns Request’s headers.

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

Request extensions

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

Mutable reference to a the request’s extensions

fn take_payload(&mut self) -> Payload<Self::Stream>

Message payload stream

pub fn content_type(&self) -> &str

Read the request content type. If request did not contain a Content-Type header, an empty string is returned.

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

Get content type encoding

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

Convert the request content type to a known mime type.

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

Check if request has chunked transfer encoding.

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

Load request cookies.

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

Return request cookie.