当前位置： 首页 > news >正文

RestTemplate 和 Apache HttpClient 实现 HTTP 请求

news 2025/11/12 5:28:47

一、整体使用广度

从行业实际应用来看，Spring 框架（含 Spring Boot）占据 Java 后端的半壁江山，因此与其深度集成的 RestTemplate（同步）和 WebClient（异步，Spring 5+）是最主流的选择；而非 Spring 项目（如传统 Java 项目、中间件）中，Apache HttpClient 凭借成熟稳定的特性成为首选。

具体使用占比（基于社区调研、招聘需求、开源项目统计）：

工具使用占比（估算）核心场景
RestTemplate40%+Spring Boot 同步 HTTP 请求（最主流）
Apache HttpClient25%+非 Spring 项目、复杂 HTTP 需求（连接池、SSL、认证）
WebClient（Spring 5+）20%+Spring Boot 异步 / 响应式编程（趋势）
Java 11+ HttpClient10%+Java 11+ 无依赖项目、轻量异步场景
其他（OkHttp、Retrofit）5% 以内移动端 / Android 联动、特定框架集成

二、分场景详解

1. Spring 项目：RestTemplate（同步）/ WebClient（异步）

Spring Boot 是当前 Java 后端最流行的框架（占比超 60%），而 RestTemplate/WebClient 作为 Spring 内置的 HTTP 客户端，几乎是 Spring 项目的 “标配”，核心原因：

  • 零额外依赖：Spring 核心包自带，无需引入第三方库，开箱即用。
  • 无缝集成：支持 Spring 依赖注入、AOP、消息转换器（自动 JSON/XML 序列化）、异常处理等生态特性。
  • API 简洁：模板方法设计（如 getForObject、postForEntity），无需关注底层连接管理、资源释放，开发效率极高。
  • 升级平滑：Spring 5+ 推出 WebClient（响应式编程，支持异步 / 非阻塞），完美适配微服务高并发场景，逐步替代 RestTemplate 成为新趋势。

2. 非 Spring 项目：Apache HttpClient —— 成熟稳定的 “万能工具”

在传统 Java 项目、中间件（如 Dubbo、Elasticsearch 客户端）、非 Spring 微服务中，Apache HttpClient 是绝对的主流，核心原因：

  • 功能全面：支持连接池、SSL 证书自定义、重试策略、代理、Digest Auth 等所有复杂 HTTP 场景，是 Java 生态中功能最完善的 HTTP 客户端。
  • 稳定性强：迭代近 20 年（4.x 版本已稳定多年），经过海量生产环境验证，bug 少、兼容性好。
  • 线程安全：CloseableHttpClient 实例可全局单例，连接池优化成熟，适合高并发场景。
  • 生态兼容：很多框架（如 RestTemplate 可配置其作为底层请求工厂）、工具类都基于它封装，间接扩大了其使用范围。

3. 其他工具

  • Java 11+ HttpClient：作为 Java 标准库，无需第三方依赖，但功能不如 Apache HttpClient 丰富（如连接池配置、重试策略需手动实现），仅在 Java 11+ 无依赖场景中使用较多。
  • OkHttp：由 Square 开发，API 简洁、支持 HTTP/2，在 Android 端使用广泛，但 Java 后端项目中因缺乏框架深度集成，使用占比远低于前三者。
  • Retrofit：基于 OkHttp 封装的声明式 HTTP 客户端（类似 Spring Cloud OpenFeign），适合 API 接口较多的场景，但需额外定义接口，灵活性略低，主要用于特定业务场景。

三、RestTemplate 详解

RestTemplate 是 Spring 3.0 提供的 HTTP 客户端工具，封装了底层 HTTP 通信细节（默认使用 HttpURLConnection，可替换为 HttpClient/OkHttp），支持 Spring 生态的特性（如依赖注入、异常处理、消息转换器），适合 Spring 项目使用。

1. 核心组件与参数

（1）RestTemplate 初始化

通过 RestTemplateBuilder 或直接 new 初始化，核心配置参数如下：

参数说明示例代码
setConnectTimeout连接超时（毫秒）.setConnectTimeout(Duration.ofSeconds(5))
setReadTimeout读取超时（等待响应数据的时间，毫秒）.setReadTimeout(Duration.ofSeconds(10))
setDefaultHeader默认请求头（所有请求共享）.setDefaultHeader(“User-Agent”, “RestTemplate/Spring”)
messageConverters消息转换器（将请求体转为 JSON/XML，响应体转为 Java 对象）.messageConverters(Arrays.asList(new MappingJackson2HttpMessageConverter()))
requestFactory底层 HTTP 工厂（默认 SimpleClientHttpRequestFactory，可替换为 HttpComponentsClientHttpRequestFactory 以支持 HttpClient 特性）.requestFactory(new HttpComponentsClientHttpRequestFactory(httpClient))
errorHandler错误处理器（自定义 4xx/5xx 响应的异常处理）.errorHandler(new DefaultResponseErrorHandler() { … })
interceptors请求拦截器（统一添加头信息、日志打印、认证等）.interceptors(new LoggingInterceptor())
（2）核心请求方法

RestTemplate 提供了丰富的模板方法，无需手动构建请求体 / 响应体，核心方法如下：

方法名说明适用场景
getForObject()GET 请求，直接返回响应体转为的 Java 对象响应体为 JSON/XML，需映射为实体类
getForEntity()GET 请求，返回 ResponseEntity（含状态码、头、响应体）需获取响应头 / 状态码
postForObject()POST 请求，返回响应体对象提交数据并获取结果
postForEntity()POST 请求，返回 ResponseEntity需获取响应元数据
postForLocation()POST 请求，返回重定向地址（Location 头）表单提交后重定向
put()PUT 请求（无返回值）更新资源
delete()DELETE 请求（无返回值）删除资源
exchange()通用方法（支持自定义请求方法、头、请求体）复杂场景（如 PATCH、自定义头）
execute()最底层方法（完全自定义请求 / 响应处理）特殊需求（如二进制流处理）
（3）关键参数说明
  • URL 参数占位符：支持 {name} 占位符，自动替换参数（避免字符串拼接错误）：
// 方式1：直接拼接参数
restTemplate.getForObject("https://api.example.com/user/{id}", User.class, 1001);
// 方式2：Map 传递参数
Map<String, Object> params = new HashMap<>();
params.put("id", 1001);
restTemplate.getForObject("https://api.example.com/user/{id}", User.class, params);
  • 请求头（HttpHeaders）：通过 HttpEntity 封装请求头和请求体：
HttpHeaders headers = new HttpHeaders();
headers.set("Content-Type", "application/json");
headers.set("Authorization", "Bearer your-token");
HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers); // 请求体+头

2. RestTemplate 完整示例

  1. Spring Boot 中初始化 RestTemplate（推荐）
    在 Spring Boot 项目中，通过 @Bean 注入 RestTemplate，统一配置：
  • 简单配置示例：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Collections;@Configuration
public class RestTemplateConfig {@Beanpublic RestTemplate restTemplate() {// 1. 配置底层 HTTP 工厂HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();factory.setConnectTimeout(Duration.ofSeconds(5));factory.setReadTimeout(Duration.ofSeconds(10));factory.setConnectionRequestTimeout(Duration.ofSeconds(3));// 2. 构建 RestTemplate（指定工厂）RestTemplate restTemplate = new RestTemplate(factory);// 3. 移除默认的 StringHttpMessageConverter（避免其默认 ISO-8859-1 编码冲突）restTemplate.getMessageConverters().removeIf(converter -> converter instanceof StringHttpMessageConverter);// 4. 配置 JSON 转换器（明确指定 UTF-8 字符集）MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();jsonConverter.setDefaultCharset(StandardCharsets.UTF_8); // 核心：设置 UTF-8restTemplate.getMessageConverters().add(jsonConverter);// 5. （可选）如果需要单独处理 String 响应，添加 UTF-8 编码的 String 转换器restTemplate.getMessageConverters().add(new StringHttpMessageConverter(StandardCharsets.UTF_8));// 6. 请求拦截器（保持不变）restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {request.getHeaders().set("Authorization", "Bearer your-token");// 可选：给请求头添加 Content-Type（明确告知服务端请求体是 UTF-8 编码的 JSON）request.getHeaders().setContentType(org.springframework.http.MediaType.APPLICATION_JSON_UTF8);return execution.execute(request, body);}));return restTemplate;}
}
  • 高级配置示例（含连接池、HTTPS、重试）：
    依赖引入（Maven）：
<!-- Apache HttpClient 核心依赖 -->
<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.5.14</version> <!-- 适配 Spring 版本，避免冲突 -->
</dependency>

import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContextBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;import javax.net.ssl.SSLContext;
import java.time.Duration;@Configuration
public class RestTemplateConfig {@Beanpublic RestTemplate restTemplate() {// 1. 配置 HttpClient 连接池PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();connectionManager.setMaxTotal(200); // 连接池最大总连接数connectionManager.setDefaultMaxPerRoute(50); // 每个路由（域名）的最大连接数connectionManager.setValidateAfterInactivity(30000); // 空闲连接校验时间（30s）// 2. 配置 HTTPS（跳过证书校验，生产环境建议用真实证书）SSLContext sslContext = null;try {sslContext = new SSLContextBuilder().loadTrustMaterial(null, (certificate, authType) -> true) // 信任所有证书.build();} catch (Exception e) {throw new RuntimeException("HTTPS 配置失败", e);}SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE); // 禁用主机名校验// 3. 配置请求超时RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000) // 连接超时 5s.setSocketTimeout(10000) // 读取超时 10s.setConnectionRequestTimeout(3000) // 从连接池获取连接的超时 3s.build();// 4. 构建 HttpClient 实例HttpClient httpClient = HttpClients.custom().setConnectionManager(connectionManager).setDefaultRequestConfig(requestConfig).setSSLSocketFactory(sslSocketFactory).evictIdleConnections(Duration.ofSeconds(60)) // 60s 空闲连接自动关闭.build();// 5. 包装为 Spring 的请求工厂HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);// 6. 构建 RestTemplatereturn new RestTemplate(factory);}
}
  1. GET 请求（返回实体类、带参数）
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;import java.time.Duration;@Configuration
public class RestTemplateConfig {@Beanpublic RestTemplate restTemplate() {// 1. 配置底层 HTTP 工厂（使用 HttpClient 提升性能，支持连接池）HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();factory.setConnectTimeout(Duration.ofSeconds(5)); // 连接超时factory.setReadTimeout(Duration.ofSeconds(10));    // 读取超时factory.setConnectionRequestTimeout(Duration.ofSeconds(3)); // 从连接池获取连接的超时// 2. 构建 RestTemplateRestTemplate restTemplate = new RestTemplate(factory);// 3. 添加 JSON 消息转换器（支持请求体/响应体自动转换）restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());// 4. 添加请求拦截器（示例：统一添加 Authorization 头）restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {request.getHeaders().set("Authorization", "Bearer your-token");return execution.execute(request, body);}));return restTemplate;}
}
  1. POST 请求（JSON 体、Basic Auth）
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;import javax.annotation.Resource;
import java.util.Base64;public class RestTemplatePostExample {@Resourceprivate RestTemplate restTemplate;public String login() {// 1. 构建 JSON 请求体（也可直接传入 User 对象，RestTemplate 自动转为 JSON）UserLoginRequest loginRequest = new UserLoginRequest("test", "123456");// 2. 配置请求头（Basic Auth + JSON 格式）String username = "admin";String password = "123456";String auth = "Basic " + Base64.getEncoder().encodeToString((username + ":" + password).getBytes());HttpHeaders headers = new HttpHeaders();headers.setContentType(MediaType.APPLICATION_JSON); // JSON 格式headers.set("Authorization", auth);// 3. 封装请求实体（请求体 + 头）HttpEntity<UserLoginRequest> requestEntity = new HttpEntity<>(loginRequest, headers);// 4. 发送 POST 请求（返回响应体字符串）String response = restTemplate.postForObject("https://api.example.com/login",requestEntity,String.class);// 5. 若返回 JSON，直接转为实体类LoginResponse loginResponse = restTemplate.postForObject("https://api.example.com/login",requestEntity,LoginResponse.class);return loginResponse.getToken();}// 请求实体类static class UserLoginRequest {private String username;private String password;// 构造器/getter/setter}// 响应实体类static class LoginResponse {private String token;private Long expireTime;// getter/setter}
}

四、Apache HttpClient 详解

Apache HttpClient（org.apache.httpcomponents）是 Java 生态中最成熟、功能最强大的 HTTP 客户端工具之一，相比 Java 11 内置的 HttpClient 和 Spring 的 RestTemplate，它提供了更精细的配置选项（如连接池、SSL 证书、重试策略等）

1.核心依赖

首先需要在项目中引入 Apache HttpClient 的 Maven/Gradle 依赖：
Maven 依赖

<!-- 核心依赖（HTTP 客户端基础功能） -->
<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.5.14</version> <!-- 最新稳定版 -->
</dependency><!-- 可选：支持 Multipart 表单（文件上传） -->
<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpmime</artifactId><version>4.5.14</version>
</dependency><!-- 可选：JSON 序列化（与 Jackson 配合） -->
<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.15.3</version>
</dependency>

2.核心组件与关键参数

Apache HttpClient 的核心是 CloseableHttpClient（客户端实例），通过 HttpClientBuilder 构建，配合 HttpGet/HttpPost 等请求对象、HttpEntity（请求体 / 响应体）完成 HTTP 通信。

  • 核心组件说明
组件类名作用
HttpClientBuilder构建 CloseableHttpClient 的核心构建器，配置全局参数（连接池、超时、SSL 等）
CloseableHttpClientHTTP 客户端实例，负责发送请求、接收响应（线程安全，建议全局单例）
HttpGet/HttpPost/HttpPut/HttpDelete具体的 HTTP 请求对象，配置请求 URL、头、参数等
HttpEntity封装请求体 / 响应体数据（如字符串、字节流、文件等），需手动关闭资源
HttpResponseHTTP 响应对象，包含状态码、响应头、响应体（HttpEntity）
RequestConfig单个请求的配置（超时、重定向策略等，可覆盖全局配置）
PoolingHttpClientConnectionManager连接池管理器，控制最大连接数、每个路由连接数等（性能优化核心）
  • 关键配置参数
    （1）全局配置（HttpClientBuilder）
    通过 HttpClientBuilder 配置客户端级别的全局参数，核心参数如下：
参数方法说明示例代码
setConnectionManager设置连接池管理器（必配，优化性能）.setConnectionManager(connectionManager)
setDefaultRequestConfig设置默认请求配置（超时、重定向等）.setDefaultRequestConfig(defaultRequestConfig)
setSSLContext配置 SSL 上下文（自定义证书、跳过 SSL 验证）.setSSLContext(sslContext)
setSSLSocketFactorySSL 套接字工厂（配合 SSLContext 配置加密套件、协议版本）.setSSLSocketFactory(sslSocketFactory)
setProxy配置代理（HTTP/HTTPS 代理）.setProxy(new HttpHost(“127.0.0.1”, 8888))
setDefaultCredentialsProvider默认凭证提供器（Basic Auth、Digest Auth 等全局认证）.setDefaultCredentialsProvider(credentialsProvider)
setRetryHandler重试策略（网络异常、5xx 状态码自动重试）.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true))
setUserAgent默认 User-Agent 头.setUserAgent(“Apache-HttpClient/4.5.14”)
disableAutomaticRetries禁用自动重试.disableAutomaticRetries()
setMaxConnTotal最大总连接数（连接池全局限制，替代连接池管理器的配置）.setMaxConnTotal(200)
setMaxConnPerRoute每个路由最大连接数（单个域名 / IP 的连接限制）.setMaxConnPerRoute(50)

（2）请求级配置（RequestConfig）
通过 RequestConfig.Builder 配置单个请求的参数，可覆盖全局配置：

参数方法说明示例代码
setConnectTimeout连接超时（建立 TCP 连接的时间限制，毫秒）.setConnectTimeout(5000)（5 秒）
setSocketTimeout读取超时（等待响应数据的时间限制，毫秒）.setSocketTimeout(10000)（10 秒）
setConnectionRequestTimeout从连接池获取连接的超时时间（毫秒）.setConnectionRequestTimeout(3000)（3 秒）
setRedirectsEnabled是否允许重定向（默认 true）.setRedirectsEnabled(false)
setMaxRedirects最大重定向次数.setMaxRedirects(3)
setCircularRedirectsAllowed是否允许循环重定向（默认 false）.setCircularRedirectsAllowed(true)

（3）连接池配置（PoolingHttpClientConnectionManager）
连接池是高并发场景的核心优化，通过 PoolingHttpClientConnectionManager 配置：

参数方法说明示例代码
setMaxTotal连接池最大总连接数（默认 20）.setMaxTotal(200)
setDefaultMaxPerRoute每个路由默认最大连接数（默认 2）.setDefaultMaxPerRoute(50)
setMaxPerRoute为特定路由设置最大连接数（如对某个域名单独限制）.setMaxPerRoute(new HttpRoute(httpHost), 100)
setConnectionTimeToLive连接存活时间（超过时间自动关闭，避免空闲连接占用资源）.setConnectionTimeToLive(30, TimeUnit.SECONDS)
closeExpiredConnections关闭过期的连接（建议定时调用，如定时任务每 30 秒执行一次）connectionManager.closeExpiredConnections()
closeIdleConnections关闭空闲超过指定时间的连接connectionManager.closeIdleConnections(60, TimeUnit.SECONDS)

3.完整示例

1. 基础配置：创建全局 HttpClient 实例（单例）

建议在项目中使用单例模式创建 CloseableHttpClient，避免重复创建销毁连接池：

import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContexts;import javax.net.ssl.SSLContext;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeUnit;public class HttpClientConfig {// 单例 HttpClient 实例private static CloseableHttpClient httpClient;static {try {httpClient = createHttpClient();} catch (Exception e) {throw new RuntimeException("创建 HttpClient 失败", e);}}public static CloseableHttpClient getHttpClient() {return httpClient;}private static CloseableHttpClient createHttpClient() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException {// 1. 配置 SSL 上下文（默认使用系统信任证书，生产环境建议自定义）SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, (chain, authType) -> true) // 跳过 SSL 验证（仅测试环境）.build();// 2. 创建连接池管理器ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext);HttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();// 3. 配置连接池参数PoolingHttpClientConnectionManager poolingManager = (PoolingHttpClientConnectionManager) connectionManager;poolingManager.setMaxTotal(200); // 最大总连接数poolingManager.setDefaultMaxPerRoute(50); // 每个路由默认最大连接数// 为特定路由设置更大的连接数（如 API 服务器）HttpHost apiHost = new HttpHost("api.example.com", 443, "https");poolingManager.setMaxPerRoute(new HttpRoute(apiHost), 100);// 4. 配置默认请求参数（超时、重定向等）RequestConfig defaultRequestConfig = RequestConfig.custom().setConnectTimeout(5000) // 连接超时 5 秒.setSocketTimeout(10000) // 读取超时 10 秒.setConnectionRequestTimeout(3000) // 连接池获取连接超时 3 秒.setRedirectsEnabled(true) // 允许重定向.setMaxRedirects(3) // 最大重定向 3 次.build();// 5. 构建 HttpClientreturn HttpClientBuilder.create().setConnectionManager(connectionManager).setDefaultRequestConfig(defaultRequestConfig).setUserAgent("Apache-HttpClient/4.5.14").setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)) // 重试 3 次（非幂等请求不重试）.build();}// 定时清理过期/空闲连接（建议在项目启动时启动定时任务）public static void startConnectionCleanupTask() {HttpClientConnectionManager connectionManager = ((PoolingHttpClientConnectionManager) httpClient.getConnectionManager());new Thread(() -> {while (true) {try {Thread.sleep(30000); // 每 30 秒执行一次connectionManager.closeExpiredConnections(); // 关闭过期连接connectionManager.closeIdleConnections(60, TimeUnit.SECONDS); // 关闭空闲 60 秒以上的连接} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}}).start();}
}
2. GET 请求（带查询参数、请求头）
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.util.EntityUtils;import java.net.URI;
import java.util.HashMap;
import java.util.Map;public class HttpClientGetExample {public static void main(String[] args) {CloseableHttpClient httpClient = HttpClientConfig.getHttpClient();CloseableHttpResponse response = null;try {// 1. 构建 GET 请求 URL（带查询参数）String baseUrl = "https://api.example.com/user";Map<String, String> params = new HashMap<>();params.put("id", "1001");params.put("name", "test");// 使用 URIBuilder 拼接参数（自动处理 URL 编码）URIBuilder uriBuilder = new URIBuilder(baseUrl);for (Map.Entry<String, String> entry : params.entrySet()) {uriBuilder.addParameter(entry.getKey(), entry.getValue());}URI uri = uriBuilder.build();// 2. 创建 HttpGet 请求对象HttpGet httpGet = new HttpGet(uri);// 3. 设置请求头httpGet.setHeader("Authorization", "Bearer your-token");httpGet.setHeader("User-Agent", "Apache-HttpClient/Test");httpGet.setHeader("Accept", "application/json");// 4. （可选）覆盖全局请求配置（如单独设置超时）RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(15000) // 读取超时 15 秒（覆盖全局 10 秒）.build();httpGet.setConfig(requestConfig);// 5. 发送请求并获取响应response = httpClient.execute(httpGet);// 6. 处理响应int statusCode = response.getStatusLine().getStatusCode();System.out.println("状态码：" + statusCode);HttpEntity responseEntity = response.getEntity();if (responseEntity != null) {String responseBody = EntityUtils.toString(responseEntity, "UTF-8"); // 响应体转为字符串（指定 UTF-8）System.out.println("响应体：" + responseBody);// 若响应为 JSON，可转为 Java 对象（配合 Jackson）// ObjectMapper objectMapper = new ObjectMapper();// User user = objectMapper.readValue(responseBody, User.class);}// 7. 消耗响应体（避免连接泄漏）EntityUtils.consume(responseEntity);} catch (Exception e) {e.printStackTrace();} finally {// 8. 关闭响应对象（必须关闭，释放连接）if (response != null) {try {response.close();} catch (Exception e) {e.printStackTrace();}}}}// 实体类示例static class User {private Long id;private String name;// getter/setter/toString}
}
3. POST 请求（JSON 体、Basic Auth）
import org.apache.http.HttpEntity;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
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.BasicCredentialsProvider;
import org.apache.http.util.EntityUtils;
import com.fasterxml.jackson.databind.ObjectMapper;public class HttpClientPostExample {public static void main(String[] args) {CloseableHttpClient httpClient = HttpClientConfig.getHttpClient();CloseableHttpResponse response = null;ObjectMapper objectMapper = new ObjectMapper(); // Jackson JSON 工具try {// 1. 配置 Basic Auth（两种方式：全局凭证/请求头）// 方式1：全局凭证（通过 HttpClientBuilder 配置，适用于所有请求）CredentialsProvider credentialsProvider = new BasicCredentialsProvider();credentialsProvider.setCredentials(AuthScope.ANY, // 对所有地址生效new UsernamePasswordCredentials("admin", "123456"));// 若需单独为该请求配置 Auth，可创建新的 HttpClient：// CloseableHttpClient authHttpClient = HttpClientBuilder.create().setDefaultCredentialsProvider(credentialsProvider).build();// 方式2：手动添加 Basic Auth 头（更灵活）String auth = "Basic " + java.util.Base64.getEncoder().encodeToString(("admin:123456").getBytes());// 2. 创建 HttpPost 请求对象HttpPost httpPost = new HttpPost("https://api.example.com/login");// 3. 设置请求头httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");httpPost.setHeader("Authorization", auth); // Basic Auth 头// 4. 构建 JSON 请求体（两种方式：字符串/Java 对象）// 方式1：直接传入 JSON 字符串String jsonBody = "{\"username\":\"test\",\"password\":\"123456\"}";// 方式2：Java 对象转为 JSON 字符串（推荐，避免手动拼接错误）LoginRequest loginRequest = new LoginRequest("test", "123456");jsonBody = objectMapper.writeValueAsString(loginRequest);// 5. 设置请求体（StringEntity 封装字符串，指定编码）StringEntity requestEntity = new StringEntity(jsonBody, "UTF-8");httpPost.setEntity(requestEntity);// 6. 发送请求response = httpClient.execute(httpPost);// 7. 处理响应int statusCode = response.getStatusLine().getStatusCode();System.out.println("状态码：" + statusCode);HttpEntity responseEntity = response.getEntity();if (responseEntity != null) {String responseBody = EntityUtils.toString(responseEntity, "UTF-8");System.out.println("响应体：" + responseBody);// JSON 响应转为 Java 对象LoginResponse loginResponse = objectMapper.readValue(responseBody, LoginResponse.class);System.out.println("登录令牌：" + loginResponse.getToken());}EntityUtils.consume(responseEntity);} catch (Exception e) {e.printStackTrace();} finally {if (response != null) {try {response.close();} catch (Exception e) {e.printStackTrace();}}}}// 请求实体类static class LoginRequest {private String username;private String password;public LoginRequest(String username, String password) {this.username = username;this.password = password;}// getter/setter}// 响应实体类static class LoginResponse {private String token;private Long expireTime;// getter/setter}
}
http://www.dtcms.com/a/596549.html

相关文章：

  • Lua 变量
  • 国外网站设计模板百度引擎搜索
  • css波浪线和着重号效果
  • Ansible 任务控制全面解析
  • 昇腾CANN训练营 学习（day4）Ascend C算子开发全流程深度解析：从环境准备到异构计算部署
  • 谷歌发布 Veo 3.1 视频生成模型：有声电影、长视频叙事与人物定制的实测与展望
  • 有做a50期货的网站青岛网站建设方案书
  • 2.10 实践练习：训练一个意图识别模型并部署为 API
  • 数据结构精讲：从零到一搞懂队列与循环队列的底层实现
  • 微信小程序开发案例 | 幸运抽签小程序（下）
  • 如何在 Windows 电脑上调试 iOS 设备上的 Safari？完整方案与实战经验分享
  • 密度聚类调参精讲
  • 场馆预约小程序拓展功能分析：技术赋能下的效率革命与商业破局
  • 【开题答辩全过程】以 二手小型电子产品商城小程序为例，包含答辩的问题和答案
  • 怎么查百度收录网站网站建设代码生成器
  • 网站建设科技建盏大师排名与落款
  • 【面经 每日一题】面试题16.25.LRU缓存(medium)
  • 网站推广常用的方法seo搜索引擎优化视频
  • XML的了解
  • 开源制品管理工具Hadess，一键安装及快速入门教程
  • 【云运维】Python基础（三）
  • MyBatis-Plus 进阶实战：不用写 XML，CRUD + 复杂查询像 “点奶茶” 一样简单
  • 野狗算法详细原理，野狗算法公式，野狗算法求解目标函数极值
  • V-Ray 渲染高效优化指南
  • 商丘网站建设的公司哪家好菏泽网站建设
  • RobotFramework框架基本功能语法
  • 120. 三角形最小路径和
  • Redis（116）Redis的内存管理如何实现？
  • 如何通过中药饮片采购平台实现安全高效的全链路供应链建立？
  • 兴县做网站的公司wordpress登陆改图标和连接