我正在使用URL类从中读取InputStream。是否有任何方法可以使用RestTemplate来实现这个功能？
InputStream input = new URL(url).openStream();
JsonReader reader = new JsonReader(new InputStreamReader(input, StandardCharsets.UTF_8.displayName()));
如何使用RestTemplate获取InputStream而不是使用URL？
InputStream时，有时不仅是可取的，而且是必要的，最常见的例子是从源头（如web服务器）流式传输大文件到目标地（如数据库）。如果你尝试使用ByteArrayInputStream，你将会遇到预期之外的OutOfMemoryError。是的，你可以编写自己的HTTP客户端代码，但是你将不得不处理错误响应代码、响应转换器等问题。如果你已经使用了Spring，那么寻找RestTemplate就是一个自然的选择。spring-web:5.0.2.RELEASE拥有一个ResourceHttpMessageConverter，它有一个boolean supportsReadStreaming，如果设置为true，并且响应类型为InputStreamResource，则返回InputStreamResource；否则返回ByteArrayResource。因此，很明显，你不是唯一一个需要流支持的人。RestTemplate在HttpMessageConverter运行后很快就关闭了响应。因此，即使你请求了InputStreamResource并收到了它，但它没有用，因为响应流已经关闭了。我认为这是一个设计缺陷，他们忽视了这一点；它应该依赖于响应类型。因此，很遗憾，对于读取，你必须完全消耗响应；如果使用RestTemplate，则不能传递它。InputStream，ResourceHttpMessageConverter将为你完成。在幕后，它使用org.springframework.util.StreamUtils每次从InputStream中写入4096字节到OutputStream中。一些HttpMessageConverter支持所有媒体类型，因此根据您的要求，您可能需要从RestTemplate中删除默认值，并设置您需要的值，谨慎考虑它们的相对顺序。
最后，如果您正在上传大量数据流，则ClientHttpRequestFactory的实现具有boolean bufferRequestBody，您可以和应该将其设置为false。否则，会出现OutOfMemoryError错误。截至本文撰写时，SimpleClientHttpRequestFactory（JDK客户端）和HttpComponentsClientHttpRequestFactory（Apache HTTP客户端）支持此功能，但OkHttp3ClientHttpRequestFactory不支持。同样是设计上的疏忽。
编辑：已提交工单SPR-16885。
Spring有一个org.springframework.http.converter.ResourceHttpMessageConverter，它可以将Spring的org.springframework.core.io.Resource类转换为其他格式。
Resource类封装了一个InputStream，可以通过someResource.getInputStream()获取。
把这些组合在一起，您可以通过将Resource.class指定为RestTemplate调用的响应类型，从RestTemplate开箱即用地获取InputStream。
以下是使用RestTemplate的exchange(..)方法之一的示例：
import org.springframework.web.client.RestTemplate;
import org.springframework.http.HttpMethod;
import org.springframework.core.io.Resource;
ResponseEntity<Resource> responseEntity = restTemplate.exchange( someUrlString, HttpMethod.GET, someHttpEntity, Resource.class );
InputStream responseInputStream;
try {
responseInputStream = responseEntity.getBody().getInputStream();
}
catch (IOException e) {
throw new RuntimeException(e);
}
// use responseInputStream
responseEntity.getBody().getInputStream();是不正确的。没有getInputStream方法。 - brain stormspring-core-3.1.1.RELEASE 版本旧和新的版本都有一个 org.springframework.core.io.Resource，它继承了 org.springframework.core.io.InputStreamSource 并提供了 getInputStream() 。 - AbdullInputStream，RestTemplate旨在封装响应（和请求）内容的处理。它的优势在于处理所有IO并将一个准备就绪的Java对象交给您。 RestTemplate的原始作者之一Brian Clozel已经表明：
RestTemplate不适用于流式响应体; 它的合同不允许它，并且它已经存在了很长时间，改变其行为的这个基本部分会干扰许多应用程序。
您需要注册适当的HttpMessageConverter对象。这些对象将通过HttpInputMessage对象访问响应的InputStream。
正如Abdull所建议的那样, Spring自带了一个HttpMessageConverter实现Resource，它本身包装了一个InputStream，ResourceHttpMessageConverter。它不支持所有的Resource类型，但既然你应该按照接口编程，那么你应该只使用超级接口Resource。
当前实现（4.3.5）将返回一个ByteArrayResource，其中包含响应流的内容复制到一个新的ByteArrayInputStream中，您可以访问它。
RestTemplate会为你处理。如果你尝试使用InputStreamResource（另一种被ResourceHttpMessageConverter支持的类型），这就很不幸了，因为它包装了底层响应的InputStream但在暴露给客户端代码之前就已经关闭了。InputStream 的一般情况下，你说得没错。然而，RestTemplate 并不支持这种流式使用情况。你可以在其中一个原始作者（Brian Clozel）的评论中看到这一点这里： RestTemplate 不是用来流式传输响应体的; 它的契约不允许它，而且它已经存在了很长时间，改变其行为的这个基本部分是不可能的，会破坏许多应用程序。 - Sotirios Delimanolis我也遇到了同样的问题，通过扩展RestTemplate并在流读取完毕后关闭连接解决了问题。
您可以在此处查看代码：https://github.com/ItamarBenjamin/stream-rest-template
一种非常简单但有效的解决方案是使用ResponseExtractor。当您想要在非常大的InputStream上进行操作并且内存有限时，这种方法尤其有用。
以下是实现方法：
public void consumerInputStreamWithoutBuffering(String url, Consumer<InputStream> streamConsumer) throws IOException {
final ResponseExtractor responseExtractor =
(ClientHttpResponse clientHttpResponse) -> {
streamConsumer.accept(clientHttpResponse.getBody());
return null;
};
restTemplate.execute(url, HttpMethod.GET, null, responseExtractor);
}
然后，在需要的任何地方调用该方法：
Consumer<InputStream> doWhileDownloading = inputStream -> {
//Use inputStream for your business logic...
};
consumerInputStreamWithoutBuffering("https://localhost.com/download", doWhileDownloading);
public InputStream getInputStreamFromResponse(String url) throws IOException {
final ResponseExtractor<InputStream> responseExtractor =
clientHttpResponse -> clientHttpResponse.getBody();
return restTemplate.execute(url, HttpMethod.GET, null, responseExtractor);
}
在您访问它之前，InputStream 将会被关闭。
我通过这种方法解决了问题，希望它能帮助到大家。
@GetMapping("largeFile")
public ResponseEntity<InputStreamResource> downloadLargeFile(
@RequestParam("fileName") String fileName
) throws IOException {
RestTemplate restTemplate = new RestTemplate();
// Optional Accept header
RequestCallback requestCallback = request -> request.getHeaders()
.setAccept(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL));
// Streams the response instead of loading it all in memory
ResponseExtractor<InputStreamResource> responseExtractor = response -> {
// Here I write the response to a file but do what you like
Path path = Paths.get("tmp/" + fileName);
Files.copy(response.getBody(), path, StandardCopyOption.REPLACE_EXISTING);
return new InputStreamResource(new FileInputStream(String.format("tmp/%s", fileName)));
};
InputStreamResource response = restTemplate.execute(
String.format("http://%s:%s/file/largeFileRestTemplate?fileName=%s", host, "9091", fileName),
HttpMethod.GET,
requestCallback,
responseExtractor
);
return ResponseEntity
.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, String.format("attachment; filename=%s", fileName))
.body(response);
}
[
{ "property1": "value1", "property2": "value2", "property3": "value3" },
{ "property1": "value1", "property2": "value2", "property3": "value3" },
... 1446481 objects => a file of 104 MB => take quite long to download...
]
这个JSON数组的每一行都可以被解析为这个对象：
@lombok.Data
public class Testing {
String property1;
String property2;
String property3;
}
import com.fasterxml.jackson.core.JsonParser;
import java.io.IOException;
@FunctionalInterface
public interface JsonStreamer<R> {
/**
* Parse the given JSON stream, process it, and optionally return an object.<br>
* The returned object can represent a downsized parsed version of the stream, or the result of a map/reduce processing, or null...
*
* @param jsonParser the parser to use while streaming JSON for processing
* @return the optional result of the process (can be {@link Void} if processing returns nothing)
* @throws IOException on streaming problem (you are also strongly encouraged to throw HttpMessageNotReadableException on parsing error)
*/
R stream(JsonParser jsonParser) throws IOException;
}
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import lombok.AllArgsConstructor;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
@AllArgsConstructor
public class StreamingHttpMessageConverter<R> implements HttpMessageConverter<R> {
private final JsonFactory factory;
private final JsonStreamer<R> jsonStreamer;
@Override
public boolean canRead(Class<?> clazz, MediaType mediaType) {
return MediaType.APPLICATION_JSON.isCompatibleWith(mediaType);
}
@Override
public boolean canWrite(Class<?> clazz, MediaType mediaType) {
return false; // We only support reading from an InputStream
}
@Override
public List<MediaType> getSupportedMediaTypes() {
return Collections.singletonList(MediaType.APPLICATION_JSON);
}
@Override
public R read(Class<? extends R> clazz, HttpInputMessage inputMessage) throws IOException {
try (InputStream inputStream = inputMessage.getBody();
JsonParser parser = factory.createParser(inputStream)) {
return jsonStreamer.stream(parser);
}
}
@Override
public void write(R result, MediaType contentType, HttpOutputMessage outputMessage) {
throw new UnsupportedOperationException();
}
}
接下来是用于流式HTTP响应、解析JSON数组并返回仅第一个未解组对象的代码:
// You should @Autowire these:
JsonFactory jsonFactory = new JsonFactory();
ObjectMapper objectMapper = new ObjectMapper();
RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
// If detectRequestFactory true (default): HttpComponentsClientHttpRequestFactory will be used and it will consume the entire HTTP response, even if we close the stream early
// If detectRequestFactory false: SimpleClientHttpRequestFactory will be used and it will close the connection as soon as we ask it to
RestTemplate restTemplate = restTemplateBuilder.detectRequestFactory(false).messageConverters(
new StreamingHttpMessageConverter<>(jsonFactory, jsonParser -> {
// While you use a low-level JsonParser to not load everything in memory at once,
// you can still profit from smaller object mapping with the ObjectMapper
if (!jsonParser.isClosed() && jsonParser.nextToken() == JsonToken.START_ARRAY) {
if (!jsonParser.isClosed() && jsonParser.nextToken() == JsonToken.START_OBJECT) {
return objectMapper.readValue(jsonParser, Testing.class);
}
}
return null;
})
).build();
final Testing firstTesting = restTemplate.getForObject("http://example.org/testings.json", Testing.class);
log.debug("First testing object: {}", firstTesting);
try 块，响应流就会关闭，因此看起来你会得到一个异常。 - Abhijit SarkarR，所以显然你必须完全消耗流并反序列化为 R。 - Abhijit Sarkar RestTemplate restTemplate = new RestTemplateBuilder().basicAuthentication("user", "their_password" ).build();
int responseSize = restTemplate.execute(uri,
HttpMethod.POST,
(ClientHttpRequest requestCallback) -> {
requestCallback.getHeaders().setContentType(MediaType.APPLICATION_JSON);
requestCallback.getBody().write(body.getBytes());
},
responseExtractor -> {
FileOutputStream fos = new FileOutputStream(new File("out.json"));
return StreamUtils.copy(responseExtractor.getBody(), fos);
}
)
byte data[] = restTemplate.execute(link, HttpMethod.GET, null, new BinaryFileExtractor());
return new ByteArrayInputStream(data);
Extractor 是
public class BinaryFileExtractor implements ResponseExtractor<byte[]> {
@Override
public byte[] extractData(ClientHttpResponse response) throws IOException {
return ByteStreams.toByteArray(response.getBody());
}
}