Struct actix_web::web::Data

pub struct Data<T: ?Sized>(_);

Application data wrapper and extractor.

Setting Data

Data is set using the app_data methods on App, Scope, and Resource. If data is wrapped in this Data type for those calls, it can be used as an extractor.

Note that Data should be constructed outside the HttpServer::new closure if shared, potentially mutable state is desired. Data is cheap to clone; internally, it uses an Arc.

See also App::app_data, Scope::app_data, and Resource::app_data.

Extracting Data

Since the Actix Web router layers application data, the returned object will reference the “closest” instance of the type. For example, if an App stores a u32, a nested Scope also stores a u32, and the delegated request handler falls within that Scope, then extracting a web::<Data<u32>> for that handler will return the Scope’s instance. However, using the same router set up and a request that does not get captured by the Scope, web::<Data<u32>> would return the App’s instance.

If route data is not set for a handler, using Data<T> extractor would cause a 500 Internal Server Error response.

See also HttpRequest::app_data and ServiceRequest::app_data.

Unsized Data

For types that are unsized, most commonly dyn T, Data can wrap these types by first constructing an Arc<dyn T> and using the From implementation to convert it.

let displayable_arc: Arc<dyn Display> = Arc::new(42usize);
let displayable_data: Data<dyn Display> = Data::from(displayable_arc);

Examples

use std::sync::Mutex;
use actix_web::{App, HttpRequest, HttpResponse, Responder, web::{self, Data}};

struct MyData {
    counter: usize,
}

/// Use the `Data<T>` extractor to access data in a handler.
async fn index(data: Data<Mutex<MyData>>) -> impl Responder {
    let mut my_data = data.lock().unwrap();
    my_data.counter += 1;
    HttpResponse::Ok()
}

/// Alteratively, use the `HttpRequest::app_data` method to access data in a handler.
async fn index_alt(req: HttpRequest) -> impl Responder {
    let data = req.app_data::<Data<Mutex<MyData>>>().unwrap();
    let mut my_data = data.lock().unwrap();
    my_data.counter += 1;
    HttpResponse::Ok()
}

let data = Data::new(Mutex::new(MyData { counter: 0 }));

let app = App::new()
    // Store `MyData` in application storage.
    .app_data(Data::clone(&data))
    .route("/index.html", web::get().to(index))
    .route("/index-alt.html", web::get().to(index_alt));

Implementations

impl<T> Data<T>

pub fn new(state: T) -> Data<T>

Create new Data instance.

impl<T: ?Sized> Data<T>

pub fn get_ref(&self) -> &T

Returns reference to inner T.

pub fn into_inner(self) -> Arc<T>

Unwraps to the internal Arc<T>

Trait Implementations

impl<T: ?Sized> Clone for Data<T>

fn clone(&self) -> Data<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for Data<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Data<T>

type Target = Arc<T>

The resulting type after dereferencing.

fn deref(&self) -> &Arc<T>

Dereferences the value.

impl<T: ?Sized> From<Arc<T>> for Data<T>

fn from(arc: Arc<T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized + 'static> FromRequest for Data<T>

type Error = Error

The associated error which can be returned.

type Future = Ready<Result<Data<T>, 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.

impl<T> Serialize for Data<T>where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.