Uploading MultipartFile with Spring RestTemplate

1. Overview

This quick tutorial focuses on how to upload a multipart file using Spring’s RestTemplate.

We’ll see both a single file and multiple files – upload using the RestTemplate.

2. What is an HTTP Multipart Request?

Simply put, a basic HTTP POST request body holds form data in name/value pairs.

On the other hand, HTTP clients can construct HTTP multipart requests to send text or binary files to the server; it’s mainly used for uploading files.

Another common use-case is sending the email with an attachment. Multipart file requests break a large file into smaller chunks and use boundary markers to indicate the start and end of the block.

Explore more about multipart requests here.

3. Maven Dependency

This single dependency is enough for the client application:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.7.RELEASE</version>
</dependency>

4. The File Upload Server

The file server API exposes two REST endpoints for uploading single and multiple files respectively:

• POST /fileserver/singlefileupload/
• POST /fileserver/multiplefileupload/

5. Uploading a Single File

First, let’s see single file upload using the RestTemplate.

We need to create HttpEntitywith header and body. Set the content-type header value to MediaType.MULTIPART_FORM_DATA. When this header is set, RestTemplate automatically marshals the file data along with some metadata.

Metadata includes file name, file size, and file content type (for example text/plain):

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

Next, build the request body as an instance of LinkedMultiValueMap class. LinkedMultiValueMap wraps LinkedHashMap storing multiple values for each key in a LinkedList.

In our example, the getTestFile( ) method generates a dummy file on the fly and returns a FileSystemResource:

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

Finally, construct an HttpEntity instance that wraps the header and the body object and post it using a RestTemplate.

Note that the single file upload points to the /fileserver/singlefileupload/ endpoint.

In the end, the call restTemplate.postForEntity( ) completes the job of connecting to the given URL and sending the file to the server:

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

String serverUrl = "http://localhost:8082/spring-rest/fileserver/singlefileupload/";

RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> response = restTemplate
  .postForEntity(serverUrl, requestEntity, String.class);

6. Uploading Multiple Files

In multiple file upload, the only change from single file upload is in constructing the body of the request.

Let’s create multiple files and add them with the same key in MultiValueMap.

Obviously, the request URL should refer to endpoint for multiple file upload:

MultiValueMap<String, Object> body
  = new LinkedMultiValueMap<>();
body.add("files", getTestFile());
body.add("files", getTestFile());
body.add("files", getTestFile());
    
HttpEntity<MultiValueMap<String, Object>> requestEntity
  = new HttpEntity<>(body, headers);

String serverUrl = "http://localhost:8082/spring-rest/fileserver/multiplefileupload/";

RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> response = restTemplate
  .postForEntity(serverUrl, requestEntity, String.class);

It’s always possible to model single file upload using the multiple file upload.

7. Conclusion

In conclusion, we saw a case of MultipartFile transfer using Spring RestTemplate.

As always, the example client and server source code is available over on GitHub.