原始 body：两个支付回调

    // M5c：微信支付 v3 异步回调（JSON）。验签需原始 body 逐字节一致 → 用 Bytes。
    .route(
      "/api/pay/wechat/notify",
      post(|headers: HeaderMap, body: axum::body::Bytes| async move {
        let mut map = std::collections::HashMap::new();
        for (k, v) in headers.iter() {
          if let Ok(s) = v.to_str() {
            map.insert(k.as_str().to_ascii_lowercase(), s.to_string());
          }
        }
        let body_str = String::from_utf8_lossy(&body).to_string();
        let (code, resp) = module_course::server::handle_wechat_notify(map, body_str).await;
        // ...
      }),
    )
    // 阶段 I：Stripe webhook（JSON）。验签同样需要原始 body。
    .route(
      "/api/pay/stripe/notify",
      post(|headers: HeaderMap, body: axum::body::Bytes| async move {
        let signature = headers
          .get("stripe-signature")
          .and_then(|v| v.to_str().ok())
          .unwrap_or_default()
          .to_string();
        let body_str = String::from_utf8_lossy(&body).to_string();
        let code = module_course::server::handle_stripe_notify(signature, body_str).await;
        // ...
      }),
    )

    mac.update(format!("{ts}.{body}").as_bytes());
    mac.verify_slice(&sig).is_ok()

fn main() {
  // 支付平台发来的原始 body（有空格、有 \u 转义、键的顺序是平台定的）
  let raw: &[u8] = br#"{"type": "checkout.session.completed", "id": "evt_1", "note": "café"}"#;
  let value: serde_json::Value = serde_json::from_slice(raw).unwrap();
  let again = serde_json::to_vec(&value).unwrap();
  println!("原始:   {}", String::from_utf8_lossy(raw));
  println!("再序列化: {}", String::from_utf8_lossy(&again));
  println!("字节相同: {}", raw == &again[..]);
}

原始:   {"type": "checkout.session.completed", "id": "evt_1", "note": "café"}
再序列化: {"id":"evt_1","note":"café","type":"checkout.session.completed"}
字节相同: false

    fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
        if !self.read_buf.is_empty() {
            let n = std::cmp::min(len, self.read_buf.len());
            Poll::Ready(Ok(self.read_buf.split_to(n).freeze()))
        } else {
            let n = ready!(self.poll_read_from_io(cx))?;
            Poll::Ready(Ok(self.read_buf.split_to(::std::cmp::min(len, n)).freeze()))
        }
    }

        let bytes = req
            .into_limited_body()
            .collect()
            .await
            .map_err(FailedToBufferBody::from_err)?
            .to_bytes();

    #[inline]
    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
        // Our inner buffer may have an optimized version of copy_to_bytes, and if the whole
        // request can be fulfilled by the front buffer, we can take advantage.
        match self.bufs.front_mut() {
            Some(front) if front.remaining() == len => {
                let b = front.copy_to_bytes(len);
                self.bufs.pop_front();
                b
            }
            Some(front) if front.remaining() > len => front.copy_to_bytes(len),
            _ => {
                let rem = self.remaining();
                assert!(len <= rem, "`len` greater than remaining");
                let mut bm = BytesMut::with_capacity(len);
                if rem == len {
                    // .take() costs a lot more, so skip it if we don't need it
                    bm.put(self);
                } else {
                    bm.put(self.take(len));
                }
                bm.freeze()
            }
        }
    }

bytes = "=1.12.1"
tokio = { version = "=1.54.1", features = ["full"] }
axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
futures-util = "0.3"

use std::alloc::{GlobalAlloc, Layout, System};
use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};

use axum::{
  Router,
  body::{Body, Bytes, to_bytes},
  extract::Request,
  http::HeaderMap,
  routing::post,
};
use tower::ServiceExt;

const KIB: usize = 1024;
const BIG: usize = 16 * KIB; // 只记录 16 KiB 以上的分配

struct Counting;
static BIG_N: AtomicUsize = AtomicUsize::new(0);
static BIG_SIZES: [AtomicUsize; 16] = [const { AtomicUsize::new(0) }; 16];

unsafe impl GlobalAlloc for Counting {
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    if layout.size() >= BIG {
      let i = BIG_N.fetch_add(1, Relaxed);
      if i < 16 {
        BIG_SIZES[i].store(layout.size(), Relaxed);
      }
    }
    unsafe { System.alloc(layout) }
  }
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
    unsafe { System.dealloc(ptr, layout) }
  }
}

#[global_allocator]
static GLOBAL: Counting = Counting;

fn big_allocs() -> Vec<usize> {
  let n = BIG_N.swap(0, Relaxed).min(16);
  (0..n).map(|i| BIG_SIZES[i].load(Relaxed)).collect()
}

// 和本站 /api/pay/stripe/notify 一样：HeaderMap + Bytes，再转成 String
async fn notify(_headers: HeaderMap, body: Bytes) -> String {
  let body_ptr = body.as_ptr() as usize;
  let unique = body.is_unique();
  let body_str = String::from_utf8_lossy(&body).to_string();
  format!("{body_ptr} {} {unique} {}", body.len(), body_str.as_ptr() as usize)
}

async fn run(app: &Router, label: &str, chunk_size: usize, total: usize) {
  let chunks: Vec<Bytes> = (0..total / chunk_size)
    .map(|_| Bytes::from(vec![b'{'; chunk_size]))
    .collect();
  let first_chunk = chunks[0].as_ptr() as usize;
  let stream = futures_util::stream::iter(chunks.into_iter().map(Ok::<_, std::io::Error>));
  let req = Request::post("/notify").body(Body::from_stream(stream)).unwrap();

  big_allocs(); // 清零
  let res = app.clone().oneshot(req).await.unwrap();
  let big = big_allocs();

  let text = to_bytes(res.into_body(), 1024).await.unwrap();
  let text = String::from_utf8_lossy(&text);
  let mut it = text.split(' ');
  let body_ptr: usize = it.next().unwrap().parse().unwrap();
  let len = it.next().unwrap();
  let unique = it.next().unwrap();
  let str_ptr: usize = it.next().unwrap().parse().unwrap();
  println!("{label}: len={len}");
  println!("  Bytes 指向第一块: {}", body_ptr == first_chunk);
  println!("  Bytes is_unique: {unique}");
  println!("  String 和 Bytes 同址: {}", str_ptr == body_ptr);
  println!("  16 KiB 以上的分配: {big:?}");
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let app = Router::new().route("/notify", post(notify));
  run(&app, "1 块 x 64 KiB", 64 * KIB, 64 * KIB).await;
  run(&app, "16 块 x 4 KiB", 4 * KIB, 64 * KIB).await;
}

1 块 x 64 KiB: len=65536
  Bytes 指向第一块: true
  Bytes is_unique: true
  String 和 Bytes 同址: false
  16 KiB 以上的分配: [65536]
16 块 x 4 KiB: len=65536
  Bytes 指向第一块: false
  Bytes is_unique: true
  String 和 Bytes 同址: false
  16 KiB 以上的分配: [65536, 65536]

2 KiB
  1 块，第一块 is_unique=false，各块 [2048]
  Bytes: len=2048 is_unique=false
64 KiB
  4 块，第一块 is_unique=false，各块 [16308, 16384, 32768, 76]
  Bytes: len=65536 is_unique=true
256 KiB
  11 块，第一块 is_unique=false，各块 [16307, 16384, 32768, 32456, 32664, 16332, 16332, 32664, 32664, 32664, 909]
  Bytes: len=262144 is_unique=true