java怎么调用http请求

Java调用HTTP请求的实现方式与详解

在Java开发中,调用HTTP请求是常见的操作，涵盖从简单REST API调用到复杂HTTP通信的场景，以下内容将详细介绍多种实现方式、代码示例及最佳实践，帮助开发者根据不同需求选择合适的方案。

Java HTTP请求的实现方式分类

主流实现方式详解与代码示例

使用 HttpURLConnection（Java原生）

特点：无需外部依赖，直接通过JDK API发起请求，但需手动处理连接细节。

示例代码（GET请求）：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class HttpURLConnectionExample {
    public static void main(String[] args) throws Exception {
        // 创建URL对象
        URL url = new URL("https://jsonplaceholder.typicode.com/posts/1");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        // 设置请求方法
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/json");
        // 处理响应
        int responseCode = connection.getResponseCode();
        if (responseCode == 200) { // HTTP 200 OK
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()))) {
                String line;
                StringBuilder response = new StringBuilder();
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                System.out.println("Response: " + response.toString());
            }
        } else {
            System.out.println("Error: " + responseCode);
        }
        connection.disconnect();
    }
}

关键点：

• 需手动管理连接关闭（disconnect()）。
• 异常处理需覆盖IOException和MalformedURLException。
• POST请求需额外设置doOutput=true并写入请求体。

使用 Apache HttpClient

特点：功能全面，支持连接池、异步请求、认证机制，适合复杂场景。

示例代码（POST请求）：

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
public class ApacheHttpClientExample {
    public static void main(String[] args) throws Exception {
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 创建POST请求
            HttpPost request = new HttpPost("https://jsonplaceholder.typicode.com/posts");
            request.setHeader("Content-Type", "application/json");
            String jsonBody = "{"title": "foo", "body": "bar", "userId": 1}";
            request.setEntity(new StringEntity(jsonBody));
            // 执行请求
            try (CloseableHttpResponse response = httpClient.execute(request)) {
                int statusCode = response.getStatusLine().getStatusCode();
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Code: " + statusCode);
                System.out.println("Response Body: " + responseBody);
            }
        }
    }
}

关键点：

• 自动管理连接生命周期（try-with-resources）。
• 支持异步请求（FutureRequestExecutionService）。
• 可配置超时、代理、SSL上下文等。

使用 OkHttp

特点：轻量级、高性能，支持缓存和异步调用，广泛用于移动端（Android）。

示例代码（异步GET请求）：

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        // 构建请求
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        // 异步执行
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                System.err.println("Request Failed: " + e.getMessage());
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    String body = response.body().string();
                    System.out.println("Response: " + body);
                } else {
                    System.err.println("Error: " + response.code());
                }
            }
        });
    }
}

关键点：

• 默认支持HTTP/2（需服务器支持）。
• 支持拦截器（Interceptor）扩展功能（如日志、重试）。
• 同步调用可通过client.newCall(request).execute()实现。

使用 Spring RestTemplate

特点：与Spring生态深度集成，支持负载均衡、统一异常处理。

示例代码（交换JSON数据）：

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.web.client.RestTemplate;
public class RestTemplateExample {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        // 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.set("Accept", "application/json");
        headers.set("Content-Type", "application/json");
        // 构建请求实体
        String jsonBody = "{"title": "spring", "body": "resttemplate", "userId": 1}";
        HttpEntity<String> entity = new HttpEntity<>(jsonBody, headers);
        // 发送POST请求
        String url = "https://jsonplaceholder.typicode.com/posts";
        String response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class).getBody();
        System.out.println("Response: " + response);
    }
}

关键点：

• 依赖Spring Web模块（spring-web）。
• 支持对象与JSON的自动转换（需配合Jackson或Gson）。
• 可结合@LoadBalanced实现Ribbon负载均衡。

使用 Java 11+ HttpClient

特点：JDK内置，支持异步、流式处理和WebSocket，替代HttpURLConnection。

示例代码（同步GET请求）：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class HttpClientExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts/1"))
                .header("Accept", "application/json")
                .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response Code: " + response.statusCode());
        System.out.println("Response Body: " + response.body());
    }
}

关键点：

• 支持异步调用（sendAsync返回CompletableFuture）。
• 可配置HttpClient（如超时、代理、SSL上下文）。
• 流式处理支持（BodyHandlers.ofLines()或ofString()）。

不同实现方式对比

最佳实践与选型建议

1. 优先选择成熟库：避免直接使用HttpURLConnection，除非项目限制严格。
2. 移动端推荐OkHttp：轻量且支持缓存，适合Android应用。
3. 企业级项目选Apache HttpClient：功能全面，稳定性强。
4. Spring项目用RestTemplate或WebClient：后者支持响应式编程。
5. JDK 11+项目尝试HttpClient：减少外部依赖，语法现代。

常见问题与解决方案（FAQs）

Q1：如何处理HTTPS自签名证书或未知CA？

• 解决方案：
  • Apache HttpClient：自定义SSLContext并信任所有证书（非生产推荐）。

    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(null, new TrustManager[]{new X509TrustManager(){
        public void checkClientTrusted(X509Certificate[] chain, String authType) {}
        public void checkServerTrusted(X509Certificate[] chain, String authType) {}
        public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; }
    }}, new SecureRandom());
    CloseableHttpClient httpClient = HttpClients.custom()
        .setSSLContext(sslContext).build();

  • OkHttp：添加.hostnameVerifier((hostname, session) -> true)绕过验证。
  • 生产环境：应使用可信CA签发的证书，避免安全风险。

Q2：如何实现HTTP请求的重试机制？

• 解决方案：
  • Apache HttpClient：使用RetryHandler或HttpRequestRetryHandler。
  • OkHttp：通过Interceptor实现重试逻辑。
  • Spring RestTemplate：配合SimpleMappingExceptionResolver或自定义ClientHttpRequestInterceptor。

通过以上分析,开发者可根据项目需求、技术栈和性能要求选择最合适的HTTP请求