状态：State 与 FromRef

/// The router type for composing handlers and services.
///
/// `Router<S>` means a router that is _missing_ a state of type `S` to be able
/// to handle requests. Thus, only `Router<()>` (i.e. without missing state) can
/// be passed to [`serve`]. See [`Router::with_state`] for more details.
///
/// [`serve`]: crate::serve()
#[must_use]
pub struct Router<S = ()> {
    inner: Arc<RouterInner<S>>,
}

impl<OuterState, InnerState> FromRequestParts<OuterState> for State<InnerState>
where
    InnerState: FromRef<OuterState>,
    OuterState: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_request_parts(
        _parts: &mut Parts,
        state: &OuterState,
    ) -> Result<Self, Self::Rejection> {
        let inner_state = InnerState::from_ref(state);
        Ok(Self(inner_state))
    }
}

impl<B> Service<Request<B>> for Router<()>
where
    B: HttpBody<Data = bytes::Bytes> + Send + 'static,
    B::Error: Into<axum_core::BoxError>,
{
    // ...
    fn call(&mut self, req: Request<B>) -> Self::Future {
        let req = req.map(Body::new);
        self.call_with_state(req, ())
    }
}

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }

use axum::{Router, extract::State, routing::get};

#[derive(Clone)]
struct AppState;

async fn handler(State(_s): State<AppState>) -> &'static str { "ok" }

#[tokio::main]
async fn main() {
  let app = Router::new().route("/", get(handler));
  let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
  axum::serve(listener, app).await.unwrap();
}

error[E0277]: the trait bound `for<'a> Router<AppState>: tower_service::Service<IncomingStream<'a, tokio::net::TcpListener>>` is not satisfied
   --> src/bin/missing_state.rs:12:25
    |
 12 |   axum::serve(listener, app).await.unwrap();
    |   -----------           ^^^ the trait `for<'a> tower_service::Service<IncomingStream<'a, tokio::net::TcpListener>>` is not implemented for `Router<AppState>`
    |   |
    |   required by a bound introduced by this call
    |
help: `Router` implements trait `tower_service::Service<Request>`
   --> axum-0.8.9/src/routing/mod.rs:549:5
    |
549 | /     impl<L> Service<serve::IncomingStream<'_, L>> for Router<()>
550 | |     where
551 | |         L: serve::Listener,
    | |___________________________^ `tower_service::Service<IncomingStream<'_, L>>`
...
569 | / impl<B> Service<Request<B>> for Router<()>
570 | | where
571 | |     B: HttpBody<Data = bytes::Bytes> + Send + 'static,
572 | |     B::Error: Into<axum_core::BoxError>,
    | |________________________________________^ `tower_service::Service<axum::http::Request<B>>`

error[E0308]: mismatched types
  --> src/bin/missing_state2.rs:13:3
   |
12 | fn app() -> Router {
   |             ------ expected `Router` because of return type
13 |   api()
   |   ^^^^^ expected `Router`, found `Router<AppState>`
   |
   = note: expected struct `Router<()>`
              found struct `Router<AppState>`

async fn handler(State(_db): State<Db>) -> &'static str { "ok" }

fn main() {
  let _app: Router = Router::new()
    .route("/", get(handler))
    .with_state(AppState);
}

error[E0308]: mismatched types
   --> src/bin/wrong_state.rs:14:17
    |
 14 |     .with_state(AppState);
    |      ---------- ^^^^^^^^ expected `Db`, found `AppState`
    |      |
    |      arguments to this method are incorrect
    |
note: method defined here
   --> axum-0.8.9/src/routing/mod.rs:408:12
    |
408 |     pub fn with_state<S2>(self, state: S) -> Router<S2> {
    |            ^^^^^^^^^^

    pub fn with_state<S2>(self, state: S) -> Router<S2> {
        map_inner!(self, this => RouterInner {
            path_router: this.path_router.with_state(state.clone()),
            fallback_router: this.fallback_router.with_state(state.clone()),
            default_fallback: this.default_fallback,
            catch_all_fallback: this.catch_all_fallback.with_state(state),
        })
    }

    fn with_state<S2>(self, state: &S) -> MethodEndpoint<S2, E> {
        match self {
            MethodEndpoint::None => MethodEndpoint::None,
            MethodEndpoint::Route(route) => MethodEndpoint::Route(route),
            MethodEndpoint::BoxedHandler(handler) => {
                MethodEndpoint::Route(handler.into_route(state.clone()))
            }
        }
    }

        Self(Box::new(MakeErasedHandler {
            handler,
            into_route: |handler, state| Route::new(Handler::with_state(handler, state)),
        }))

#[derive(Clone)]
struct AppState { name: &'static str }

#[derive(Clone)]
struct ApiState { version: u32 }

async fn root(State(s): State<AppState>) -> String { format!("app = {}", s.name) }
async fn api(State(s): State<ApiState>) -> String { format!("api v{}", s.version) }

#[tokio::main]
async fn main() {
  // Router<ApiState> --with_state--> Router<AppState> (S2 inferred from .nest)
  let api_router = Router::new()
    .route("/info", get(api))
    .with_state(ApiState { version: 2 });

  let app: Router = Router::new()
    .route("/", get(root))
    .nest("/api", api_router)
    .with_state(AppState { name: "demo" });

  for uri in ["/", "/api/info"] {
    let res = app.clone().oneshot(Request::get(uri).body(Body::empty()).unwrap()).await.unwrap();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{uri:<10} {}", String::from_utf8_lossy(&body));
  }
}

/          app = demo
/api/info  api v2

                        MethodEndpoint::BoxedHandler(handler) => {
                            let route = handler.clone().into_route(state);
                            return route.oneshot_inner_owned($req);
                        }

// NOTE: This trait is defined in axum-core, even though it is mainly used with `State` which is
// defined in axum. That allows crate authors to use it when implementing extractors.
pub trait FromRef<T> {
    /// Converts to this type from a reference to the input type.
    fn from_ref(input: &T) -> Self;
}

impl<T> FromRef<T> for T
where
    T: Clone,
{
    fn from_ref(input: &T) -> Self {
        input.clone()
    }
}

    let body = if let Some(field_ident) = &field.ident {
        if matches!(field_ty, Type::Reference(_)) {
            quote_spanned! {span=> state.#field_ident }
        } else {
            quote_spanned! {span=> state.#field_ident.clone() }
        }
    } else {
        // ...
        quote_spanned! {span=> state.#idx.clone() }
    };

    quote_spanned! {span=>
        #[allow(clippy::clone_on_copy, clippy::clone_on_ref_ptr)]
        impl ::axum::extract::FromRef<#state> for #field_ty {
            fn from_ref(state: &#state) -> Self {
                #body
            }
        }
    }

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
tower = { version = "=0.5.3", features = ["util"] }

use std::sync::atomic::{AtomicUsize, Ordering};
use axum::{Router, body::Body, extract::State, http::Request, routing::get};
use tower::ServiceExt;

static CLONES: AtomicUsize = AtomicUsize::new(0);

struct AppState;

impl Clone for AppState {
  fn clone(&self) -> Self {
    CLONES.fetch_add(1, Ordering::SeqCst);
    AppState
  }
}

async fn with_state(State(_s): State<AppState>) -> &'static str { "ok" }
async fn without_state() -> &'static str { "ok" }

fn report(label: &str) {
  println!("{label:<28} clones = {}", CLONES.swap(0, Ordering::SeqCst));
}

#[tokio::main]
async fn main() {
  let app = Router::new()
    .route("/a", get(with_state))
    .route("/b", get(without_state).post(without_state))
    .with_state(AppState);
  report("with_state (2 routes)");

  for path in ["/a", "/a", "/b"] {
    let req = Request::get(path).body(Body::empty()).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    report(&format!("GET {path} -> {}", res.status()));
  }
}

// the layer: AddExtension::call
    fn call(&mut self, mut req: Request<ResBody>) -> Self::Future {
        req.extensions_mut().insert(self.value.clone());
        self.inner.call(req)
    }

// the extractor
    fn from_extensions(extensions: &Extensions) -> Option<Self> {
        extensions.get::<T>().cloned().map(Extension)
    }

use axum::{Extension, Router, body::Body, http::Request, routing::get};
use http_body_util::BodyExt;
use tower::ServiceExt;

#[derive(Clone)]
struct Db;

async fn handler(Extension(_db): Extension<Db>) -> &'static str { "ok" }

#[tokio::main]
async fn main() {
  let app = Router::new()
    .route("/before", get(handler))
    .layer(Extension(Db))
    // added after .layer(): not wrapped by it
    .route("/after", get(handler));

  for uri in ["/before", "/after"] {
    let req = Request::get(uri).body(Body::empty()).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    let status = res.status();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{uri:<8} {} {}", status.as_u16(), String::from_utf8_lossy(&body));
  }
}

/before  200 ok
/after   500 Missing request extension: Extension of type `extension::Db` was not found. Perhaps you forgot to add it? See `axum::Extension`.

with_state (2 routes)        clones = 7
GET /a -> 200 OK             clones = 3
GET /a -> 200 OK             clones = 3
GET /b -> 200 OK             clones = 2

axum = { version = "=0.8.9", features = ["macros"] }

#[derive(FromRef)]
struct AppState {
  db: Db,
  #[from_ref(skip)]
  _secret: String,
}
impl Clone for AppState {
  fn clone(&self) -> Self {
    APP.fetch_add(1, SeqCst);
    AppState { db: self.db.clone(), _secret: self._secret.clone() }
  }
}

async fn handler(State(_db): State<Db>) {}

one request: AppState::clone = 2, Db::clone = 3