压缩的内部

pub struct Compression<S, P = DefaultPredicate> {
    pub(crate) inner: S,
    pub(crate) accept: AcceptEncoding,
    pub(crate) predicate: P,
    pub(crate) quality: CompressionLevel,
}

pub struct DefaultPredicate(
    And<And<And<SizeAbove, NotForContentType>, NotForContentType>, NotForContentType>,
);

        let content_size = response.body().size_hint().exact().or_else(|| {
            response
                .headers()
                .get(header::CONTENT_LENGTH)
                .and_then(|h| h.to_str().ok())
                .and_then(|val| val.parse().ok())
        });

        match content_size {
            Some(size) => size >= self.0,
            _ => true,
        }

pin_project_cfg! {
    #[project = BodyInnerProj]
    pub(crate) enum BodyInner<B>
    where
        B: Body,
    {
        #[cfg(feature = "compression-gzip")]
        Gzip {
            #[pin]
            inner: GzipBody<B>,
        },
        // Deflate、Brotli、Zstd 同样带 #[cfg]
        Identity {
            #[pin]
            inner: B,
        },
    }
}

    fn size_hint(&self) -> http_body::SizeHint {
        if let BodyInner::Identity { inner } = &self.inner {
            inner.size_hint()
        } else {
            http_body::SizeHint::new()
        }
    }

    fn is_end_stream(&self) -> bool {
        if let BodyInner::Identity { inner } = &self.inner {
            inner.is_end_stream()
        } else {
            false
        }
    }

tower-http = { version = "=0.7.1", features = ["compression-full"] }
tower = { version = "=0.5.3", features = ["util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt"] }
http = "1"
http-body = "1"
http-body-util = "0.1"
bytes = "1"

use bytes::Bytes;
use http::{Request, Response, StatusCode};
use http_body::Body as _;
use http_body_util::{BodyExt, Full};
use std::convert::Infallible;
use tower::{service_fn, Layer, ServiceExt};
use tower_http::compression::{
  predicate::{DefaultPredicate, Predicate, SizeAbove},
  CompressionLayer, CompressionLevel,
};

fn text() -> String {
  (0..2000).map(|i| format!("line {i}: the quick brown fox jumps over the lazy dog\n")).collect()
}

async fn handler(req: Request<Full<Bytes>>) -> Result<Response<Full<Bytes>>, Infallible> {
  let body = match req.uri().path() {
    "/small" => "0123456789".to_owned(),
    "/404" => return Ok(Response::builder().status(StatusCode::NOT_FOUND).body(Full::from(text())).unwrap()),
    _ => text(),
  };
  Ok(Response::new(Full::from(body)))
}

fn get(path: &str, enc: &str) -> Request<Full<Bytes>> {
  Request::get(path).header("accept-encoding", enc).body(Full::default()).unwrap()
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  println!("input {} bytes", text().len());
  for enc in ["gzip", "deflate", "br", "zstd"] {
    let mut line = format!("{enc:<8}");
    for (name, level) in [("Fastest", CompressionLevel::Fastest), ("Default", CompressionLevel::Default), ("Best", CompressionLevel::Best)] {
      let svc = CompressionLayer::new().quality(level).layer(service_fn(handler));
      let res = svc.oneshot(get("/", enc)).await.unwrap();
      let n = res.into_body().collect().await.unwrap().to_bytes().len();
      line += &format!("  {name}={n}");
    }
    println!("{line}");
  }

  // size_hint 与 is_end_stream：没压的转发，压了的未知
  let svc = CompressionLayer::new().layer(service_fn(handler));
  for path in ["/small", "/"] {
    let res = svc.clone().oneshot(get(path, "gzip")).await.unwrap();
    let ce = res.headers().get("content-encoding").cloned();
    let b = res.body();
    println!("{path:<6} content-encoding={ce:?} size_hint.exact={:?} is_end_stream={}", b.size_hint().exact(), b.is_end_stream());
  }

  // 自定义谓词：只压 2xx，且大小超过阈值；200_000 超出了 u16 的范围
  let only_ok = |status: StatusCode, _: http::Version, _: &http::HeaderMap, _: &http::Extensions| status.is_success();
  let big = CompressionLayer::new().compress_when(DefaultPredicate::new().and(SizeAbove::new(200_000)).and(only_ok));
  let low = CompressionLayer::new().compress_when(DefaultPredicate::new().and(SizeAbove::new(1_000)).and(only_ok));
  for (name, layer) in [("min 200000", big), ("min 1000", low)] {
    for path in ["/", "/404"] {
      let res = layer.clone().layer(service_fn(handler)).oneshot(get(path, "gzip")).await.unwrap();
      println!("{name:<10} {path:<4} {} content-encoding={:?}", res.status(), res.headers().get("content-encoding"));
    }
  }
}

input 108890 bytes
gzip      Fastest=5580  Default=5147  Best=5149
deflate   Fastest=5568  Default=5135  Best=5137
br        Fastest=8949  Default=2154  Best=2359
zstd      Fastest=2090  Default=2225  Best=2066
/small content-encoding=None size_hint.exact=Some(10) is_end_stream=false
/      content-encoding=Some("gzip") size_hint.exact=None is_end_stream=false
min 200000 /    200 OK content-encoding=None
min 200000 /404 404 Not Found content-encoding=None
min 1000   /    200 OK content-encoding=Some("gzip")
min 1000   /404 404 Not Found content-encoding=None