axum路由器

`axum::Router`结构体

pub struct Router<S = ()> { /* private fields */}

用于组合处理程序和服务的路由器类型。

实现

impl<S> Router<S>
where
  S: Clone + Send + Sync + 'static,

新建路由器

pub fn new() -> Self

创建一个新的路由器，除非您添加额外的路由，否则将对所有请求响应404未找到。

添加另一个路由到路由器

pub fn route(self, path: &str, method_router: MethodRouter<S>) -> Self

path: 是由/分割的路径段字符串。每个段可能是静态的、捕获的或者是通配符。
method_router: 是一个MethodRouter，它将请求方法映射到处理程序。 method_router通常会是类似于get的方法路由器中的处理程序。

静态路径

例如:

/
/foo
/foo/bar

如果传入的请求路径完全匹配，则将调用相应的服务。

捕获

例如:

/:key
/foo/:key
/users/:id/tweets

路径可以包含类似于/:key的段，它匹配任何单个段，并将存储在key处捕获的值。捕获的值可以是零长度，除了无效路径//

捕获可以使用Path进行提取。

MatchedPath可以用于提取匹配路径，而不是实际路径。

通配符

路径可以以/*key结尾，匹配所有段并捕获的段存储在key中。

例如:

/*key
/users/*path
/:id/:repo/*tree

请注意，/*key 不匹配空段。因此：

/*key 不匹配 /，但匹配 /a，/a/ 等。
/x/*key 不匹配 /x 或 /x/，但匹配 /x/a，/x/a/ 等。

还可以使用 Path 来提取通配符捕获。请注意，不包括前导斜杠，即对于路由 /foo/*rest 和路径 /foo/bar/baz， rest 的值将是 bar/baz。

接受多种方法

要接受同一路由的多个方法，您可以同时添加所有处理程序。

use axum::{Router, routing::{get, delete}, extract::Path};

let app = Router::new().route(
	"/", 
	get(get_root).post(post_root).delete(delete_root),
);

async fn get_root() {}
async fn post_root() {}
async fn delete_root() {}

或者你也可以一一添加:

let app = Router::new()
	.route("/", get(get_root))
	.route("/", post(post_root))
	.route("/", delete(delete_root));

更多例子

use axum::{Router, routing::{get, delete}, extract::Path};

let app = Router::new()
    .route("/", get(root))
    .route("/users", get(list_users).post(create_user))
    .route("/users/:id", get(show_user))
    .route("/api/:version/users/:id/action", delete(do_users_action))
    .route("/assets/*path", get(serve_asset));

async fn root() {}

async fn list_users() {}

async fn create_user() {}

async fn show_user(Path(id): Path<u64>) {}

async fn do_users_action(Path((version, id)): Path<(String, u64)>) {}

async fn serve_asset(Path(path): Path<String>) {}

Panics

如果路径与另一个路由重叠，则会发生panic

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

let app = Router::new()
    .route("/", get(|| async {}))
    .route("/", get(|| async {}));

静态路由 /foo 和动态路由 /:key 不被视为重叠，并且 /foo 将优先。如果路径为空，也会引发 panic。

路由服务

添加另一个路由到路由器调用一个服务

pub fn route_service<T>(self, path: &str, service: T) -> Self
where
  T: Service<Request, Error=Infallible> + Clone + Send + 'static,
	T::Response: IntoResponse,
	T::Future: Send + 'static,

示例:

use axum::{
	Router,
	body::Body,
	routing::{any_service, get_service},
	extract::Request,
	http::StatusCode,
	error_handling::HandleErrorLayer,
};
use tower_http::services::ServeFile;
use http::Response;
use std::{convert::Infallible, io};
use tower::service_fn;

let app = Router::new()
  .route(
		"/",
		any_service(service_fn(|_: Request| async {
			let res = Response::new(Body::from("Hi from `GET /`"));
		}))
	)
	.route_service(
		"/foo",
		service_fn(|req: Request| async move {
			let body = Body::from(format!("Hi from `{}` /foo", req.method()))
			let res = Response::new(body);
			Ok::<_, Infallible>(res)
		})
	)
	.route_service(
		"/static/Cargo.toml",
		ServeFile::new("Cargo.toml"),
	);

以这种方式路由到任意服务会对背压（Service::poll_ready）产生复杂性。有关更多详细信息，请参阅服务路由和背压模块。

由于相同的原因而出现panic，或者尝试将路由到Router时也会发生panic。

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

let app = Router::new().route_service(
    "/",
    Router::new().route("/foo", get(|| async {})),
);

使用`Router::nest`替换

在某个路径上嵌套一个路由器。

这样可以将应用程序分解成更小的部分，并将它们组合在一起。

pub fn nest(self, path: &str, router: Router<S>) -> Self

示例:

use axum::{
	routing::{get, post},
	Router,
};

let user_routes = Router::new().route("/:id", get(|| async {}));
let team_routes = Router::new().route("/", post(|| async {}));

let api_routes = Router::new()
  .nest("/users", user_routes)
	.nest("/teams", team_routes);

let app = Router::new().nest("/api", api_routes);

// Our app now accepts
// - GET /api/users/:id
// - POST /api/teams

URI如何变化

请注意，嵌套路由将无法看到原始请求URI，而是会剥去匹配的前缀。这对于像静态文件服务之类的服务工作是必要的。如果需要原始请求URI，请使·OriginalUri。

外部路由的捕获

在使用嵌套动态路由时要小心，因为嵌套还会从外部路由中捕获:

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use std::collections::HashMap;

async fn users_get(Path(params): Path<HashMap<String, String>>) {
    // Both `version` and `id` were captured even though `users_api` only
    // explicitly captures `id`.
    let version = params.get("version");
    let id = params.get("id");
}

let users_api = Router::new().route("/users/:id", get(users_get));

let app = Router::new().nest("/:version/api", users_api);

与通配符路由的区别

嵌套路由类似于通配符路由。不同之处在于通配符路由仍然可以看到整个 URI，而嵌套路由将会去掉前缀:

use axum::{routing::get, http::Uri, Router};

let nested_router = Router::new()
    .route("/", get(|uri: Uri| async {
        // `uri` will _not_ contain `/bar`
    }));

let app = Router::new()
    .route("/foo/*rest", get(|uri: Uri| async {
        // `uri` will contain `/foo`
    }))
    .nest("/bar", nested_router);

后备方案

如果嵌套路由器没有自己的回退，则将从外部路由器继承回退：

use axum::{routing::get, http::StatusCode, handler::Handler, Router};

async fn fallback() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "Not Found")
}

let api_routes = Router::new().route("/users", get(|| async {}));

let app = Router::new()
    .nest("/api", api_routes)
    .fallback(fallback);

在这里，像 GET /api/not-found 这样的请求将进入 api_routes，但由于它没有匹配的路由，也没有自己的回退，它将调用外部路由器的回退，即回退功能。如果嵌套路由器有自己的回退，则外部回退将不会被继承：

use axum::{
    routing::get,
    http::StatusCode,
    handler::Handler,
    Json,
    Router,
};

async fn fallback() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "Not Found")
}

async fn api_fallback() -> (StatusCode, Json<serde_json::Value>) {
    (
        StatusCode::NOT_FOUND,
        Json(serde_json::json!({ "status": "Not Found" })),
    )
}

let api_routes = Router::new()
    .route("/users", get(|| async {}))
    .fallback(api_fallback);

let app = Router::new()
    .nest("/api", api_routes)
    .fallback(fallback);

在这里，像 GET /api/not-found 这样的请求将转到 api_fallback。

用状态嵌套路由器

当使用此方法将Router组合时，每个Router必须具有相同类型的状态。如果您的路由器具有不同类型，您可以使用Router::with_state来提供状态并使类型匹配：

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

#[derive(Clone)]
struct InnerState {}

#[derive(Clone)]
struct OuterState {}

async fn inner_handler(state: State<InnerState>) {}

let inner_router = Router::new()
    .route("/bar", get(inner_handler))
    .with_state(InnerState {});

async fn outer_handler(state: State<OuterState>) {}

let app = Router::new()
    .route("/", get(outer_handler))
    .nest("/foo", inner_router)
    .with_state(OuterState {});

请注意，内部路由器仍将继承外部路由器的后备机制。

恐慌

如果路由与另一个路由重叠。有关详细信息，请参阅Router::route。
如果路由包含通配符（*）。
如果path为空。

与`nest`类似，但接受任何服务

pub fn nest_service<T>(self, path: &str, service: T) -> Self
where
	T: Service<Request, Error=Infallible> + Clone + Send + 'static,
	T::Response: IntoResponse,
	T::Future: Send + 'static,

将两个路由器的路径(`path`)和回退(`fallbacks`)合并到一个路由器

pub fn merge<R>(self, other: R) -> Self
where
	R: Into<Router<S>>,

这对于将应用程序分成更小的部分并将它们组合成一个非常有用。

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

let user_routes = Router::new()
  .route("/users", get(users_list))
	.route("/users/:id", get(users_show));

let team_routes = Router::new()
  .route("/teams", get(teams_list));

let app = Router::new()
  .merge(user_routes)
	.merge(team_routes);

// 也可以执行 `user_routes.merge(team_routes)`

// 我们的应用程序现在接受
// - GET /users
// - GET /users/:id
// - GET /teams

合并路由器的状态

使用此方法合并 Router 时，每个 Router 必须具有相同类型的状态。如果您的 routers 具有不同类型，可以使用 Router::with_state 来提供状态并使类型匹配：

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

#[derive(Clone)]
struct InnerState {}

#[derive(Clone)]
struct OuterState {}

async fn inner_handler(state: State<InnerState>) {}

let inner_router = Router::new()
		.route("/bar", get(inner_handler))
		.with_state(InnerState {});

async fn outer_handler(state: State<OuterState>) {}

let app = Router::new()
		.route("/", get(outer_handler))
		.merge(inner_router)
		.with_state(OuterState {});

合并具有回退的路由器

使用此方法合并 Router 时，后备(fallbacks)也会合并。但是只能有一个路由器有后备。

将 `tower::Layer` 应用于路由器中的所有路由。

pub fn layer<L>(self, layer: L) -> Router<S>
where
    L: Layer<Route> + Clone + Send + 'static,
    L::Service: Service<Request> + Clone + Send + 'static,
    <L::Service as Service<Request>>::Response: IntoResponse + 'static,
    <L::Service as Service<Request>>::Error: Into<Infallible> + 'static,
    <L::Service as Service<Request>>::Future: Send + 'static,

这可以用于为一组路由的请求添加额外的处理。

注意，中间件只应用于现有路由。

因此，您必须首先添加您的路由（和/或回退(fallbacks)），然后调用层(layer)。在调用层之后添加的额外路由将不会添加中间件。

如果要将中间件添加到单个处理程序，可以使用 MethodRouter::layer 或 Handler::layer。

示例

添加tower_http::trace::TraceLayer:

use axum::{
	routing::get,
	Router,
};
use tower_http::trace::TraceLayer;

let app = Router::new()
	.route("/foo", get(|| async {}))
	.route("/bar", get(|| async {}))
	.layer(TraceLayer::new_for_http());

如果您需要编写自己的中间件，请参阅“编写中间件”以获取不同的选项。

如果您只想在某些路由上使用中间件，可以使用Router::merge：

use axum::{
	routing::get,
	Router,
};
use tower_http::{trace::TraceLayer, compression::CompressionLayer};

let with_tracing = Router::new()
  .route("/foo", get(|| async {}))
	.layer(TraceLayer::new_for_http());

let with_compression = Router::new()
	.route("/bar", get(|| async {}))
	.layer(CompressionLayer::new());

let app = Router::new()
  .merge(with_tracing)
	.merge(with_compression);

多中间件

当应用多个中间件时，建议使用tower::ServiceBuilder。有关更多详细信息，请参阅中间件。

路由之后运行

使用此方法添加的中间件将在路由之后运行，因此无法用于重写请求URI。有关更多详细信息和解决方法，请参见“在中间件中重写请求URI”。

错误处理

请参阅有关错误处理影响中间件的详细信息。

向路由器应用一个 `tower::Layer`，只有当请求匹配路由时才会运行

pub fn route_layer<L>(self, layer: L) -> Self
where
    L: Layer<Route> + Clone + Send + 'static,
    L::Service: Service<Request> + Clone + Send + 'static,
    <L::Service as Service<Request>>::Response: IntoResponse + 'static,
    <L::Service as Service<Request>>::Error: Into<Infallible> + 'static,
    <L::Service as Service<Request>>::Future: Send + 'static,

请注意，中间件仅应用于现有路由。因此，您必须首先添加您的路由（和/或回调），然后在之后调用 route_layer。调用 route_layer 后添加的额外路由将不会添加中间件。

这与 Router::layer 类似，不同之处在于只有当请求匹配路由时中间件才会运行。这对于提前返回的中间件非常有用（例如授权），否则可能会将 404 Not Found 转换为 401 Unauthorized。

示例

use axum::{
	routing::get,
	Router,
};
use tower_http::validate_request::ValidateRequestHeaderLayer;

let app = Router::new()
	.route("/foo", get(|| async {}))
	.route_layer(ValidateRequestHeaderLayer::bearer("password"));

// `GET /foo` 使用有效令牌将接收 `200 OK`
// `GET /foo` 使用无效令牌将接收 `401 未经授权`
// `GET /not-found` 使用无效令牌将接收 `404 未找到`

向路由器添加一个回退处理程序

pub fn fallback<H, T>(self, handler: H) -> Self
where
  H: Handler<T, S>,
	T: 'static

如果没有任何路由匹配传入的请求，将调用此服务。

use axum::{
	routing::get,
	Router,
	handler::Handler,
	response::IntoResponse,
	http::{StatusCode, Uri},
};

let app = Router::new()
  .route("/foo", get(|| async { "foo" }))
	.fallback(fallback);

async fn fallback(uri: Uri) -> (StatusCode, String) {
	(StatusCode::NOT_FOUND, format!("No route for {uri}"))
}

仅在路由器中没有匹配任何内容的路由时才适用回退。如果处理程序被请求匹配但返回 404，则不会调用回退。

处理所有没有其他路由的请求

如果没有其他路由，使用Router::new().fallback(...)来接受所有请求，无论路径或方法如何，这并不是最佳选择：

use axum::Router;

async fn handler() {}

let app = Router::new().fallback(handler);

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();

直接运行处理程序会更快，因为它避免了路由的开销:

use axum::handler::HandlerWithoutStateExt;

async fn handler() {}

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, handler.into_make_service()).await.unwrap();

向路由器添加一个回退服务

pub fn fallback_service<T>(self, service: T) -> Self
where
	T: Service<Request, Error=Infallible> + Clone + Send + 'static,
	T::Response: IntoResponse,
	T::Future: Send + 'static,

查看Router::fallback以获取更多详细信息。

为路由器提供状态

pub fn with_state<S2>(self, state: S) -> Router<S2>

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

#[derive(Clone)]
struct AppState {}

let routes = Router::new()
    .route("/", get(|State(state): State<AppState>| async {
        // use state
    }))
    .with_state(AppState {});

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, routes).await.unwrap();

从函数中返回带状态的路由器

在从函数返回 Router 时，通常建议不直接设置状态

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

#[derive(Clone)]
struct AppState {}

// 不要在这里调用 `Router::with_state`
fn routes() -> Router<AppState> {
    Router::new()
        .route("/", get(|_: State<AppState>| async {}))
}

// 在运行服务器之前执行
let routes = routes().with_state(AppState {});

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, routes).await.unwrap();

如果确实需要提供状态，并且您没有将路由嵌套/合并到另一个路由器中，则返回不带任何类型参数的 Router:

// 不要返回 `Router<AppState>`
fn routes(state: AppState) -> Router {
    Router::new()
        .route("/", get(|_: State<AppState>| async {}))
        .with_state(state)
}

let routes = routes(AppState {});

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, routes).await.unwrap();

这是因为我们只能在 Router<()> 上调用 Router::into_make_service，而不能在 Router<AppState> 上调用。有关原因的更多详细信息，请参见下文。

请注意，状态默认为()，所以Router和Router<()>是一样的。

如果您需要嵌套/合并路由器，建议在结果路由器上使用通用状态类型：

fn routes<S>(state: AppState) -> Router<S> {
    Router::new()
        .route("/", get(|_: State<AppState>| async {}))
        .with_state(state)
}

let routes = Router::new().nest("/api", routes(AppState {}));

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, routes).await.unwrap();

状态是路由器内的全局状态

传递给此方法的状态将用于该路由器接收的所有请求。这意味着它不适合保存从请求中派生的状态，比如在中间件中提取的授权数据。请改用 Extension 来存储此类数据。

`Router<S>`中的`S`代表什么

Router<S>表示一个缺少类型为S的状态以处理请求的路由器。它并不意味着具有类型为S的状态的路由器。

例如：

// 需要`AppState`来处理请求的路由器
let router: Router<AppState> = Router::new()
  .route("/", get(|_: State<AppState>| async {}));

// 一旦我们调用 `Router::with_state` 方法，路由器就不再缺少状态了，因为我们刚刚提供了它
//
// 因此，路由器类型变为`Router<()>`，即一个不缺少任何状态的路由器。
let router: Router<()> = router.with_state(AppState {});

// 只有 `Router<()>` 具有 `into_make_service` 方法。
//
// 因为它仍然缺少 `AppState`，所以不能在 `Router<AppState>` 上调用 `into_make_service`。
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, router).await.unwrap();

或许有点反直觉，Router::with_state 并不总是返回一个 Router<()>。相反，您可以选择新的缺失状态类型是什么：

let router: Router<AppState> = Router::new()
    .route("/", get(|_: State<AppState>| async {}));

// 当我们调用`with_state`时，我们可以选择下一个丢失的状态类型是什么。在这里我们选择`String`
let string_router: Router<String> = router.with_state(AppState {});

// 这允许我们添加使用`String`作为状态类型的新路由
let string_router = string_router
    .route("/needs-string", get(|_: State<String>| async {}));

// 提供`String`，并选择 `()` 作为新的缺失状态。
let final_router: Router<()> = string_router.with_state("foo".to_owned());

// 既然我们有一个`Router<()>`，我们可以运行它。
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, final_router).await.unwrap();

为什么在调用with_state后返回Router<AppState>不起作用？

// 这不会起作用，因为我们正在返回 `Router<AppState>`
// 即，我们在说我们仍然缺少一个 `AppState`
fn routes(state: AppState) -> Router<AppState> {
    Router::new()
        .route("/", get(|_: State<AppState>| async {}))
        .with_state(state)
}

let app = routes(AppState {});

// 我们只能在 `Router<()>` 上调用 `Router::into_make_service` 方法，
// 而 `app` 是 `Router<AppState>`
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();

由于我们提供了所需的所有状态，因此请返回 Router<()>。

// 我们已经提供了所有必要的状态，因此返回 `Router<()>`。
fn routes(state: AppState) -> Router<()> {
    Router::new()
        .route("/", get(|_: State<AppState>| async {}))
        .with_state(state)
}

let app = routes(AppState {});

// 我们现在可以调用 `Router::into_make_service`。
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();

关于性能的说明

如果您需要一个实现 Service 但不需要任何状态的 Router（也许您正在制作一个在内部使用 axum 的库），那么建议在开始提供请求之前调用该方法：

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

let app = Router::new()
    .route("/", get(|| async { /* ... */ }))
    // 即使我们不需要任何状态，也要调用`with_state(())`。
    .with_state(());

这不是必需的，但它让 axum 有机会更新路由器中的一些内部内容，可能会影响性能并减少分配。

备注

请注意，Router::into_make_service 和 Router::into_make_service_with_connect_info 会自动执行此操作。

将路由器转换为带有固定请求体类型的借用服务，以辅助类型推断

pub fn as_service<B>(&mut self) -> RouterAsService<'_, B, S>

在某些情况下，在 Router 上调用 tower::ServiceExt 的方法时，可能会出现类似以下内容的类型推断错误

let response = router.ready().await?.call(request).await?;
                      ^^^^^ cannot infer type for type parameter `B`

这是因为 Router 使用 impl<B> Service<Request<B>> for Router<()> 实现了 Service。

例如：

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

let mut router = Router::new().route("/", get(|| async {}));
let request = Request::new(Body::empty());
let response = router.ready().await?.call(request).await?;

调用 Router::as_service 可以解决此问题。

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

let mut router = Router::new().route("/", get(|| async {}));
let request = Request::new(Body::empty());
let response = router.as_service().ready().await?.call(request).await?;

这主要是在测试时调用路由时使用的。当通过 Router::into_make_service 正常运行路由时，这是不必要的。

将路由器转换为具有固定请求正文类型的所有服务，以帮助类型推断

pub fn into_service<B>(self) -> RouterIntoService<B, S>

这与 Router::as_service 相同，只是它返回一个拥有的服务。有关更多详细信息，请参见该方法。

`impl Router`

`pub fn into_make_service(self) -> IntoMakeService<Self>`

将此路由器转换为一个 MakeService，它是一个响应是另一个服务的服务。

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

let app = Router::new().route("/", get(|| async { "Hi!" }));

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();

仅在tokio特性上可用

pub fn into_make_service_with_connect_info<C>(
    self
) -> IntoMakeServiceWithConnectInfo<Self, C>

将这个路由器转换为一个MakeService，它将把C的相关ConnectInfo存储在一个请求扩展中，以便ConnectInfo可以提取它。

这使得可以提取类似客户端远程地址的信息。

提取std::net::SocketAddr 是开箱即用的。

use axum::{
    extract::ConnectInfo,
    routing::get,
    Router,
};
use std::net::SocketAddr;

let app = Router::new().route("/", get(handler));

async fn handler(ConnectInfo(addr): ConnectInfo<SocketAddr>) -> String {
    format!("Hello {addr}")
}

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app.into_make_service_with_connect_info::<SocketAddr>()).await.unwrap();

您可以这样实现自定义连接(Connected):

use axum::{
    extract::connect_info::{ConnectInfo, Connected},
    routing::get,
    serve::IncomingStream,
    Router,
};

let app = Router::new().route("/", get(handler));

async fn handler(
    ConnectInfo(my_connect_info): ConnectInfo<MyConnectInfo>,
) -> String {
    format!("Hello {my_connect_info:?}")
}

#[derive(Clone, Debug)]
struct MyConnectInfo {
    // ...
}

impl Connected<IncomingStream<'_>> for MyConnectInfo {
    fn connect_info(target: IncomingStream<'_>) -> Self {
        MyConnectInfo {
            // ...
        }
    }
}

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app.into_make_service_with_connect_info::<MyConnectInfo>()).await.unwrap();

Trait实现

`impl<S> Clone for Router<S>`

fn clone(&self) -> Self: 返回一个克隆值。
fn clone_from(&mut self, source: &Self): 从源(source)执行复制赋值。

`impl<S> Debug for Router<S>`

fn fmt(&self, f: &mut Formatter<'_>) -> Result: 使用给定的格式器格式化值

`impl<S> Default for Router<S> where S: Clone + Send + Sync + 'static`

fn default() -> Self: 返回一个默认值。

`impl Service<IncomingStream<'_>> for Router<()>`

仅在 tokio crate 功能和 (crate 功能 http1 或 http2) 中可用。

`type Response = Router`

由服务提供的响应。

`type Error = Infallible`

由服务生成的错误

`type Future = Ready<Result<<Router as Service<IncomingStream<'_>>>::Response, <Router as Service<IncomingStream<'_>>>::Error>>`

功能响应值

`fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>`

当服务能够处理请求时，返回 Poll::Ready(Ok(()))。

`fn call(&mut self, _req: IncomingStream<'_>) -> Self::Future`

处理请求并异步返回响应。

impl<B> Service<Request<B>> for Router<()>
where
    B: HttpBody<Data = Bytes> + Send + 'static,
    B::Error: Into<BoxError>,

`type Response = Response<Body>`

由服务提供的响应。

`type Error = Infallible`

由服务生成的错误

`type Future = RouteFuture<Infallible>`

功能响应值

`fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>`

当服务能够处理请求时，返回 Poll::Ready(Ok(()))。

`fn call(&mut self, req: Request<B>) -> Self::Future`

异步处理请求并返回响应

自动特性实现

impl<S> Freeze for Router<S>
impl<S = ()> !RefUnwindSafe for Router<S>
impl<S> Send for Router<S>
impl<S> Sync for Router<S>
impl<S> Unpin for Router<S>
impl<S = ()> !UnwindSafe for Router<S>

通用实现

impl<T> Any for T
where
  T: 'static + ?Sized,

impl<T> Borrow<T> for T
where
  T: ?Sized,

impl<T> BorrowMut<T> for T
where
  T: ?Sized,

impl<T> From<T> for T

impl<T> FromRef<T> for T
where
  T: Clone,

impl<T> Instrument for T

impl<T, U> Into<U> for T
where
  U: From<T>,

impl<M, S, Target, Request> MakeService<Target, Request> for M
where
  M: Service<Target, Response = S>,
  S: Service<Request>,

impl<T> PolicyExt for T
where
  T: ?Sized,

impl<T> Same for T

impl<S, R> ServiceExt<R> for S
where
  S: Service<R>,

impl<T, Request> ServiceExt<Request> for T
where
  T: Service<Request> + ?Sized,

impl<T> ToOwned for T
where
  T: Clone,

impl<T, U> TryFrom<U> for T
where
  U: Into<T>,

impl<T, U> TryInto<U> for T
where
  U: TryFrom<T>,

impl<V, T> VZip<V> for T
where
  V: MultiLane<T>,

impl<T> WithSubscriber for T

axum路由器

axum::Router结构体​

实现​

新建路由器​

添加另一个路由到路由器​

静态路径​

捕获​

通配符​

接受多种方法​

Panics​

路由服务​

使用Router::nest替换​

URI如何变化​

外部路由的捕获​

与通配符路由的区别​

后备方案​

用状态嵌套路由器​

恐慌​

与nest类似，但接受任何服务​

将两个路由器的路径(path)和回退(fallbacks)合并到一个路由器​

合并路由器的状态​

合并具有回退的路由器​

将 tower::Layer 应用于路由器中的所有路由。​

多中间件​

路由之后运行​

错误处理​

向路由器应用一个 tower::Layer，只有当请求匹配路由时才会运行​

向路由器添加一个回退处理程序​

处理所有没有其他路由的请求​

向路由器添加一个回退服务​

为路由器提供状态​

从函数中返回带状态的路由器​

状态是路由器内的全局状态​

Router<S>中的S代表什么​

关于性能的说明​

将路由器转换为带有固定请求体类型的借用服务，以辅助类型推断​

将路由器转换为具有固定请求正文类型的所有服务，以帮助类型推断​

impl Router​

pub fn into_make_service(self) -> IntoMakeService<Self>​

仅在tokio特性上可用​

Trait实现​

impl<S> Clone for Router<S>​

impl<S> Debug for Router<S>​

impl<S> Default for Router<S> where S: Clone + Send + Sync + 'static​

impl Service<IncomingStream<'_>> for Router<()>​

type Response = Router​

type Error = Infallible​

type Future = Ready<Result<<Router as Service<IncomingStream<'_>>>::Response, <Router as Service<IncomingStream<'_>>>::Error>>​

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>​

fn call(&mut self, _req: IncomingStream<'_>) -> Self::Future​

type Response = Response<Body>​

type Error = Infallible​

type Future = RouteFuture<Infallible>​

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>​

fn call(&mut self, req: Request<B>) -> Self::Future​

自动特性实现​

通用实现​

`axum::Router`结构体

实现

新建路由器

添加另一个路由到路由器

静态路径

捕获

通配符

接受多种方法

Panics

路由服务

使用`Router::nest`替换

URI如何变化

外部路由的捕获

与通配符路由的区别

后备方案

用状态嵌套路由器

恐慌

与`nest`类似，但接受任何服务

将两个路由器的路径(`path`)和回退(`fallbacks`)合并到一个路由器

合并路由器的状态

合并具有回退的路由器

将 `tower::Layer` 应用于路由器中的所有路由。

多中间件

路由之后运行

错误处理

向路由器应用一个 `tower::Layer`，只有当请求匹配路由时才会运行

向路由器添加一个回退处理程序

处理所有没有其他路由的请求

向路由器添加一个回退服务

为路由器提供状态

从函数中返回带状态的路由器

状态是路由器内的全局状态

`Router<S>`中的`S`代表什么

关于性能的说明

将路由器转换为带有固定请求体类型的借用服务，以辅助类型推断

将路由器转换为具有固定请求正文类型的所有服务，以帮助类型推断

`impl Router`

`pub fn into_make_service(self) -> IntoMakeService<Self>`

仅在tokio特性上可用

Trait实现

`impl<S> Clone for Router<S>`

`impl<S> Debug for Router<S>`

`impl<S> Default for Router<S> where S: Clone + Send + Sync + 'static`

`impl Service<IncomingStream<'_>> for Router<()>`

`type Response = Router`

`type Error = Infallible`

`type Future = Ready<Result<<Router as Service<IncomingStream<'_>>>::Response, <Router as Service<IncomingStream<'_>>>::Error>>`

`fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>`

`fn call(&mut self, _req: IncomingStream<'_>) -> Self::Future`

`type Response = Response<Body>`

`type Error = Infallible`

`type Future = RouteFuture<Infallible>`

`fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>`

`fn call(&mut self, req: Request<B>) -> Self::Future`

自动特性实现

通用实现