dioxus 生成的 Router

pub fn router(app: fn() -> Element) -> Router {
    let cfg = ServeConfig::new();
    apply_base_path(
        Router::new().serve_dioxus_application(cfg.clone(), app),
        app,
        cfg,
        base_path().map(|s| s.to_string()),
    )
}

    fn serve_dioxus_application<M: 'static>(
        self,
        cfg: ServeConfig,
        app: impl ComponentFunction<(), M> + Send + Sync,
    ) -> Router<()> {
        self.register_server_functions()
            .serve_static_assets()
            .fallback(get(FullstackState::render_handler))
            .with_state(FullstackState::new(cfg, app))
    }

    fn register_server_functions(mut self) -> Router<FullstackState> {
        use std::collections::HashSet;

        let mut seen = HashSet::new();

        for func in ServerFunction::collect() {
            if seen.insert(format!("{} {}", func.method(), func.path())) {
                tracing::info!("Registering: {} {}", func.method(), func.path());

                self = self.route(func.path(), func.method_router())
            }
        }

        self
    }

        axum::routing::method_routing::on(
            method
                .try_into()
                .expect("MethodFilter only supports standard HTTP methods"),
            move |state: State<FullstackState>, request: Request| async move {
                // ...
                let result = state.rt.spawn_pinned(move || async move {
                    // ...
                    let (parts, body) = request.into_parts();
                    let server_context = FullstackContext::new(parts.clone());
                    let request = axum::extract::Request::from_parts(parts, body);
                    // ...
                }).await;

                match result {
                    Ok(response) => response,
                    Err(err) => Response::builder()
                        .status(StatusCode::INTERNAL_SERVER_ERROR)
                        .body(Body::new(if cfg!(debug_assertions) {
                            format!("Server function panicked: {}", err)
                        } else {
                            "Internal Server Error".to_string()
                        }))
                        .unwrap(),
                }
            },
        )

        if path.is_dir() {
            // ...
            #[cfg(debug_assertions)]
            {
                router = router.nest_service(&route, ServeDir::new(&path));
            }

            #[cfg(not(debug_assertions))]
            {
                router = serve_dir_cached(router, public_path, &path);
            }
        } else {
            let serve_file = ServeFile::new(&path).precompressed_br();
            // ...
            if file_name_looks_immutable(&route) {
                router = router.nest_service(&route, cache_response_forever(serve_file))
            } else {
                router = router.nest_service(&route, serve_file)
            }
        }

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread"] }

use std::collections::HashSet;
use std::sync::Mutex;

use axum::{
  Router,
  body::{Body, to_bytes},
  extract::{Request, State},
  http::{Method, header},
  middleware::{Next, from_fn},
  response::Response,
  routing::{MethodFilter, get, on},
};
use tower::ServiceExt;

// 相当于 FullstackState：只有 dioxus 自己的 handler 能拿到它
#[derive(Clone)]
struct FullstackState;

static SEEN: Mutex<Vec<String>> = Mutex::new(Vec::new());

// 相当于 inventory 收集到的 ServerFunction：(方法, 路径)，故意放一个重复项
const SERVER_FNS: &[(&str, &str)] = &[
  ("POST", "/api/topics/list"),
  ("POST", "/api/list_blog_posts1234"), // #[server] 不写路径：/api/ + 函数名 + 一串数字
  ("POST", "/api/topics/list"),         // 两个 crate 写了同一个路径
];

async fn server_fn(State(_): State<FullstackState>, req: Request) -> String {
  format!("server fn {}", req.uri().path())
}

async fn render_handler(State(_): State<FullstackState>, req: Request) -> String {
  format!("ssr {}", req.uri().path())
}

async fn outer_mw(req: Request, next: Next) -> Response {
  SEEN.lock().unwrap().push(format!("{} {}", req.method(), req.uri().path()));
  next.run(req).await
}

fn dioxus_router() -> Router {
  let mut router: Router<FullstackState> = Router::new();
  // register_server_functions：按「方法 路径」去重，再逐个 route
  let mut seen = HashSet::new();
  for (method, path) in SERVER_FNS {
    if seen.insert(format!("{method} {path}")) {
      let filter = MethodFilter::try_from(Method::from_bytes(method.as_bytes()).unwrap()).unwrap();
      router = router.route(path, on(filter, server_fn));
    }
  }
  // SSR 作为 fallback，然后立刻 with_state
  router.fallback(get(render_handler)).with_state(FullstackState)
}

async fn send(app: &Router, method: Method, path: &str) {
  SEEN.lock().unwrap().clear();
  let req = Request::builder().method(method.clone()).uri(path).body(Body::empty()).unwrap();
  let res = app.clone().oneshot(req).await.unwrap();
  let status = res.status().as_u16();
  let allow = res.headers().get(header::ALLOW).map(|v| v.to_str().unwrap().to_owned());
  let body = to_bytes(res.into_body(), 1024).await.unwrap();
  let seen = !SEEN.lock().unwrap().is_empty();
  println!(
    "{:<5}{:<26} {status} allow={:<10} mw={seen:<5} body={:?}",
    method.as_str(),
    path,
    allow.unwrap_or("-".into()),
    String::from_utf8_lossy(&body)
  );
}

#[tokio::main]
async fn main() {
  // main.rs 的顺序：先 route / mount，最后才 layer
  let app = dioxus_router()
    .route("/healthz", get(|| async { "ok" }))
    .layer(from_fn(outer_mw));

  send(&app, Method::GET, "/healthz").await;
  send(&app, Method::POST, "/api/topics/list").await;
  send(&app, Method::GET, "/api/topics/list").await;
  send(&app, Method::POST, "/api/list_blog_posts1234").await;
  send(&app, Method::GET, "/blog/hello").await;
  send(&app, Method::HEAD, "/blog/hello").await;
  send(&app, Method::POST, "/blog/hello").await;
  send(&app, Method::POST, "/api/nope").await;

  // 不去重会怎样：axum 自己对同一方法同一路径 panic
  std::panic::set_hook(Box::new(|_| {}));
  let r = std::panic::catch_unwind(|| {
    Router::<()>::new()
      .route("/api/topics/list", on(MethodFilter::POST, || async {}))
      .route("/api/topics/list", on(MethodFilter::POST, || async {}))
  });
  if let Err(e) = r {
    let msg = e.downcast_ref::<String>().cloned().unwrap_or_default();
    println!("without dedupe: panic: {msg}");
  }
}

    let router = dioxus::server::router(App)
      // S3：健康检查（ok/degraded），供 LB / 监控 / 部署脚本判活。
      .route("/healthz", get(crate::server::health::healthz));
    #[cfg(feature = "accounts")]
    let router = crate::server::auth_routes::mount(router, cookie_is_secure);
    let router = crate::server::static_assets::mount(router, assets_root);
    let router = crate::server::pay_routes::mount(router);
    // ...
    let router = crate::server::seo::mount(router, &base_url);

    // S2（风险 R4）：应用层 per-IP 限流，仅作用于 /api/*（auth / pay 更严）。
    // ...
    let router = router.layer(axum::middleware::from_fn(crate::server::rate_limit::rate_limit_mw));
    // ...（尾斜杠、压缩、安全头，共四次 layer）

    Ok(router)

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use axum::{
  Router,
  body::{Body, Bytes, to_bytes},
  extract::{FromRequest, Request},
  http::StatusCode,
  response::{IntoResponse, Response},
  routing::post,
};
use serde::Deserialize;
use tower::ServiceExt;

#[derive(Deserialize)]
struct UploadArgs {
  name: String,
  data_base64: String,
}

async fn upload_image(req: Request) -> Response {
  // make_handler 用的是 LocalPoolHandle::spawn_pinned，这里用 tokio::spawn，panic 时同样得到 JoinError
  let result = tokio::spawn(async move {
    let bytes = Bytes::from_request(req, &()).await.unwrap();
    match serde_json::from_slice::<UploadArgs>(&bytes) {
      Ok(args) => {
        // 站点自己的 5 MiB 检查（check_upload_size：按 len * 3 / 4 估算）
        let estimated = args.data_base64.len() * 3 / 4;
        if estimated > 5 * 1024 * 1024 {
          (StatusCode::INTERNAL_SERVER_ERROR, "文件过大（限制 5 MB）").into_response()
        } else {
          format!("ok {} ~{} bytes", args.name, estimated).into_response()
        }
      }
      Err(e) => (StatusCode::BAD_REQUEST, e.to_string()).into_response(),
    }
  })
  .await;
  match result {
    Ok(res) => res,
    Err(_) => Response::builder()
      .status(StatusCode::INTERNAL_SERVER_ERROR)
      .body(Body::new("Internal Server Error".to_string()))
      .unwrap(),
  }
}

#[tokio::main]
async fn main() {
  std::panic::set_hook(Box::new(|info| {
    let msg = info.payload().downcast_ref::<String>().cloned().unwrap_or_default();
    println!("  [panic] {msg}");
  }));
  let app = Router::new().route("/api/upload", post(upload_image));
  for image_bytes in [1_000_000usize, 1_500_000, 1_600_000, 4_000_000, 6_000_000] {
    let b64_len = image_bytes.div_ceil(3) * 4;
    let json = format!(r#"{{"name":"a.png","data_base64":"{}"}}"#, "A".repeat(b64_len));
    println!("image {image_bytes} B -> json {} B", json.len());
    let req = Request::post("/api/upload").header("content-type", "application/json").body(Body::from(json)).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    let status = res.status().as_u16();
    let body = to_bytes(res.into_body(), 1 << 20).await.unwrap();
    println!("  {status} {:?}", String::from_utf8_lossy(&body));
  }
}

image 1000000 B -> json 1333369 B
  200 "ok a.png ~1000002 bytes"
image 1500000 B -> json 2000033 B
  200 "ok a.png ~1500000 bytes"
image 1600000 B -> json 2133369 B
  [panic] called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))
  500 "Internal Server Error"
image 4000000 B -> json 5333369 B
  [panic] called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))
  500 "Internal Server Error"
image 6000000 B -> json 8000033 B
  [panic] called `Result::unwrap()` on an `Err` value: FailedToBufferBody(LengthLimitError(LengthLimitError(Error { inner: LengthLimitError })))
  500 "Internal Server Error"

GET  /healthz                   200 allow=-          mw=true  body="ok"
POST /api/topics/list           200 allow=-          mw=true  body="server fn /api/topics/list"
GET  /api/topics/list           405 allow=POST       mw=true  body=""
POST /api/list_blog_posts1234   200 allow=-          mw=true  body="server fn /api/list_blog_posts1234"
GET  /blog/hello                200 allow=-          mw=true  body="ssr /blog/hello"
HEAD /blog/hello                200 allow=-          mw=true  body=""
POST /blog/hello                405 allow=GET,HEAD   mw=true  body=""
POST /api/nope                  405 allow=GET,HEAD   mw=true  body=""
without dedupe: panic: Overlapping method route. Handler for `POST /api/topics/list` already exists