← All Backend Guides

Java Spring Boot

Handle MultipleUpload file uploads with Spring Boot using MultipartFile and a REST controller. This guide covers both standard multipart uploads and chunked uploads.

Application Properties

Configure file upload limits in application.properties.

# application.properties
spring.servlet.multipart.max-file-size=200MB
spring.servlet.multipart.max-request-size=200MB
upload.directory=./uploads

CORS Configuration

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
            .allowedOrigins("*")
            .allowedMethods("POST", "OPTIONS")
            .allowedHeaders(
                "Content-Type", "X-Upload-Id", "X-Chunk-Index",
                "X-Chunk-Count", "X-File-Name", "X-File-Size"
            );
    }
}

Multipart Form Upload

The controller receives the file through Spring's MultipartFile interface and saves it with a unique GUID.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.nio.file.*;
import java.util.*;

@RestController
@RequestMapping("/api")
public class UploadController {

    @Value("${upload.directory:./uploads}")
    private String uploadDir;

    @PostMapping("/upload")
    public ResponseEntity<Map<String, Object>> upload(
            @RequestParam("file") MultipartFile file) throws IOException {

        Path uploadPath = Paths.get(uploadDir);
        Files.createDirectories(uploadPath);

        String fileGuid = UUID.randomUUID().toString();
        String originalName = file.getOriginalFilename();
        String ext = "";
        if (originalName != null && originalName.contains(".")) {
            ext = originalName.substring(originalName.lastIndexOf("."));
        }

        Path destPath = uploadPath.resolve(fileGuid + ext);
        file.transferTo(destPath.toFile());

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("success", true);
        response.put("fileGuid", fileGuid);
        response.put("fileName", originalName);
        response.put("fileSize", file.getSize());

        return ResponseEntity.ok(response);
    }
}

Chunked Upload

Each chunk arrives as a raw body with custom headers. Store chunks in a temporary directory and assemble the final file once all chunks have arrived.

// Add to UploadController
@PostMapping("/upload-chunk")
public ResponseEntity<Map<String, Object>> uploadChunk(
        @RequestHeader("X-Upload-Id") String uploadId,
        @RequestHeader("X-Chunk-Index") int chunkIndex,
        @RequestHeader("X-Chunk-Count") int chunkCount,
        @RequestHeader("X-File-Name") String fileName,
        @RequestHeader("X-File-Size") long fileSize,
        @RequestBody byte[] chunkData) throws IOException {

    Path chunkDir = Paths.get(uploadDir, "chunks", uploadId);
    Files.createDirectories(chunkDir);

    // Save this chunk
    Path chunkPath = chunkDir.resolve("chunk_" + chunkIndex);
    Files.write(chunkPath, chunkData);

    // Count received chunks
    long received;
    try (var stream = Files.list(chunkDir)) {
        received = stream.count();
    }

    if (received == chunkCount) {
        // Assemble final file
        String fileGuid = UUID.randomUUID().toString();
        String ext = "";
        if (fileName.contains(".")) {
            ext = fileName.substring(fileName.lastIndexOf("."));
        }

        Path uploadPath = Paths.get(uploadDir);
        Files.createDirectories(uploadPath);
        Path finalPath = uploadPath.resolve(fileGuid + ext);

        try (OutputStream output = Files.newOutputStream(finalPath)) {
            for (int i = 0; i < chunkCount; i++) {
                Path cp = chunkDir.resolve("chunk_" + i);
                byte[] data = Files.readAllBytes(cp);
                output.write(data);
            }
        }

        // Clean up chunks
        try (var stream = Files.list(chunkDir)) {
            stream.forEach(p -> {
                try { Files.delete(p); } catch (IOException ignored) {}
            });
        }
        Files.delete(chunkDir);

        Map<String, Object> response = new LinkedHashMap<>();
        response.put("success", true);
        response.put("fileGuid", fileGuid);
        response.put("fileName", fileName);
        response.put("fileSize", fileSize);
        return ResponseEntity.ok(response);
    }

    Map<String, Object> response = new LinkedHashMap<>();
    response.put("success", true);
    response.put("chunksReceived", received);
    return ResponseEntity.ok(response);
}

Expected JSON Response

Both endpoints must return this JSON structure on successful upload completion.

{
  "success": true,
  "fileGuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "fileName": "photo.jpg",
  "fileSize": 204800
}

Client-Side JavaScript

Initialize MultipleUpload on the client, pointing to your Spring Boot API endpoints.

<link rel="stylesheet" href="multipleupload.css" />
<div id="uploader"></div>
<script src="multipleupload.js"></script>
<script>
  var uploader = new MultipleUpload("#uploader", {
    uploadUrl: "/api/upload",
    chunkUploadUrl: "/api/upload-chunk",
    chunkSize: 2 * 1024 * 1024, // 2 MB chunks
    onFileUploaded: function (file, response) {
      console.log("Uploaded:", response.fileName, response.fileGuid);
    }
  });
</script>