同样是跳转，为什么 POST 到下一站变成了 GET？

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.ProxySelector;
import java.net.SocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/** JDK 17. Local HTTP only; two status codes, fixed small body, no business writes. */
public class RedirectMethodDemo {
    static final String BODY = "message=demo";
    record Seen(String path, String method, String body) {}
    static final List<Seen> seen = new CopyOnWriteArrayList<>();
    static final AtomicReference<Throwable> handlerFailure = new AtomicReference<>();

    static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
    }

    static void handle(HttpExchange exchange) throws IOException {
        try {
            String path = exchange.getRequestURI().getPath();
            byte[] bytes = exchange.getRequestBody().readNBytes(513);
            if (bytes.length > 512) {
                exchange.sendResponseHeaders(413, -1);
                return;
            }
            String body = new String(bytes, StandardCharsets.UTF_8);
            seen.add(new Seen(path, exchange.getRequestMethod(), body));
            String[] parts = path.split("/");
            if (parts.length == 4 && parts[1].equals("redirect")
                    && (parts[2].equals("303") || parts[2].equals("307"))) {
                exchange.getResponseHeaders().set("Location", "/sink/" + parts[3]);
                exchange.sendResponseHeaders(Integer.parseInt(parts[2]), -1);
            } else if (parts.length == 3 && parts[1].equals("sink")) {
                byte[] reply = "observed".getBytes(StandardCharsets.UTF_8);
                exchange.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8");
                exchange.sendResponseHeaders(200, reply.length);
                exchange.getResponseBody().write(reply);
            } else {
                exchange.sendResponseHeaders(404, -1);
            }
        } catch (IOException | RuntimeException failure) {
            handlerFailure.compareAndSet(null, failure);
            throw failure;
        } finally {
            exchange.close();
        }
    }

    static HttpClient client(HttpClient.Redirect policy, ExecutorService workers) {
        return HttpClient.newBuilder().followRedirects(policy).executor(workers)
                .connectTimeout(Duration.ofSeconds(3))
                .version(HttpClient.Version.HTTP_1_1)
                .proxy(new ProxySelector() {
                    public List<Proxy> select(URI uri) { return List.of(Proxy.NO_PROXY); }
                    public void connectFailed(URI uri, SocketAddress address, IOException failure) { }
                }).build();
    }

    static void observe(HttpClient client, String base, int status, boolean follow) throws Exception {
        seen.clear();
        String trial = (follow ? "follow-" : "never-") + status;
        String initialPath = "/redirect/" + status + "/" + trial;
        String finalPath = "/sink/" + trial;
        HttpRequest request = HttpRequest.newBuilder(URI.create(base + initialPath))
                .timeout(Duration.ofSeconds(5)).header("Content-Type", "text/plain; charset=utf-8")
                .POST(HttpRequest.BodyPublishers.ofString(BODY, StandardCharsets.UTF_8)).build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        check(handlerFailure.get() == null, "server handler failed: " + handlerFailure.get());
        List<Seen> expected = new ArrayList<>();
        expected.add(new Seen(initialPath, "POST", BODY));
        if (follow) expected.add(new Seen(finalPath, status == 303 ? "GET" : "POST", status == 303 ? "" : BODY));
        check(List.copyOf(seen).equals(expected), "unexpected requests: " + seen);
        check(response.statusCode() == (follow ? 200 : status), "unexpected final status");
        check(response.uri().getPath().equals(follow ? finalPath : initialPath), "wrong final URI");
        check(response.request().method().equals(follow && status == 303 ? "GET" : "POST"), "wrong final method");
        check(response.previousResponse().isPresent() == follow, "wrong response history");
        if (follow) {
            HttpResponse<String> previous = response.previousResponse().orElseThrow();
            check(previous.statusCode() == status && previous.previousResponse().isEmpty(), "wrong redirect chain");
            check(response.body().equals("observed"), "final body mismatch");
        }
        List<String> chain = new ArrayList<>();
        for (HttpResponse<String> current = response; current != null;
                current = current.previousResponse().orElse(null)) {
            chain.add(0, current.request().method() + " " + current.uri().getPath() + " -> " + current.statusCode());
        }
        System.out.println(trial + " response chain: " + chain);
        for (Seen event : seen) {
            System.out.println("  server saw " + event.method() + " " + event.path()
                    + " body=[" + event.body() + "]");
        }
    }

    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        ExecutorService serverWorkers = Executors.newSingleThreadExecutor();
        ExecutorService clientWorkers = Executors.newFixedThreadPool(2);
        try {
            server.setExecutor(serverWorkers);
            server.createContext("/", RedirectMethodDemo::handle);
            server.start();
            String base = "http://127.0.0.1:" + server.getAddress().getPort();
            HttpClient never = client(HttpClient.Redirect.NEVER, clientWorkers);
            HttpClient normal = client(HttpClient.Redirect.NORMAL, clientWorkers);
            observe(never, base, 303, false);
            observe(never, base, 307, false);
            observe(normal, base, 303, true);
            observe(normal, base, 307, true);
        } finally {
            server.stop(0);
            serverWorkers.shutdownNow();
            clientWorkers.shutdownNow();
            check(serverWorkers.awaitTermination(5, TimeUnit.SECONDS), "server executor did not terminate");
            check(clientWorkers.awaitTermination(5, TimeUnit.SECONDS), "client executor did not terminate");
        }
        System.out.println("PASS: four cases; response history matches server methods and bodies; server stopped");
        System.out.println("Scope: JDK 17 local HTTP/1.1; no browser, proxy, credentials, external URL or business mutation.");
    }
}