307 Temporary Redirect 原样回到调用方

tower-http = { version = "=0.7.1", features = ["follow-redirect"] }
axum = { version = "=0.8.9", default-features = false, features = ["tokio", "http1"] }
tower = { version = "=0.5.3", features = ["util"] }
hyper = "1"
hyper-util = { version = "=0.1.21", features = ["client-legacy", "http1", "tokio"] }
http = "1"
http-body-util = "0.1"
bytes = "1"
tokio = { version = "=1.54.1", features = ["macros", "rt", "net"] }

use axum::response::Redirect;
use axum::routing::{any, get, post};
use axum::Router;
use bytes::Bytes;
use http::Request;
use http_body_util::{BodyExt, Full};
use hyper_util::{client::legacy::Client, rt::TokioExecutor};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use tower::{ServiceBuilder, ServiceExt};
use tower_http::follow_redirect::{policy, policy::PolicyExt, FollowRedirectLayer, RequestUri};

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let hits = Arc::new(AtomicUsize::new(0));
  let h = hits.clone();
  let app = Router::new()
    .route("/form", post(|| async { Redirect::temporary("/done") }))
    .route("/done", any(|body: Bytes| async move { format!("done, got {} bytes", body.len()) }))
    .route("/loop", get(move || {
      h.fetch_add(1, Ordering::SeqCst);
      async { Redirect::to("/loop") }
    }));
  let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });

  let client = Client::builder(TokioExecutor::new()).build_http::<Full<Bytes>>();

  // 打印最终状态码、最后一跳的地址（RequestUri 扩展）、Location 和 body
  let send = |name: &'static str, svc, req: Request<Full<Bytes>>| async move {
    let svc: tower::util::BoxCloneService<_, http::Response<hyper::body::Incoming>, _> = svc;
    let res = svc.oneshot(req).await.unwrap();
    let uri = res.extensions().get::<RequestUri>().unwrap().0.path().to_owned();
    let loc = res.headers().get("location").map(|v| v.to_str().unwrap().to_owned());
    let status = res.status();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{name:<34} {status} last={uri} location={loc:?} {body:?}");
  };

  let standard = ServiceBuilder::new().layer(FollowRedirectLayer::new()).service(client.clone()).boxed_clone();
  let cloning = ServiceBuilder::new()
    .layer(FollowRedirectLayer::with_policy(
      policy::Standard::default().and::<_, Full<Bytes>, hyper_util::client::legacy::Error>(policy::clone_body_fn(|b: &Full<Bytes>| Some(b.clone()))),
    ))
    .service(client.clone())
    .boxed_clone();

  let form = || Request::post(format!("http://{addr}/form")).body(Full::from("a=1&b=2")).unwrap();
  let empty_form = || Request::post(format!("http://{addr}/form")).body(Full::default()).unwrap();
  send("Standard, POST /form (7 bytes)", standard.clone(), form()).await;
  send("Standard, POST /form (empty)", standard.clone(), empty_form()).await;
  send("Standard + clone_body_fn, POST", cloning, form()).await;
  send("Standard, GET /loop", standard, Request::get(format!("http://{addr}/loop")).body(Full::default()).unwrap()).await;
  println!("/loop handler ran {} times", hits.load(Ordering::SeqCst));
}

Standard, POST /form (7 bytes)     307 Temporary Redirect last=/form location=Some("/done") b""
Standard, POST /form (empty)       200 OK last=/done location=None b"done, got 0 bytes"
Standard + clone_body_fn, POST     200 OK last=/done location=None b"done, got 7 bytes"
Standard, GET /loop                303 See Other last=/loop location=Some("/loop") b""
/loop handler ran 21 times

        let body = if let Some(body) = this.body.take() {
            body
        } else {
            return Poll::Ready(Ok(res));
        };