<think>
我们正在讨论Java中使用
HTTP请求获取
流数据的方法。用户希望了解如何实现从三方接口获取
流式响应。
在Java中，我们可以使用多种
方式发送
HTTP请求并处理
流响应。常见的方法有：
1. 使用Java原生
HttpURLConnection类
2. 使用Apache
HttpClient库
3. 使用Java 11引入的
HttpClient（java.net.
http包）
4. 使用
Spring框架的RestTemplate或WebClient（针对
Spring应用）
考虑到
流式处理，我们需要避免将整个响应
内容一次性加载到内存，而是逐块读取并处理。下面将分别展示几种
方式的关键代码。
注意：用户要求
返回流数据，因此我们重点展示如何以
流的
方式读取响应。
方法1：使用
HttpURLConnection（Java原生，兼容性强）
步骤：
a. 创建URL对象，打开连接
b. 设置
请求方法（GET/POST等）
c. 设置
请求头（如需要）
d. 获取输入
流，逐行或逐字节读取
方法2：使用Apache
HttpClient（更强大，功能丰富）
需要添加依赖（如Maven）：
<dependency>
<groupId>org.apache.
httpcomponents</groupId>
<artifactId>
httpclient</artifactId>
<version>4.5.13</version> <!-- 使用最新版本 -->
</dependency>
使用Closeable
HttpClient，并设置ResponseHandler或直接获取响应的Entity
流。
方法3：使用Java 11的
HttpClient（现代，异步支持好）
这是Java 11引入的标准库，支持异步和同步
请求。
方法4：使用
Spring WebClient（响应式，非阻塞，适合
Spring应用）
需要
Spring WebFlux依赖，支持
流式处理。
鉴于用户没有指定具体环境，我们将展示两种常用
方式：
HttpURLConnection（原生）和Apache
HttpClient（第三方库）。同时，考虑到现代Java应用，也会简要介绍Java 11
HttpClient。
下面给出示例代码：
示例1：使用
HttpURLConnection
```java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.
HttpURLConnection;
import java.net.URL;
public class
HttpStreamExample {
public static void main(String[] args) throws IOException {
URL url = new URL("
http://example.com/stream-api");
HttpURLConnection connection = (
HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
// 设置
请求头，比如认证信息等
// connection.setRequestProperty("Authorization", "Bearer token");
int responseCode = connection.getResponseCode();
if (responseCode ==
HttpURLConnection.
HTTP_OK) {
// 获取输入
流
try (InputStream inputStream = connection.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
String line;
while ((line = reader.readLine()) != null) {
// 处理每一行
数据，这里可以替换为业务逻辑
System.
out.println(line);
}
}
} else {
// 处理错误
System.err.println("
HTTP error: " + responseCode);
}
connection.disconnect();
}
}
```
示例2：使用Apache
HttpClient
```java
import org.apache.
http.
HttpEntity;
import org.apache.
http.client.methods.Closeable
HttpResponse;
import org.apache.
http.client.methods.
HttpGet;
import org.apache.
http.impl.client.Closeable
HttpClient;
import org.apache.
http.impl.client.
HttpClients;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Apache
HttpClientStreamExample {
public static void main(String[] args) throws IOException {
try (Closeable
HttpClient
httpClient =
HttpClients.createDefault()) {
HttpGet request = new
HttpGet("
http://example.com/stream-api");
// 设置
请求头
// request.addHeader("Authorization", "Bearer token");
try (Closeable
HttpResponse response =
httpClient.execute(request)) {
HttpEntity entity = response.getEntity();
if (entity != null) {
try (InputStream inputStream = entity.getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
String line;
while ((line = reader.readLine()) != null) {
System.
out.println(line);
}
}
}
}
}
}
}
```
示例3：使用Java 11
HttpClient（同步
方式）
```java
import java.net.URI;
import java.net.
http.
HttpClient;
import java.net.
http.
HttpRequest;
import java.net.
http.
HttpResponse;
import java.nio.charset.StandardCharsets;
public class Java11
HttpClientStreamExample {
public static void main(String[] args) throws Exception {
HttpClient client =
HttpClient.new
HttpClient();
HttpRequest request =
HttpRequest.newBuilder()
.uri(URI.create("
http://example.com/stream-api"))
.header("Authorization", "Bearer token") // 可选
.build();
// 发送
请求并获取响应体作为
流
HttpResponse<InputStream> response = client.send(request,
HttpResponse.BodyHandlers.ofInputStream());
InputStream inputStream = response.body();
// 使用try-with-resources确保
流关闭
try (inputStream;
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
String line;
while ((line = reader.readLine()) != null) {
System.
out.println(line);
}
}
}
}
```
注意事项：
- 在处理
流时，务必注意资源的关闭（使用try-with-resources语句）。
- 根据响应
内容类型，可能需要处理字节
流（如二进制
数据）或字符
流（如文本）。上述示例以文本行读取，如果是二进制
流，应直接使用InputStream读取字节。
- 对于大文件或长时间运行的
流，需要考虑设置连接超时和读取超时。
以上方法均可用于从三方接口获取
流数据。用户可以根据项目依赖和Java版本选择合适的方法。
相关问题：
1. 如何处理
HTTP请求中的异常情况？
2. 如何设置
HTTP请求的超时时间？
3. 如何异步处理
HTTP流响应？
4. 如何发送带认证信息的
HTTP请求？
5. 如何解析
流式
返回的JSON
数据（例如JSON
流）？
</think>
### Java中使用
HTTP请求三方接口并
返回流数据的实现方法
在Java中处理
HTTP流响应主要有三种主
流方式，核心思路是**避免将整个响应加载到内存**，通过
流式处理逐块读取
数据。以下是具体实现方案：
---
#### 1. 使用原生 `
HttpURLConnection`（Java标准库）
```java
import java.io.InputStream;
import java.net.
HttpURLConnection;
import java.net.URL;
public class
HttpStreamFetcher {
public static void main(String[] args) throws Exception {
URL url = new URL("
https://api.example.com/stream-data");
HttpURLConnection conn = (
HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
// 关键：设置
流式处理
try (InputStream stream = conn.getInputStream()) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = stream.read(buffer)) != -1) {
// 处理
流数据（例如写入文件或实时解析）
processChunk(buffer, bytesRead);
}
}
conn.disconnect();
}
private static void processChunk(byte[] data, int length) {
// 实现
数据块处理逻辑
}
}
```
**特点**：
- 无需第三方依赖
- 手动处理连接和异常
- 需自行管理连接超时：`conn.setConnectTime
out(5000)`
---
#### 2. 使用Apache
HttpClient（推荐生产环境）
**添加Maven依赖**：
```xml
<dependency>
<groupId>org.apache.
httpcomponents</groupId>
<artifactId>
httpclient</artifactId>
<version>4.5.13</version>
</dependency>
```
**代码实现**：
```java
import org.apache.
http.client.methods.Closeable
HttpResponse;
import org.apache.
http.client.methods.
HttpGet;
import org.apache.
http.impl.client.Closeable
HttpClient;
import org.apache.
http.impl.client.
HttpClients;
public class ApacheStreamClient {
public static void main(String[] args) throws Exception {
try (Closeable
HttpClient client =
HttpClients.createDefault()) {
HttpGet request = new
HttpGet("
https://api.example.com/stream-data");
try (Closeable
HttpResponse response = client.execute(request);
InputStream stream = response.getEntity().getContent()) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = stream.read(buffer)) != -1) {
processChunk(buffer, bytesRead);
}
}
}
}
}
```
**优势**：
- 连接池管理
- 自动重试机制
- 支持
HTTPS和代理
- 设置超时：`RequestConfig.custom().setConnectTime
out(5000).build()`
---
#### 3. 使用Java 11+的`
HttpClient`（现代方案）
```java
import java.net.URI;
import java.net.
http.
HttpClient;
import java.net.
http.
HttpRequest;
import java.net.
http.
HttpResponse;
import java.nio.ByteBuffer;
import java.util.concurrent.Flow;
public class Java11
HttpClient {
public static void main(String[] args) {
HttpClient client =
HttpClient.new
HttpClient();
HttpRequest request =
HttpRequest.newBuilder()
.uri(URI.create("
https://api.example.com/stream-data"))
.build();
// 响应体订阅器（支持背压）
HttpResponse.BodySubscriber<Void> subscriber =
HttpResponse.BodySubscribers.fromSubscriber(new Flow.Subscriber<>() {
@Override
public void onSubscribe(Flow.Subscription subscription) {
subscription.request(Long.MAX_VALUE); //
请求所有
数据
}
@Override
public void onNext(List<ByteBuffer> buffers) {
buffers.forEach(buffer -> processChunk(buffer.array()));
}
@Override
public void onError(Throwable throwable) {
throwable.printStackTrace();
}
@Override
public void onComplete() {
System.
out.println("Stream completed");
}
});
client.sendAsync(request, responseInfo -> subscriber);
}
}
```
**优势**：
- 支持异步非阻塞
- 内置响应式
流处理
- 简洁的链式API
---
### 关键注意事项
1. **连接超时设置**：
```java
// Apache
HttpClient
RequestConfig config = RequestConfig.custom().setConnectTime
out(5000).build();
HttpGet request = new
HttpGet(url);
request.setConfig(config);
```
2. **
流中断处理**：
```java
try (InputStream stream = ...) {
// ...
} catch (SocketTime
outException e) {
// 处理读超时
} finally {
conn.disconnect(); // 确保释放连接
}
```
3. **大文件写入示例**：
```java
try (InputStream in = response.getEntity().getContent();
File
OutputStream
out = new File
OutputStream("data.bin")) {
byte[] buf = new byte[8192];
int n;
while ((n = in.read(buf)) > 0) {
out.write(buf, 0, n);
}
}
```
---
### 性能对比
| 方法 | 依赖 | 异步支持 | 连接池 | 适用场景 |
|---------------------|-------------|----------|--------|------------------------|
|
HttpURLConnection | JDK内置 | ❌ | ❌ | 简单
请求/兼容旧系统 |
| Apache
HttpClient | 第三方库 | ✅ | ✅ | 生产环境/复杂需求 |
| Java 11
HttpClient | JDK11+ | ✅ | ✅ | 新项目/响应式编程 |
> **最佳实践**：生产环境推荐Apache
HttpClient；新项目且使用Java 11+可选用内置
HttpClient[^1]。
博客介绍了Spring HTTP请求中通过Out流返回数据的情况。其优点是可能减少高频调用下接收方IO错误，但未被证实；缺点是out.close后请求结束，后续程序仍运行。还提到用out.flush可分批返回数据，无out.close时能多次返回。
扫一扫
5613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
