Java中是否存在curl -L的等价实现以处理URL重定向？

Great question! I totally get why you'd want something as seamless as curl -L in Java—manual checking of the Location header and looping through redirects isn't just tedious, it's also easy to mess up with edge cases like infinite redirect loops or protocol switches.

Luckily, Java has several built-in and widely-used library options that handle redirects automatically, no manual code required. Here are the top ones I've used in real projects:

1. 使用Java原生的HttpURLConnection #

This is the simplest option if you don't want to add external dependencies. By default, HttpURLConnection automatically follows redirects for GET and HEAD requests. You can also configure it explicitly for more control:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class RedirectExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://example.com/your-redirecting-url");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            
            // 显式开启自动重定向（默认已经是true）
            conn.setInstanceFollowRedirects(true);
            // 设置超时时间，避免卡在无响应的重定向链中
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(5000);

            try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
                String line;
                StringBuilder content = new StringBuilder();
                while ((line = in.readLine()) != null) {
                    content.append(line);
                }
                System.out.println("Final content: " + content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. Java 11+ 现代HttpClient #

If you're on Java 11 or later, the new java.net.http.HttpClient is the way to go. It's designed to be flexible, supports both synchronous and asynchronous requests, and has clear, granular redirect configuration:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class ModernHttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
                // 设置重定向策略：NORMAL跟随大多数重定向，默认排除HTTPS→HTTP的降级
                // 可选还有ALWAYS（允许所有重定向）或NEVER（完全禁用）
                .followRedirects(HttpClient.Redirect.NORMAL)
                .connectTimeout(Duration.ofSeconds(5))
                .build();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://example.com/your-redirecting-url"))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println("Final content: " + response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. Apache HttpClient（旧版Java或复杂场景首选） #

For projects relying on Apache libraries, Apache HttpClient offers robust, configurable redirect handling—great if you need to support edge cases like POST-to-GET redirects:

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.LaxRedirectStrategy;
import org.apache.http.util.EntityUtils;

public class ApacheHttpClientExample {
    public static void main(String[] args) {
        // LaxRedirectStrategy支持更多重定向场景，比如POST请求后的302重定向
        try (CloseableHttpClient client = HttpClientBuilder.create()
                .setRedirectStrategy(new LaxRedirectStrategy())
                .build()) {

            HttpGet request = new HttpGet("https://example.com/your-redirecting-url");
            try (CloseableHttpResponse response = client.execute(request)) {
                String content = EntityUtils.toString(response.getEntity());
                System.out.println("Final content: " + content);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

为什么这些方案比手动处理更优？ #

• Edge case handling: All these libraries automatically handle infinite redirect loops, protocol restrictions (like blocking HTTPS→HTTP downgrades by default), and all standard redirect status codes (301, 302, 303, 307, 308).
• Maintainability: You don't have to write and debug custom logic for parsing Location headers, resolving relative URLs, or tracking redirect counts.
• Flexibility: You can easily tweak behavior (e.g., disable redirects for specific requests, allow protocol switches) without rewriting core code.

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