Java 调用 HTTP 和 HTTPS 的方式详解

1. HTTP 和 HTTPS 基础知识

1.1 什么是 HTTP/HTTPS？

HTTP（HyperText Transfer Protocol，超文本传输协议）是一种用于分布式、协作式和超媒体信息系统的应用层协议。它是 Web 的基础，用于在 Web 浏览器和服务器之间传输数据，如HTML文件、图像、查询结果等。

HTTPS（HTTP Secure，安全超文本传输协议）是 HTTP 的安全版本，通过 SSL/TLS 协议进行加密通信，提供了三个关键安全功能：

• 加密：防止数据在传输过程中被第三方窃听
• 数据完整性：防止数据被篡改
• 认证：确保用户正在与预期的网站通信

1.2 HTTP 请求与响应结构

HTTP 请求由以下部分组成：

• 请求行：包含HTTP方法（GET、POST等）、URL和HTTP版本
• 请求头：包含有关请求的附加信息（如Content-Type、User-Agent等）
• 空行：分隔请求头和请求体
• 请求体：包含发送到服务器的数据（如POST请求中的表单数据）

HTTP 响应由以下部分组成：

• 状态行：包含HTTP版本、状态码和状态消息
• 响应头：包含有关响应的附加信息
• 空行：分隔响应头和响应体
• 响应体：包含服务器返回的数据

1.3 常见的 HTTP 方法

• GET：请求指定的资源，应该只被用于获取数据
• POST：向指定资源提交数据，可能导致新资源的创建或已有资源的修改
• PUT：使用请求中的数据替换指定资源的内容
• DELETE：删除指定的资源
• PATCH：对资源应用部分修改
• HEAD：与GET相同，但只返回响应头，不返回响应体
• OPTIONS：获取目标资源支持的通信选项

1.4 常见的 HTTP 状态码

• 1xx（信息性）：请求已接收，继续处理
• 2xx（成功）：请求已成功接收、理解、接受
  • 200 OK：请求成功
  • 201 Created：请求已完成，并创建了新资源
  • 204 No Content：服务器成功处理了请求，但没有返回任何内容
• 3xx（重定向）：需要进一步操作才能完成请求
  • 301 Moved Permanently：资源已永久移动到新位置
  • 302 Found：资源临时位于不同的URL
  • 304 Not Modified：资源未被修改
• 4xx（客户端错误）：请求包含错误语法或无法完成
  • 400 Bad Request：服务器无法理解请求
  • 401 Unauthorized：需要身份验证
  • 403 Forbidden：服务器拒绝请求
  • 404 Not Found：服务器找不到请求的资源
• 5xx（服务器错误）：服务器在处理请求时发生错误
  • 500 Internal Server Error：服务器遇到了意外情况
  • 502 Bad Gateway：服务器作为网关，从上游服务器收到无效响应
  • 503 Service Unavailable：服务器暂时不可用

2. Java 原生 HTTP 客户端

2.1 使用 URLConnection 和 HttpURLConnection

URLConnection 和 HttpURLConnection 是 Java 标准库提供的最基本的 HTTP 客户端 API，自 JDK 1.1 就存在。虽然功能相对简单，但不需要任何外部依赖。

2.1.1 基本 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) {
        try {
            // 创建URL对象
            URL url = new URL("https://api.example.com/data");
            
            // 打开连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 设置请求方法（默认为GET）
            connection.setRequestMethod("GET");
            
            // 设置连接和读取超时（毫秒）
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            
            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            // 读取响应内容
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            // 打印响应内容
            System.out.println("Response: " + response.toString());
            
            // 断开连接
            connection.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.1.2 基本 POST 请求

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class HttpURLConnectionPostExample {
    
    public static void main(String[] args) {
        try {
            // 创建URL对象
            URL url = new URL("https://api.example.com/submit");
            
            // 打开连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 设置请求方法
            connection.setRequestMethod("POST");
            
            // 启用输入/输出流
            connection.setDoOutput(true);
            connection.setDoInput(true);
            
            // 设置请求头
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("Accept", "application/json");
            
            // 构建请求体
            String jsonInputString = "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}";
            
            // 发送请求体
            try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
                byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
                outputStream.write(input, 0, input.length);
            }
            
            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            // 读取响应内容
            BufferedReader in;
            if (responseCode >= 200 && responseCode < 300) {
                in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            } else {
                in = new BufferedReader(new InputStreamReader(connection.getErrorStream()));
            }
            
            String inputLine;
            StringBuilder response = new StringBuilder();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            // 打印响应内容
            System.out.println("Response: " + response.toString());
            
            // 断开连接
            connection.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.1.3 处理 HTTPS 请求

处理 HTTPS 请求需要配置 HttpsURLConnection，特别是在需要自定义信任管理器或者客户端证书时：

import javax.net.ssl.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.cert.X509Certificate;

public class HttpsURLConnectionExample {
    
    public static void main(String[] args) {
        try {
            // 创建信任所有证书的信任管理器（仅用于测试/开发环境！）
            TrustManager[] trustAllCerts = new TrustManager[] {
                new X509TrustManager() {
                    public X509Certificate[] getAcceptedIssuers() { return null; }
                    public void checkClientTrusted(X509Certificate[] certs, String authType) { }
                    public void checkServerTrusted(X509Certificate[] certs, String authType) { }
                }
            };
            
            // 创建SSL上下文，并使用我们的信任管理器
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
            
            // 创建URL对象
            URL url = new URL("https://api.example.com/secure-data");
            
            // 打开连接
            HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
            
            // 设置SSL socket工厂
            connection.setSSLSocketFactory(sslContext.getSocketFactory());
            
            // 设置主机名验证器（跳过主机名验证，仅用于测试）
            connection.setHostnameVerifier((hostname, session) -> true);
            
            // 设置请求方法
            connection.setRequestMethod("GET");
            
            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            // 读取响应内容
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            // 打印响应内容
            System.out.println("Response: " + response.toString());
            
            // 断开连接
            connection.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：上述示例中使用了接受所有证书的信任管理器，这仅应在开发/测试环境中使用，生产环境应使用适当的证书验证。

2.1.4 设置代理

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

public class HttpURLConnectionProxyExample {
    
    public static void main(String[] args) {
        try {
            // 创建代理对象
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.com", 8080));
            
            // 创建URL对象
            URL url = new URL("https://api.example.com/data");
            
            // 使用代理打开连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
            
            // 设置请求方法
            connection.setRequestMethod("GET");
            
            // 如果代理需要身份验证
            String authString = "username:password";
            byte[] authEncBytes = java.util.Base64.getEncoder().encode(authString.getBytes());
            String authStringEnc = new String(authEncBytes);
            connection.setRequestProperty("Proxy-Authorization", "Basic " + authStringEnc);
            
            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            // 读取响应内容
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            // 打印响应内容
            System.out.println("Response: " + response.toString());
            
            // 断开连接
            connection.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.1.5 上传文件

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class HttpURLConnectionFileUploadExample {
    
    public static void main(String[] args) {
        try {
            // 创建URL对象
            URL url = new URL("https://api.example.com/upload");
            
            // 连接参数
            String boundary = "===" + System.currentTimeMillis() + "===";
            
            // 打开连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 设置请求方法
            connection.setRequestMethod("POST");
            
            // 启用输入/输出流
            connection.setDoOutput(true);
            connection.setDoInput(true);
            
            // 设置请求头
            connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
            
            // 创建请求体
            try (OutputStream outputStream = connection.getOutputStream();
                 PrintWriter writer = new PrintWriter(new OutputStreamWriter(outputStream, StandardCharsets.UTF_8), true)) {
                
                // 添加表单字段
                writer.append("--").append(boundary).append("\r\n");
                writer.append("Content-Disposition: form-data; name=\"description\"\r\n\r\n");
                writer.append("文件描述").append("\r\n");
                
                // 添加文件
                writer.append("--").append(boundary).append("\r\n");
                writer.append("Content-Disposition: form-data; name=\"file\"; filename=\"example.txt\"\r\n");
                writer.append("Content-Type: text/plain\r\n\r\n");
                writer.flush();
                
                // 从文件读取并写入请求
                try (FileInputStream fileInputStream = new FileInputStream("example.txt")) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                        outputStream.write(buffer, 0, bytesRead);
                    }
                    outputStream.flush();
                }
                
                writer.append("\r\n");
                
                // 结束请求
                writer.append("--").append(boundary).append("--").append("\r\n");
            }
            
            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            // 读取响应内容
            BufferedReader in = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();
            
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();
            
            // 打印响应内容
            System.out.println("Response: " + response.toString());
            
            // 断开连接
            connection.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2 使用 Java 11+ HttpClient

从 Java 11 开始，Java 标准库引入了现代化的 HttpClient API，提供了比 HttpURLConnection 更丰富的功能，包括异步请求、WebSocket 支持等。

2.2.1 基本 GET 请求

import java.io.IOException;
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 Java11HttpClientExample {
    
    public static void main(String[] args) {
        try {
            // 创建 HttpClient
            HttpClient client = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)  // 设置HTTP协议版本
                    .connectTimeout(Duration.ofSeconds(5))  // 设置连接超时
                    .build();
            
            // 创建 HttpRequest
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.example.com/data"))
                    .timeout(Duration.ofSeconds(5))  // 设置请求超时
                    .header("Content-Type", "application/json")
                    .GET()  // 设置请求方法为GET
                    .build();
            
            // 发送请求并获取响应
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            
            // 获取响应状态码
            int statusCode = response.statusCode();
            System.out.println("Status Code: " + statusCode);
            
            // 获取响应头
            response.headers().map().forEach((key, values) -> {
                System.out.println(key + ": " + values);
            });
            
            // 获取响应体
            String responseBody = response.body();
            System.out.println("Response Body: " + responseBody);
            
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.2.2 基本 POST 请求

import java.io.IOException;
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 Java11HttpClientPostExample {
    
    public static void main(String[] args) {
        try {
            // 创建 HttpClient
            HttpClient client = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .connectTimeout(Duration.ofSeconds(5))
                    .build();
            
            // 准备JSON请求体
            String jsonBody = "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}";
            
            // 创建 HttpRequest
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.example.com/submit"))
                    .timeout(Duration.ofSeconds(5))
                    .header("Content-Type", "application/json")
                    .POST(HttpRequest.BodyPublishers.ofString(jsonBody))  // 设置请求方法为POST并提供请求体
                    .build();
            
            // 发送请求并获取响应
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            
            // 获取响应状态码
            int statusCode = response.statusCode();
            System.out.println("Status Code: " + statusCode);
            
            // 获取响应体
            String responseBody = response.body();
            System.out.println("Response Body: " + responseBody);
            
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.2.3 异步请求

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

public class Java11HttpClientAsyncExample {
    
    public static void main(String[] args) {
        // 创建 HttpClient
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .connectTimeout(Duration.ofSeconds(5))
                .build();
        
        // 创建 HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .timeout(Duration.ofSeconds(5))
                .GET()
                .build();
        
        // 异步发送请求
        CompletableFuture<HttpResponse<String>> futureResponse = 
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        
        // 添加响应处理逻辑
        futureResponse
                .thenApply(response -> {
                    System.out.println("Status Code: " + response.statusCode());
                    return response;
                })
                .thenApply(HttpResponse::body)
                .thenAccept(responseBody -> System.out.println("Response Body: " + responseBody))
                .exceptionally(e -> {
                    System.err.println("Error: " + e.getMessage());
                    return null;
                });
        
        // 等待异步操作完成
        futureResponse.join();
        
        System.out.println("请求已完成");
    }
}

2.2.4 处理 HTTPS 和 SSL

import javax.net.ssl.*;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.security.KeyStore;
import java.security.cert.X509Certificate;
import java.time.Duration;

public class Java11HttpClientSslExample {
    
    public static void main(String[] args) {
        try {
            // 方法1：使用默认的SSL配置
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, null, null);
            
            HttpClient defaultClient = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .sslContext(sslContext)
                    .build();
            
            // 方法2：配置自定义SSL上下文（允许所有证书，仅用于测试）
            SSLContext sslContext2 = SSLContext.getInstance("TLS");
            sslContext2.init(null, null, null);
            
            HttpClient customSslClient = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .sslContext(sslContext2)
                    .build();
            
            // 方法3：使用客户端证书进行双向SSL认证
            KeyStore clientKeyStore = KeyStore.getInstance("PKCS12");
            clientKeyStore.load(
                    Java11HttpClientSslExample.class.getResourceAsStream("/client.p12"), 
                    "password".toCharArray());
            
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, "password".toCharArray());
            
            SSLContext clientAuthSslContext = SSLContext.getInstance("TLS");
            clientAuthSslContext.init(
                    keyManagerFactory.getKeyManagers(), 
                    null,  // 使用默认的信任管理器
                    null); // 使用默认的随机数生成器
            
            HttpClient clientAuthClient = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .sslContext(clientAuthSslContext)
                    .build();
            
            // 创建请求
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.example.com/secure-data"))
                    .timeout(Duration.ofSeconds(5))
                    .GET()
                    .build();
            
            // 使用适当的客户端发送请求
            HttpResponse<String> response = customSslClient.send(request, HttpResponse.BodyHandlers.ofString());
            
            System.out.println("Status Code: " + response.statusCode());
            System.out.println("Response Body: " + response.body());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2.5 上传文件

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;

public class Java11HttpClientFileUploadExample {
    
    public static void main(String[] args) {
        try {
            // 创建 HttpClient
            HttpClient client = HttpClient.newBuilder()
                    .version(HttpClient.Version.HTTP_2)
                    .connectTimeout(Duration.ofSeconds(30))  // 上传文件可能需要更长的超时时间
                    .build();
            
            // 创建多部分请求
            var multipartData = MultipartBodyPublisher.newBuilder()
                    .addPart("description", "文件描述")
                    .addFilePart("file", Path.of("example.txt"))
                    .build();
            
            // 创建 HttpRequest
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.example.com/upload"))
                    .timeout(Duration.ofSeconds(60))
                    .header("Content-Type", "multipart/form-data; boundary=" + multipartData.getBoundary())
                    .POST(multipartData)
                    .build();
            
            // 发送请求并获取响应
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            
            // 获取响应状态码
            int statusCode = response.statusCode();
            System.out.println("Status Code: " + statusCode);
            
            // 获取响应体
            String responseBody = response.body();
            System.out.println("Response Body: " + responseBody);
            
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    // 自定义多部分请求体发布器
    static class MultipartBodyPublisher {
        private final String boundary;
        private final HttpRequest.BodyPublisher bodyPublisher;
        
        private MultipartBodyPublisher(String boundary, HttpRequest.BodyPublisher bodyPublisher) {
            this.boundary = boundary;
            this.bodyPublisher = bodyPublisher;
        }
        
        public String getBoundary() {
            return boundary;
        }
        
        public HttpRequest.BodyPublisher bodyPublisher() {
            return bodyPublisher;
        }
        
        public static Builder newBuilder() {
            return new Builder();
        }
        
        static class Builder {
            private final String boundary = "===" + System.currentTimeMillis() + "===";
            private final StringBuilder content = new StringBuilder();
            
            public Builder addPart(String name, String value) {
                content.append("--").append(boundary).append("\r\n");
                content.append("Content-Disposition: form-data; name=\"").append(name).append("\"\r\n\r\n");
                content.append(value).append("\r\n");
                return this;
            }
            
            public Builder addFilePart(String name, Path filePath) throws IOException {
                content.append("--").append(boundary).append("\r\n");
                content.append("Content-Disposition: form-data; name=\"").append(name)
                       .append("\"; filename=\"").append(filePath.getFileName()).append("\"\r\n");
                content.append("Content-Type: application/octet-stream\r\n\r\n");
                
                // 为简化示例，这里将文件内容也作为字符串处理
                // 实际应用中应使用byte数组或流处理二进制内容
                content.append(java.nio.file.Files.readString(filePath)).append("\r\n");
                
                return this;
            }
            
            public HttpRequest.BodyPublisher build() {
                content.append("--").append(boundary).append("--\r\n");
                return HttpRequest.BodyPublishers.ofString(content.toString());
            }
        }
    } 

3. Apache HttpClient

Apache HttpClient 是 Apache HttpComponents 项目的一部分，提供了功能丰富、标准兼容的 HTTP 客户端库。它支持 HTTP/1.1 和 HTTP/2，并具有许多高级功能，如连接池、认证支持、重试机制等。

3.1 添加依赖

Maven:

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.2.1</version>
</dependency>

Gradle:

implementation 'org.apache.httpcomponents.client5:httpclient5:5.2.1'

3.2 基本 GET 请求

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.io.IOException;

public class ApacheHttpClientGetExample {
    
    public static void main(String[] args) {
        // 创建 HttpClient 实例
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 创建 HttpGet 请求
            HttpGet httpGet = new HttpGet("https://api.example.com/data");
            
            // 设置请求头
            httpGet.setHeader("User-Agent", "Mozilla/5.0");
            httpGet.setHeader("Accept", "application/json");
            
            // 发送 GET 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3 基本 POST 请求

import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.io.entity.StringEntity;

import java.io.IOException;

public class ApacheHttpClientPostExample {
    
    public static void main(String[] args) {
        // 创建 HttpClient 实例
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 创建 HttpPost 请求
            HttpPost httpPost = new HttpPost("https://api.example.com/submit");
            
            // 设置请求头
            httpPost.setHeader("User-Agent", "Mozilla/5.0");
            httpPost.setHeader("Accept", "application/json");
            
            // 设置请求体
            String jsonBody = "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}";
            StringEntity entity = new StringEntity(jsonBody, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            
            // 发送 POST 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4 配置连接池

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.util.Timeout;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class ApacheHttpClientConnectionPoolExample {
    
    public static void main(String[] args) {
        // 创建连接管理器
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        // 设置最大连接数
        connectionManager.setMaxTotal(100);
        // 设置每个路由的最大连接数
        connectionManager.setDefaultMaxPerRoute(20);
        
        // 配置请求参数
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(Timeout.of(5, TimeUnit.SECONDS))
                .setResponseTimeout(Timeout.of(5, TimeUnit.SECONDS))
                .setConnectionRequestTimeout(Timeout.of(5, TimeUnit.SECONDS))
                .build();
        
        // 创建 HttpClient 实例
        try (CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(connectionManager)
                .setDefaultRequestConfig(requestConfig)
                .build()) {
            
            // 创建 HttpGet 请求
            HttpGet httpGet = new HttpGet("https://api.example.com/data");
            
            // 发送 GET 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.5 处理 Cookie

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.cookie.BasicCookieStore;
import org.apache.hc.client5.http.cookie.Cookie;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.cookie.BasicClientCookie;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.io.IOException;
import java.util.Date;
import java.util.List;

public class ApacheHttpClientCookieExample {
    
    public static void main(String[] args) {
        // 创建 Cookie 存储
        BasicCookieStore cookieStore = new BasicCookieStore();
        
        // 添加自定义 Cookie
        BasicClientCookie cookie = new BasicClientCookie("sessionId", "abc123");
        cookie.setDomain("example.com");
        cookie.setPath("/");
        // 设置过期时间（1小时后）
        cookie.setExpiryDate(new Date(System.currentTimeMillis() + 3600 * 1000));
        cookieStore.addCookie(cookie);
        
        // 创建 HttpClient 实例，使用 Cookie 存储
        try (CloseableHttpClient httpClient = HttpClients.custom()
                .setDefaultCookieStore(cookieStore)
                .build()) {
            
            // 创建 HttpGet 请求
            HttpGet httpGet = new HttpGet("https://api.example.com/data");
            
            // 发送 GET 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
                
                // 获取响应中的 Cookie
                List<Cookie> cookies = cookieStore.getCookies();
                for (Cookie c : cookies) {
                    System.out.println("Cookie: " + c.getName() + " = " + c.getValue());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.6 表单提交

import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.BasicNameValuePair;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ApacheHttpClientFormPostExample {
    
    public static void main(String[] args) {
        // 创建 HttpClient 实例
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 创建 HttpPost 请求
            HttpPost httpPost = new HttpPost("https://api.example.com/submit-form");
            
            // 创建表单参数列表
            List<NameValuePair> params = new ArrayList<>();
            params.add(new BasicNameValuePair("username", "john_doe"));
            params.add(new BasicNameValuePair("password", "secret123"));
            params.add(new BasicNameValuePair("remember", "true"));
            
            // 设置表单实体
            httpPost.setEntity(new UrlEncodedFormEntity(params));
            
            // 发送 POST 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.7 文件上传

import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.io.File;
import java.io.IOException;

public class ApacheHttpClientFileUploadExample {
    
    public static void main(String[] args) {
        // 需要额外添加依赖：httpmime
        // <dependency>
        //   <groupId>org.apache.httpcomponents.client5</groupId>
        //   <artifactId>httpclient5-fluent</artifactId>
        //   <version>5.2.1</version>
        // </dependency>
        
        // 创建 HttpClient 实例
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 创建 HttpPost 请求
            HttpPost httpPost = new HttpPost("https://api.example.com/upload");
            
            // 创建 MultipartEntityBuilder
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            
            // 添加文本字段
            builder.addTextBody("description", "文件描述", ContentType.TEXT_PLAIN);
            
            // 添加文件
            File file = new File("example.txt");
            builder.addBinaryBody(
                    "file",
                    file,
                    ContentType.APPLICATION_OCTET_STREAM,
                    file.getName()
            );
            
            // 设置请求实体
            httpPost.setEntity(builder.build());
            
            // 发送 POST 请求并获取响应
            try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
                // 获取响应状态码
                int statusCode = response.getCode();
                System.out.println("Status Code: " + statusCode);
                
                // 获取响应实体
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("Response Body: " + responseBody);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.8 配置 HTTPS 和 SSL

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.socket.ConnectionSocketFactory;
import org.apache.hc.client5.http.socket.PlainConnectionSocketFactory;
import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
import org.apache.hc.core5.http.config.Registry;
import org.apache.hc.core5.http.config.RegistryBuilder;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.ssl.SSLContextBuilder;
import org.apache.hc.core5.ssl.TrustStrategy;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class ApacheHttpClientSslExample {
    
    public static void main(String[] args) {
        try {
            // 方法1：信任所有证书（仅用于测试/开发环境！）
            SSLContext sslContext = new SSLContextBuilder()
                    .loadTrustMaterial(null, new TrustStrategy() {
                        @Override
                        public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                            return true;
                        }
                    })
                    .build();
            
            SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(
                    sslContext,
                    NoopHostnameVerifier.INSTANCE);
            
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslSocketFactory)
                    .build();
            
            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            
            // 创建 HttpClient 实例
            try (CloseableHttpClient httpClient = HttpClients.custom()
                    .setConnectionManager(connectionManager)
                    .build()) {
                
                // 创建 HttpGet 请求
                HttpGet httpGet = new HttpGet("https://api.example.com/secure-data");
                
                // 发送 GET 请求并获取响应
                try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                    // 获取响应状态码
                    int statusCode = response.getCode();
                    System.out.println("Status Code: " + statusCode);
                    
                    // 获取响应实体
                    String responseBody = EntityUtils.toString(response.getEntity());
                    System.out.println("Response Body: " + responseBody);
                }
            }
            
            // 方法2：使用客户端证书进行双向SSL认证
            SSLContext clientAuthSslContext = new SSLContextBuilder()
                    .loadTrustMaterial(new File("truststore.jks"), "truststorePassword".toCharArray())
                    .loadKeyMaterial(new File("keystore.jks"), "keystorePassword".toCharArray(), "keyPassword".toCharArray())
                    .build();
            
            SSLConnectionSocketFactory clientAuthSslSocketFactory = new SSLConnectionSocketFactory(clientAuthSslContext);
            
            try (CloseableHttpClient clientAuthHttpClient = HttpClients.custom()
                    .setSSLSocketFactory(clientAuthSslSocketFactory)
                    .build()) {
                
                // 使用双向SSL认证的HttpClient发送请求
                // ...
            }
            
        } catch (IOException | NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
            e.printStackTrace();
        }
    }
}

4. OkHttp

OkHttp 是一个由 Square 开发的高效 HTTP 客户端，专为 Android 和 Java 应用程序设计。它支持 HTTP/2 和 SPDY，可以共享同一地址的 socket 连接，使用连接池减少请求延迟，并提供透明的 GZIP 压缩和响应缓存。

4.1 添加依赖

Maven:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.10.0</version>
</dependency>

Gradle:

implementation 'com.squareup.okhttp3:okhttp:4.10.0'

4.2 基本 GET 请求

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.io.IOException;

public class OkHttpGetExample {
    
    // OkHttpClient 实例应该是单例的，在应用程序生命周期内重用
    private final OkHttpClient client = new OkHttpClient();
    
    public static void main(String[] args) {
        OkHttpGetExample example = new OkHttpGetExample();
        try {
            String response = example.run("https://api.example.com/data");
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private String run(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .header("User-Agent", "OkHttp Example")
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response code: " + response);
            }
            
            return response.body().string();
        }
    }
}

4.3 基本 POST 请求

import okhttp3.*;

import java.io.IOException;

public class OkHttpPostExample {
    
    private final OkHttpClient client = new OkHttpClient();
    
    public static void main(String[] args) {
        OkHttpPostExample example = new OkHttpPostExample();
        try {
            String response = example.post("https://api.example.com/submit");
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private String post(String url) throws IOException {
        // 设置请求体的媒体类型
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        String jsonBody = "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}";
        
        RequestBody body = RequestBody.create(jsonBody, JSON);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response code: " + response);
            }
            
            return response.body().string();
        }
    }
}

4.4 异步请求

import okhttp3.*;

import java.io.IOException;

public class OkHttpAsyncExample {
    
    private final OkHttpClient client = new OkHttpClient();
    
    public static void main(String[] args) {
        OkHttpAsyncExample example = new OkHttpAsyncExample();
        example.run("https://api.example.com/data");
        
        // 等待异步请求完成
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    private void run(String url) {
        Request request = new Request.Builder()
                .url(url)
                .build();
        
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                try (ResponseBody responseBody = response.body()) {
                    if (!response.isSuccessful()) {
                        throw new IOException("Unexpected response code: " + response);
                    }
                    
                    System.out.println(responseBody.string());
                }
            }
        });
        
        System.out.println("请求已发送，等待响应...");
    }
}

4.5 表单提交

import okhttp3.*;

import java.io.IOException;

public class OkHttpFormPostExample {
    
    private final OkHttpClient client = new OkHttpClient();
    
    public static void main(String[] args) {
        OkHttpFormPostExample example = new OkHttpFormPostExample();
        try {
            String response = example.formPost("https://api.example.com/submit-form");
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private String formPost(String url) throws IOException {
        RequestBody formBody = new FormBody.Builder()
                .add("username", "john_doe")
                .add("password", "secret123")
                .add("remember", "true")
                .build();
        
        Request request = new Request.Builder()
                .url(url)
                .post(formBody)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response code: " + response);
            }
            
            return response.body().string();
        }
    }
}

4.6 文件上传

import okhttp3.*;

import java.io.File;
import java.io.IOException;

public class OkHttpFileUploadExample {
    
    private final OkHttpClient client = new OkHttpClient();
    
    public static void main(String[] args) {
        OkHttpFileUploadExample example = new OkHttpFileUploadExample();
        try {
            String response = example.uploadFile("https://api.example.com/upload");
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private String uploadFile(String url) throws IOException {
        File file = new File("example.txt");
        
        RequestBody requestBody = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("description", "文件描述")
                .addFormDataPart("file", file.getName(),
                        RequestBody.create(file, MediaType.parse("application/octet-stream")))
                .build();
        
        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected response code: " + response);
            }
            
            return response.body().string();
        }
    }
}

4.7 配置超时和重试

import okhttp3.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class OkHttpTimeoutRetryExample {
    
    public static void main(String[] args) {
        // 配置超时
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .build();
        
        // 创建请求
        Request request = new Request.Builder()
                .url("https://api.example.com/data")
                .build();
        
        // 使用重试拦截器
        OkHttpClient clientWithRetry = client.newBuilder()
                .addInterceptor(new RetryInterceptor(3))
                .build();
        
        try (Response response = clientWithRetry.newCall(request).execute()) {
            System.out.println("Response Code: " + response.code());
            System.out.println("Response Body: " + response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // 自定义重试拦截器
    static class RetryInterceptor implements Interceptor {
        private final int maxRetries;
        
        public RetryInterceptor(int maxRetries) {
            this.maxRetries = maxRetries;
        }
        
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            
            IOException exception = null;
            Response response = null;
            int retryCount = 0;
            
            while (retryCount < maxRetries && (response == null || !response.isSuccessful())) {
                if (retryCount > 0) {
                    System.out.println("重试请求: " + retryCount);
                    // 如果需要，可以在重试之间增加延迟
                    try {
                        Thread.sleep(1000 * retryCount);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new IOException("Retry interrupted", e);
                    }
                }
                
                if (exception != null) {
                    System.out.println("上次尝试失败: " + exception.getMessage());
                }
                
                try {
                    response = chain.proceed(request);
                } catch (IOException e) {
                    exception = e;
                    retryCount++;
                    
                    if (retryCount >= maxRetries) {
                        throw exception;
                    }
                    
                    continue;
                }
                
                if (!response.isSuccessful()) {
                    System.out.println("请求失败，状态码: " + response.code());
                    response.close();
                    retryCount++;
                    
                    if (retryCount >= maxRetries) {
                        break;
                    }
                }
            }
            
            return response;
        }
    }
}

4.8 配置 HTTPS 和 SSL

import okhttp3.*;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class OkHttpSslExample {
    
    public static void main(String[] args) throws Exception {
        // 方法1：信任所有证书（仅用于测试/开发环境！）
        TrustManager[] trustAllCerts = new TrustManager[]{
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType) {
                    }
                    
                    @Override
                    public void checkServerTrusted(X509Certificate[] chain, String authType) {
                    }
                    
                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        return new X509Certificate[0];
                    }
                }
        };
        
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, trustAllCerts, new SecureRandom());
        
        OkHttpClient unsafeClient = new OkHttpClient.Builder()
                .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustAllCerts[0])
                .hostnameVerifier((hostname, session) -> true)
                .build();
        
        // 方法2：使用自定义信任库和密钥库
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        try (InputStream trustStoreInputStream = OkHttpSslExample.class.getResourceAsStream("/truststore.jks")) {
            trustStore.load(trustStoreInputStream, "truststorePassword".toCharArray());
        }
        
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);
        
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (InputStream keyStoreInputStream = OkHttpSslExample.class.getResourceAsStream("/keystore.p12")) {
            keyStore.load(keyStoreInputStream, "keystorePassword".toCharArray());
        }
        
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, "keyPassword".toCharArray());
        
        SSLContext clientAuthSslContext = SSLContext.getInstance("TLS");
        clientAuthSslContext.init(
                keyManagerFactory.getKeyManagers(),
                trustManagerFactory.getTrustManagers(),
                null);
        
        OkHttpClient secureClient = new OkHttpClient.Builder()
                .sslSocketFactory(clientAuthSslContext.getSocketFactory(), (X509TrustManager) trustManagerFactory.getTrustManagers()[0])
                .build();
        
        // 创建请求
        Request request = new Request.Builder()
                .url("https://api.example.com/secure-data")
                .build();
        
        // 使用配置的客户端发送请求
        try (Response response = unsafeClient.newCall(request).execute()) {
            System.out.println("Response Code: " + response.code());
            System.out.println("Response Body: " + response.body().string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
} 

5. Spring RestTemplate

Spring RestTemplate 是 Spring 框架提供的同步 HTTP 客户端，支持 RESTful 风格的 HTTP 交互。它是 Spring 应用中进行 HTTP 请求的经典选择，提供了丰富的方法来简化 HTTP 客户端的开发。

注意：从 Spring 5 开始，RestTemplate 被标记为处于维护模式，建议新项目使用 WebClient（下一节介绍）。

5.1 添加依赖

Maven:

<!-- Spring Web -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.23</version>
</dependency>

Gradle:

implementation 'org.springframework:spring-web:5.3.23'

5.2 基本 GET 请求

import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class RestTemplateGetExample {
    
    public static void main(String[] args) {
        // 创建 RestTemplate 实例
        RestTemplate restTemplate = new RestTemplate();
        
        // 基本 GET 请求（返回字符串）
        String result = restTemplate.getForObject("https://api.example.com/data", String.class);
        System.out.println("Response Body: " + result);
        
        // 使用 ResponseEntity 获取更多响应细节
        ResponseEntity<String> response = restTemplate.getForEntity("https://api.example.com/data", String.class);
        
        System.out.println("Status Code: " + response.getStatusCode());
        System.out.println("Headers: " + response.getHeaders());
        System.out.println("Response Body: " + response.getBody());
    }
}

5.3 获取并映射到 Java 对象

import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class RestTemplateObjectMappingExample {
    
    // 响应数据的模型类
    static class User {
        private Long id;
        private String name;
        private String email;
        
        // Getters and Setters
        public Long getId() { return id; }
        public void setId(Long id) { this.id = id; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public String getEmail() { return email; }
        public void setEmail(String email) { this.email = email; }
        
        @Override
        public String toString() {
            return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
        }
    }
    
    public static void main(String[] args) {
        // 创建 RestTemplate 实例
        RestTemplate restTemplate = new RestTemplate();
        
        // 获取单个对象
        User user = restTemplate.getForObject("https://api.example.com/users/1", User.class);
        System.out.println("User: " + user);
        
        // 获取对象数组
        User[] users = restTemplate.getForObject("https://api.example.com/users", User[].class);
        System.out.println("Users count: " + users.length);
        for (User u : users) {
            System.out.println(u);
        }
        
        // 使用 ResponseEntity 获取更多响应细节
        ResponseEntity<User> response = restTemplate.getForEntity("https://api.example.com/users/1", User.class);
        System.out.println("Status Code: " + response.getStatusCode());
        System.out.println("User from response: " + response.getBody());
    }
}

5.4 基本 POST 请求

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;

public class RestTemplatePostExample {
    
    // 请求数据的模型类
    static class UserRequest {
        private String name;
        private String email;
        
        public UserRequest(String name, String email) {
            this.name = name;
            this.email = email;
        }
        
        // Getters
        public String getName() { return name; }
        public String getEmail() { return email; }
    }
    
    // 响应数据的模型类
    static class UserResponse {
        private Long id;
        private String name;
        private String email;
        private String createdAt;
        
        // Getters and Setters
        public Long getId() { return id; }
        public void setId(Long id) { this.id = id; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public String getEmail() { return email; }
        public void setEmail(String email) { this.email = email; }
        public String getCreatedAt() { return createdAt; }
        public void setCreatedAt(String createdAt) { this.createdAt = createdAt; }
        
        @Override
        public String toString() {
            return "UserResponse{id=" + id + ", name='" + name + "', email='" + email + "', createdAt='" + createdAt + "'}";
        }
    }
    
    public static void main(String[] args) {
        // 创建 RestTemplate 实例
        RestTemplate restTemplate = new RestTemplate();
        
        // 创建请求对象
        UserRequest requestUser = new UserRequest("John Doe", "john@example.com");
        
        // 方法 1: 简单的 POST 请求
        UserResponse createdUser = restTemplate.postForObject(
                "https://api.example.com/users", 
                requestUser, 
                UserResponse.class);
        
        System.out.println("Created User: " + createdUser);
        
        // 方法 2: 使用 ResponseEntity 获取更多响应细节
        ResponseEntity<UserResponse> response = restTemplate.postForEntity(
                "https://api.example.com/users", 
                requestUser, 
                UserResponse.class);
        
        System.out.println("Status Code: " + response.getStatusCode());
        System.out.println("Created User from response: " + response.getBody());
        
        // 方法 3: 使用 HttpEntity 设置请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Bearer your-token-here");
        
        HttpEntity<UserRequest> requestEntity = new HttpEntity<>(requestUser, headers);
        
        ResponseEntity<UserResponse> responseWithHeaders = restTemplate.postForEntity(
                "https://api.example.com/users", 
                requestEntity, 
                UserResponse.class);
        
        System.out.println("Status Code with headers: " + responseWithHeaders.getStatusCode());
        System.out.println("Created User with headers: " + responseWithHeaders.getBody());
    }
}