Hey there! Let's break down your problem and walk through feasible solutions—your core proxy-based idea is totally solid, we just need to swap out the incompatible server framework to support older Android versions.

First: Is Your Original Proxy Approach Feasible? #

Absolutely! The logic of running a local proxy to intercept requests, tweak headers, forward to the real server, and return responses is perfectly valid for your use case. The only roadblock was SparkJava's underlying Jetty dependency relying on ThreadLocal.withInitial() (introduced in API 26), which locked you out of pre-Android 8 devices. Swap SparkJava for a more compatible HTTP server framework, and this approach will work seamlessly on older API levels.

Recommended Compatible HTTP Server Frameworks #

Here are two lightweight, Android-friendly options that play nice with older API versions:

1. NanoHTTPD #

A tiny, dependency-free HTTP server written in pure Java. It’s super lightweight, easy to customize, and supports Android 4.0 (API 14) and above—ideal for a simple local proxy. You can implement your proxy logic directly in its request handler without dealing with complex dependencies.

2. Apache HttpComponents HttpServer #

While a bit heavier than NanoHTTPD, it’s a robust, fully-featured HTTP server with excellent backward compatibility. It’s a good pick if you need more advanced proxy capabilities (like handling HTTPS with custom certificates, though you mentioned security isn’t a concern here).

Example: Basic Proxy with NanoHTTPD #

Here’s a quick snippet to get you started—this sets up a local proxy that modifies a request header before forwarding to the real server using OkHttpClient:

public class LocalProxyServer extends NanoHTTPD {
    private final OkHttpClient okHttpClient = new OkHttpClient();
    private final String realApiBaseUrl;

    public LocalProxyServer(int port, String realApiBaseUrl) {
        super(port);
        this.realApiBaseUrl = realApiBaseUrl;
    }

    @Override
    public Response serve(IHTTPSession session) {
        try {
            // 1. Map proxy request URL to the real API URL
            String proxyRequestPath = session.getUri();
            String realRequestUrl = realApiBaseUrl + proxyRequestPath;

            // 2. Modify request headers as needed
            Request.Builder requestBuilder = new Request.Builder().url(realRequestUrl);
            for (Map.Entry<String, String> header : session.getHeaders().entrySet()) {
                // Example: Override a specific header
                if ("X-Target-Header".equals(header.getKey())) {
                    requestBuilder.header(header.getKey(), "Modified-Value");
                } else {
                    requestBuilder.header(header.getKey(), header.getValue());
                }
            }

            // 3. Forward request to the real server
            Request request = requestBuilder.build();
            okhttp3.Response realResponse = okHttpClient.newCall(request).execute();

            // 4. Convert OkHttp response to NanoHTTPD-compatible response
            return newFixedLengthResponse(
                Response.Status.lookup(realResponse.code()),
                realResponse.header("Content-Type"),
                realResponse.body().byteStream(),
                realResponse.body().contentLength()
            );
        } catch (IOException e) {
            return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, MIME_PLAINTEXT, "Proxy error: " + e.getMessage());
        }
    }
}

To use this, start the server on a local port (like 8080), then set your app’s API base URL to http://localhost:8080. All requests will route through your proxy, where you can modify headers before sending them to the real API.

Alternative Approaches (Beyond Local Proxy) #

If you want to explore other options that don’t require running a full proxy server:

• OkHttp Interceptor (if hookable): Even if you can’t modify request creation, if the app uses OkHttp under the hood, you could replace the global OkHttpClient instance with one that includes your header-modifying interceptor. This only works if you can access the client setup, though.
• DNS Hijacking: Modify DNS resolution for your original API base URL to point to your local proxy’s IP (127.0.0.1). This lets you avoid changing the app’s base URL entirely, but requires more system-level tweaks and may have edge cases on older Android versions.

Final Notes #

Your proxy-based approach is the most reliable given your constraints (can’t modify request creation, can adjust base URL). NanoHTTPD is the quickest path to get it working on older Android versions without heavy dependencies.

内容的提问来源于stack exchange，提问作者Greg Rynkowski