5

I'm building a reverse-proxy for uploading large files (multiple gigabytes), and therefore want to use a streaming model that does not buffer entire files. Large buffers would introduce latency and, more importantly, they could result in out-of-memory errors.

My client class contains

@Autowired private RestTemplate restTemplate;

@Bean
public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {

    int REST_TEMPLATE_MODE = 1; // 1=streams, 2=streams, 3=buffers

    return 
        REST_TEMPLATE_MODE == 1 ? new RestTemplate() :
        REST_TEMPLATE_MODE == 2 ? (new RestTemplateBuilder()).build() :
        REST_TEMPLATE_MODE == 3 ? restTemplateBuilder.build() : null;
}

and

public void upload_via_streaming(InputStream inputStream, String originalname) {

    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setBufferRequestBody(false);
    restTemplate.setRequestFactory(requestFactory);

    InputStreamResource inputStreamResource = new InputStreamResource(inputStream) {
        @Override public String getFilename() { return originalname; }
        @Override public long contentLength() { return -1; }
    };

    MultiValueMap<String, Object> body = new LinkedMultiValueMap<String, Object>();
    body.add("myfile", inputStreamResource);

    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.MULTIPART_FORM_DATA);

    HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(body,headers);

    String response = restTemplate.postForObject(UPLOAD_URL, requestEntity, String.class);
    System.out.println("response: "+response);
}

This is working, but notice my REST_TEMPLATE_MODE value controls whether or not it meets my streaming requirement.

Question: Why does REST_TEMPLATE_MODE == 3 result in full-file buffering?

References:

Brent Bradburn
  • 51,587
  • 17
  • 154
  • 173
  • BTW: Full-file buffering was detected by observing the symptoms: latency and server memory profile. – Brent Bradburn Jul 20 '18 at 00:32
  • Related?: [Shouldn't RestTemplate be instantiated per @Service class ?](https://stackoverflow.com/q/39957550/86967) – Brent Bradburn Jul 20 '18 at 17:13
  • Interesting description about "the most suitable `ClientHttpRequestFactory`": [Class RestTemplateBuilder](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/web/client/RestTemplateBuilder.html) – Brent Bradburn Aug 08 '18 at 20:09
  • 1
    I find it amusing that `setBufferRequestBody(false)` doesn't guarantee that result. – Brent Bradburn Aug 09 '18 at 04:29
  • Possibly useful: [Spring RestTemplate (setBufferRequestBody as false) does not like MultiValueMap request body, which contains an InputStream object](https://stackoverflow.com/q/40577107/86967) – Brent Bradburn Aug 09 '18 at 04:34
  • Another input stream: https://stackoverflow.com/questions/32782026/springboot-large-streaming-file-upload-using-apache-commons-fileupload – Brent Bradburn Aug 20 '18 at 04:18
  • More on input-side streaming: [Cannot get Spring Boot to lazily resolve a multipart file](https://stackoverflow.com/q/49234757/86967) – Brent Bradburn Aug 20 '18 at 04:43

1 Answers1

7

In short, the instance of RestTemplateBuilder provided as an @Bean by Spring Boot includes an interceptor (filter) associated with actuator/metrics -- and the interceptor interface requires buffering of the request body into a simple byte[].

If you instantiate your own RestTemplateBuilder or RestTemplate from scratch, it won't include this by default.

I seem to be the only person visiting this post, but just in case it helps someone before I get around to posting a complete solution, I've found a big clue:

restTemplate.getInterceptors().forEach(item->System.out.println(item));

displays...

org.SF.boot.actuate.metrics.web.client.MetricsClientHttpRequestInterceptor

If I clear the interceptor list via setInterceptors, it solves the problem. Furthermore, I found that any interceptor, even if it only performs a NOP, will introduce full-file buffering.

public class SimpleClientHttpRequestFactory { ...

I have explicitly set bufferRequestBody = false, but apparently this code is bypassed if interceptors are used. This would have been nice to know earlier...

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    HttpURLConnection connection = openConnection(uri.toURL(), this.proxy);
    prepareConnection(connection, httpMethod.name());

    if (this.bufferRequestBody) {
        return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming);
    }
    else {
        return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming);
    }
}

public abstract class InterceptingHttpAccessor extends HttpAccessor { ...

This shows that the InterceptingClientHttpRequestFactory is used if the list of interceptors is not empty.

/**
 * Overridden to expose an {@link InterceptingClientHttpRequestFactory}
 * if necessary.
 * @see #getInterceptors()
 */
@Override
public ClientHttpRequestFactory getRequestFactory() {
    List<ClientHttpRequestInterceptor> interceptors = getInterceptors();
    if (!CollectionUtils.isEmpty(interceptors)) {
        ClientHttpRequestFactory factory = this.interceptingRequestFactory;
        if (factory == null) {
            factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors);
            this.interceptingRequestFactory = factory;
        }
        return factory;
    }
    else {
        return super.getRequestFactory();
    }
}

class InterceptingClientHttpRequest extends AbstractBufferingClientHttpRequest { ...

The interfaces make it clear that using InterceptingClientHttpRequest requires buffering body to a byte[]. There is not an option to use a streaming interface.

    @Override
    public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
Brent Bradburn
  • 51,587
  • 17
  • 154
  • 173