Path、Query 与请求元数据

        match self.node.at(parts.uri.path()) {
            Ok(match_) => {
                let id = *match_.value;

                if !IS_FALLBACK {
                    #[cfg(feature = "matched-path")]
                    crate::extract::matched_path::set_matched_path_for_request(
                        id,
                        &self.node.route_id_to_path,
                        &mut parts.extensions,
                    );
                }

                url_params::insert_url_params(&mut parts.extensions, match_.params);
                // ...

    let params = params
        .iter()
        .filter(|(key, _)| !key.starts_with(super::NEST_TAIL_PARAM))
        .filter(|(key, _)| !key.starts_with(super::FALLBACK_PARAM))
        .map(|(k, v)| {
            if let Some(decoded) = PercentDecodedStr::new(v) {
                Ok((Arc::from(k), decoded))
            } else {
                Err(Arc::from(k))
            }
        })
        .collect::<Result<Vec<_>, _>>();

    match (current_params, params) {
        // ...
        (_, Err(invalid_key)) => {
            extensions.insert(UrlParams::InvalidUtf8InPathParam { key: invalid_key });
        }
        (Some(UrlParams::Params(current)), Ok(params)) => {
            current.extend(params);
        }
        (None, Ok(params)) => {
            extensions.insert(UrlParams::Params(params));
        }
    }

macro_rules! parse_single_value {
    ($trait_fn:ident, $visit_fn:ident, $ty:literal) => {
        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
        {
            if self.url_params.len() != 1 {
                return Err(PathDeserializationError::wrong_number_of_parameters()
                    .got(self.url_params.len())
                    .expected(1));
            }

            let value = self.url_params[0].1.parse().map_err(|_| {
                PathDeserializationError::new(ErrorKind::ParseError {
                    value: self.url_params[0].1.as_str().to_owned(),
                    expected_type: $ty,
                })
            })?;
            visitor.$visit_fn(value)
        }
    };
}

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "0.1"
serde = { version = "1", features = ["derive"] }

use std::{collections::BTreeMap, net::IpAddr};
use axum::{Router, body::Body, extract::{Path, Query}, http::Request, routing::get};
use http_body_util::BodyExt;
use serde::Deserialize;
use tower::ServiceExt;

#[allow(dead_code)]
#[derive(Deserialize, Debug)]
struct Params { id: u32, name: String }

#[allow(dead_code)]
#[derive(Deserialize, Debug)]
struct Page { n: i32 }

#[tokio::main]
async fn main() {
  let app = Router::new()
    .route("/tuple/{a}/{b}", get(|Path(p): Path<(u32, String)>| async move { format!("{p:?}") }))
    .route("/struct/{id}/{name}", get(|Path(p): Path<Params>| async move { format!("{p:?}") }))
    .route("/map/{a}/{b}", get(|Path(p): Path<BTreeMap<String, String>>| async move { format!("{p:?}") }))
    .route("/one/{a}", get(|Path(p): Path<u32>| async move { format!("{p:?}") }))
    .route("/two/{a}/{b}", get(|Path(p): Path<u32>| async move { format!("{p:?}") }))
    .route("/only-id/{id}", get(|Path(p): Path<Params>| async move { format!("{p:?}") }))
    .route("/ip/{ip}", get(|Path(p): Path<IpAddr>| async move { format!("{p:?}") }))
    .route("/opt/{a}", get(|Path(p): Path<Option<u32>>| async move { format!("{p:?}") }))
    .route("/str/{s}", get(|Path(p): Path<String>| async move { format!("{p:?}") }))
    .route("/page", get(|Query(p): Query<Page>| async move { format!("{p:?}") }));

  for uri in [
    "/tuple/7/bob",
    "/struct/7/bob",
    "/map/7/bob",
    "/one/abc",
    "/tuple/abc/bob",
    "/struct/abc/bob",
    "/ip/not-an-ip",
    "/only-id/7",
    "/two/1/2",
    "/opt/1",
    "/str/%FF",
    "/page?n=abc",
    "/page",
  ] {
    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:<22} {} {}", status.as_u16(), String::from_utf8_lossy(&body));
  }
}

/tuple/7/bob           200 (7, "bob")
/struct/7/bob          200 Params { id: 7, name: "bob" }
/map/7/bob             200 {"a": "7", "b": "bob"}
/one/abc               400 Invalid URL: Cannot parse `abc` to a `u32`
/tuple/abc/bob         400 Invalid URL: Cannot parse value at index 0 with value `abc` to a `u32`
/struct/abc/bob        400 Invalid URL: Cannot parse `id` with value `abc` to a `u32`
/ip/not-an-ip          400 Invalid URL: Cannot parse `ip` with value `not-an-ip`: invalid IP address syntax
/only-id/7             400 Invalid URL: missing field `name`
/two/1/2               500 Wrong number of path arguments for `Path`. Expected 1 but got 2. Note that multiple parameters must be extracted with a tuple `Path<(_, _)>` or a struct `Path<YourParams>`
/opt/1                 500 Unsupported type `core::option::Option<u32>`
/str/%FF               400 Invalid URL: Invalid UTF-8 in `s`
/page?n=abc            400 Failed to deserialize query string: n: invalid digit found in string
/page                  400 Failed to deserialize query string: missing field `n`

    pub fn try_from_uri(value: &Uri) -> Result<Self, QueryRejection> {
        let query = value.query().unwrap_or_default();
        let deserializer =
            serde_urlencoded::Deserializer::new(form_urlencoded::parse(query.as_bytes()));
        let params = serde_path_to_error::deserialize(deserializer)
            .map_err(FailedToDeserializeQueryString::from_err)?;
        Ok(Query(params))
    }

error[E0277]: the trait bound `fn(std::option::Option<Query<Page>>) -> impl Future<Output = ()> {handler}: Handler<_, _>` is not satisfied
   --> src/bin/opt_query.rs:11:51
    |
 11 |   let _app: Router = Router::new().route("/", get(handler));
    |                                               --- ^^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(std::option::Option<Query<Page>>) -> impl Future<Output = ()> {handler}`
    |                                               |
    |                                               required by a bound introduced by this call
    |
    = note: Consider using `#[axum::debug_handler]` to improve the error message

            let path = path_for_nested_route(prefix, inner_path);

            let layer = (
                StripPrefix::layer(prefix),
                SetNestedPath::layer(path_to_nest_at),
            );

use axum::{
  Router,
  body::Body,
  extract::{MatchedPath, NestedPath, OriginalUri, RawPathParams},
  http::{Request, Uri},
  routing::get,
};
use http_body_util::BodyExt;
use tower::ServiceExt;

async fn handler(
  m: MatchedPath,
  n: NestedPath,
  uri: Uri,
  OriginalUri(o): OriginalUri,
  params: RawPathParams,
) -> String {
  let params: Vec<_> = params.iter().collect();
  format!(
    "matched  = {}\n  nested   = {}\n  uri      = {uri}\n  original = {o}\n  params   = {params:?}",
    m.as_str(),
    n.as_str()
  )
}

#[tokio::main]
async fn main() {
  let users = || Router::new().route("/users/{id}", get(handler));
  let app = Router::new()
    .nest("/api/{version}", users())
    .nest_service("/svc", users());

  for uri in ["/api/v1/users/7?x=1", "/svc/users/7?x=1"] {
    let req = Request::get(uri).body(Body::empty()).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("GET {uri}\n  {}", String::from_utf8_lossy(&body));
  }
}

GET /api/v1/users/7?x=1
  matched  = /api/{version}/users/{id}
  nested   = /api/{version}
  uri      = /users/7?x=1
  original = /api/v1/users/7?x=1
  params   = [("version", "v1"), ("id", "7")]
GET /svc/users/7?x=1
  matched  = /svc/users/{id}
  nested   = /svc
  uri      = /users/7?x=1
  original = /svc/users/7?x=1
  params   = [("id", "7")]

    fn call(&mut self, target: T) -> Self::Future {
        let connect_info = ConnectInfo(C::connect_info(target));
        let svc = Extension(connect_info).layer(self.svc.clone());
        ResponseFuture::new(ready(Ok(svc)))
    }

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
hyper = { version = "=1.12.0", features = ["client", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio"] }
http = "1"
http-body-util = "0.1"

use std::net::SocketAddr;
use axum::{Router, extract::ConnectInfo, routing::get};
use http_body_util::{BodyExt, Empty};
use hyper::body::Bytes;
use hyper_util::rt::TokioIo;
use tokio::net::{TcpListener, TcpStream};

async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) -> String {
  format!("client = {}", addr.ip())
}

async fn get_once(addr: SocketAddr) -> String {
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  let (mut tx, conn) = hyper::client::conn::http1::handshake::<_, Empty<Bytes>>(io).await.unwrap();
  tokio::spawn(conn);
  let req = http::Request::get("/").header("host", "x").body(Empty::new()).unwrap();
  let res = tx.send_request(req).await.unwrap();
  let status = res.status().as_u16();
  let body = res.into_body().collect().await.unwrap().to_bytes();
  format!("{status} {}", String::from_utf8_lossy(&body))
}

#[tokio::main]
async fn main() {
  let app = Router::new().route("/", get(handler));

  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(axum::serve(listener, app.clone()).into_future());
  println!("serve(listener, app):\n  {}", get_once(addr).await);

  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  let make = app.into_make_service_with_connect_info::<SocketAddr>();
  tokio::spawn(axum::serve(listener, make).into_future());
  println!("serve(listener, app.into_make_service_with_connect_info()):\n  {}", get_once(addr).await);
}

serve(listener, app):
  500 Missing request extension: Extension of type `axum::extract::connect_info::ConnectInfo<core::net::socket_addr::SocketAddr>` was not found. Perhaps you forgot to add it? See `axum::Extension`.
serve(listener, app.into_make_service_with_connect_info()):
  200 client = 127.0.0.1

/path/a%2Fb%20c+d      200 "a/b c+d"
/query?q=a%2Fb%20c+d   200 "a/b c d" raw=Some("q=a%2Fb%20c+d")