Struct actix_web::web::Data

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

Application data.

Application level data is a piece of arbitrary data attached to the app, scope, or resource. Application data is available to all routes and can be added during the application configuration process via App::data().

Application data can be accessed by using Data<T> extractor where T is data type.

Note: HTTP server accepts an application factory rather than an application instance. HTTP server constructs an application instance for each thread, thus application data must be constructed multiple times. If you want to share data between different threads, a shareable object should be used, e.g. Send + Sync. Application data does not need to be Send or Sync. Internally Data uses Arc.

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

Examples

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

struct MyData {
    counter: usize,
}

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

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

    let app = App::new()
        // Store `MyData` in application storage.
        .app_data(data.clone())
        .service(
            web::resource("/index.html").route(
                web::get().to(index)));
}

Implementations

impl<T> Data<T>

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

Create new Data instance.

pub fn get_ref(&self) -> &T

Get reference to inner app data.

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

Convert to the internal Arc

Methods from Deref<Target = 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

Performs the conversion.

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

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