Spring Boot File Upload and Download Rest API Tutorial

In this tutorial, we will learn how to upload and download a file using Spring Boot RESTful API. Uploading and downloading files are very common tasks for which developers need to write code in their applications.
Learn and master in Spring boot at Spring Boot Tutorial
We’ll first build the REST APIs for uploading and downloading files, and then test those APIs using Postman.

Let’s get started.

1. Tools and Technologies Used

  • Spring Boot - 3+
  • JDK - 17 or later
  • Spring Framework - 6+
  • Maven - 3.2+
  • IDE - Eclipse or Spring Tool Suite (STS)

2. Create and Import Spring Boot Project

There are many ways to create a Spring Boot application. The simplest way is to use Spring Initializr at http://start.spring.io/, which is an online Spring Boot application generator.
Let'specify the following details while generating the Spring Boot project using Spring Initializr:
  • Project: Select Maven
  • Java Version: 17(Default)
  • Spring Boot Version: 3.04
  • Group: net.javaguides.springboot
  • Artifact: springboot-upload-download-file-rest-api-example
  • Name: springboot-upload-download-file-rest-api-example
  • Description: springboot-upload-download-file-rest-api-example
  • Package Name: net.guides.springboot.springbootfileupload
  • Packaging: jar (This is the default value)
  • Dependencies: Web
Once, all the details are entered, then click on Generate Project button will generate a spring boot project then download it. That’s it! You may now unzip the downloaded application archive and import it into your favorite IDE.

3. Project Directory Structure

Below, the diagram shows a project structure for reference:

4. The pom.xml File

<?xml version="1.0" encoding="UTF-8"?>
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <description>Demo project for Spring Boot</description>
        <!-- lookup parent from repository -->

5. Configuring Server and File Storage Properties

Let’s configure our Spring Boot application to enable Multipart file uploads, and define the maximum file size that can be uploaded. We’ll also configure the directory into which all the uploaded files will be stored.
Open the src/main/resources/application.properties file, and add the following properties to it -
## MULTIPART (MultipartProperties)
# Enable multipart uploads
# Threshold after which files are written to disk.
# Max file size.
# Max Request Size

## File Storage Properties


6. Automatically binding properties to a POJO class

Spring Boot has an awesome feature called @ConfigurationProperties using which you can automatically bind the properties defined in the application.properties file to a POJO class.
Let’s define a POJO class called FileStorageProperties inside net.javaguides.springboot.fileuploaddownload package to bind all the file storage properties -
package net.javaguides.springboot.fileuploaddownload.property;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@ConfigurationProperties(prefix = "file")
public class FileStorageProperties {
    private String uploadDir;

    public String getUploadDir() {
        return uploadDir;

    public void setUploadDir(String uploadDir) {
        this.uploadDir = uploadDir;

7. Writing APIs for File Upload and Download

File Upload Rest API

Let’s now write the REST APIs for uploading single as well as multiple files. Create a new controller class called FileUploadController inside net.javaguides.springboot.fileuploaddownload.controller package and add the following code to it -
package net.javaguides.springboot.fileuploaddownload.controller;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import net.javaguides.springboot.fileuploaddownload.payload.Response;
import net.javaguides.springboot.fileuploaddownload.service.FileStorageService;

public class FileUploadController {

    private FileStorageService fileStorageService;

    public Response uploadFile(@RequestParam("file") MultipartFile file) {
        String fileName = fileStorageService.storeFile(file);

        String fileDownloadUri = ServletUriComponentsBuilder.fromCurrentContextPath()

        return new Response(fileName, fileDownloadUri,
            file.getContentType(), file.getSize());

    public List < Response > uploadMultipleFiles(@RequestParam("files") MultipartFile[] files) {
        return Arrays.asList(files)
            .map(file - > uploadFile(file))

File Download Rest API

Let’s now write the REST API for downloading a file. Create a new controller class called FileDownloadController inside net.javaguides.springboot.fileuploaddownload.controller package and add the following code to it -
package net.javaguides.springboot.fileuploaddownload.controller;

import java.io.IOException;

import jakarta.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import net.javaguides.springboot.fileuploaddownload.service.FileStorageService;

public class FileDownloadController {

    private static final Logger logger = LoggerFactory.getLogger(FileDownloadController.class);

    private FileStorageService fileStorageService;

    public ResponseEntity < Resource > downloadFile(@PathVariable String fileName, HttpServletRequest request) {
        // Load file as Resource
        Resource resource = fileStorageService.loadFileAsResource(fileName);

        // Try to determine file's content type
        String contentType = null;
        try {
            contentType = request.getServletContext().getMimeType(resource.getFile().getAbsolutePath());
        } catch (IOException ex) {
            logger.info("Could not determine file type.");

        // Fallback to the default content type if type could not be determined
        if (contentType == null) {
            contentType = "application/octet-stream";

        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + resource.getFilename() + "\"")


This Response class is used to return responses from the /uploadFile and /uploadMultipleFiles APIs.
Create a Response class inside net.javaguides.springboot.fileuploaddownload.payload package with the following contents -
public class Response {
    private String fileName;
    private String fileDownloadUri;
    private String fileType;
    private long size;

    public Response(String fileName, String fileDownloadUri, String fileType, long size) {
        this.fileName = fileName;
        this.fileDownloadUri = fileDownloadUri;
        this.fileType = fileType;
        this.size = size;
 // Getters and Setters (Omitted for brevity)

8. Service for Storing Files in the FileSystem and retrieving them

Let’s now write the service for storing files in the file system and retrieving them. Create a new class called FileStorageService.java inside net.javaguides.springboot.fileuploaddownload.service with the following contents -
package net.javaguides.springboot.fileuploaddownload.service;

import java.io.IOException;
import java.net.MalformedURLException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import net.javaguides.springboot.fileuploaddownload.exception.FileStorageException;
import net.javaguides.springboot.fileuploaddownload.exception.FileNotFoundException;
import net.javaguides.springboot.fileuploaddownload.property.FileStorageProperties;

public class FileStorageService {

    private final Path fileStorageLocation;

    public FileStorageService(FileStorageProperties fileStorageProperties) {
        this.fileStorageLocation = Paths.get(fileStorageProperties.getUploadDir())

        try {
        } catch (Exception ex) {
            throw new FileStorageException("Could not create the directory where the uploaded files will be stored.", ex);

    public String storeFile(MultipartFile file) {
        // Normalize file name
        String fileName = StringUtils.cleanPath(file.getOriginalFilename());

        try {
            // Check if the file's name contains invalid characters
            if (fileName.contains("..")) {
                throw new FileStorageException("Sorry! Filename contains invalid path sequence " + fileName);

            // Copy file to the target location (Replacing existing file with the same name)
            Path targetLocation = this.fileStorageLocation.resolve(fileName);
            Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);

            return fileName;
        } catch (IOException ex) {
            throw new FileStorageException("Could not store file " + fileName + ". Please try again!", ex);

    public Resource loadFileAsResource(String fileName) {
        try {
            Path filePath = this.fileStorageLocation.resolve(fileName).normalize();
            Resource resource = new UrlResource(filePath.toUri());
            if (resource.exists()) {
                return resource;
            } else {
                throw new FileNotFoundException("File not found " + fileName);
        } catch (MalformedURLException ex) {
            throw new FileNotFoundException("File not found " + fileName, ex);

9. Custom Exception Classes

The FileStorageService class throws some exceptions in case of unexpected situations. Following are the definitions of those exception classes (All the exception classes go inside the package net.javaguides.springboot.fileuploaddownload.exception).


package net.javaguides.springboot.fileuploaddownload.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

public class FileNotFoundException extends RuntimeException {

    private static final long serialVersionUID = 1 L;

    public FileNotFoundException(String message) {

    public FileNotFoundException(String message, Throwable cause) {
        super(message, cause);


package net.javaguides.springboot.fileuploaddownload.exception;

public class FileStorageException extends RuntimeException {

    private static final long serialVersionUID = 1 L;

    public FileStorageException(String message) {

    public FileStorageException(String message, Throwable cause) {
        super(message, cause);
To know more about exception handling in Spring boot then check out Spring Boot 2 Exception Handling for REST APIs
Note that, we’ve annotated the above exception class with @ResponseStatus(HttpStatus.NOT_FOUND). This ensures that Spring boot responds with a 404 Not Found status when this exception is thrown.

10. Running the Application and Testing the APIs via Postman

We’re done developing our backend APIs. Let’s run the application and test the APIs via Postman. Type the following command from the root directory of the project to run the application -
mvn spring-boot:run
Once started, the application can be accessed at http://localhost:8081

1. Upload File

2. Upload Multiple Files

3. Download the File


That's it. We learned how to upload single as well as multiple files via REST APIs written in Spring Boot. We also learned how to download files in Spring Boot.

I hope the post was helpful to you. You can download the entire code for the project that we built in this article from the GitHub repository.
Learn and master in Spring boot at Spring Boot Tutorial


  1. your guide is not up to date compared to github files... mind check that out?

  2. Thanks a lot. I really did benefited from this tutorial.
    and It's work ^^
    I've just a little problem at the download GET request,
    I always get a 403 Forbidden status (with Postman)
    If u have any idea where it can be the problem
    *nb I used exactly the same code

    1. I always get a 404 not found status (with Postman)*

    2. May be video tutorial will help to your issues.

  3. Can you please tell how can I integerate it with authentication

  4. It would have been great if there were explainatory comments in the code.Would have been even better.


Post a Comment

Leave Comment