Building a Secure File Upload Feature for Albums in Spring Boot

Introduction ……………………………………………………………………………………………….. 1
Setting Up the Spring Boot Project ………………………………………………………………. 3
Configuring Security for File Uploads …………………………………………………………… 5
Managing Static Resources and File Paths ……………………………………………………….. 8
Designing the Photo Model ……………………………………………………………………………. 12
Creating the Album Controller …………………………………………………………………….. 16
Implementing the Photo Service and Repository ………………………………………………… 20
Handling File Uploads and Validations ………………………………………………………………. 24
Enhancing Security and Error Handling ……………………………………………………………… 28
Testing the File Upload Feature ………………………………………………………………………… 32
Conclusion …………………………………………………………………………………………………….. 36

Introduction

In today’s digital landscape, the ability to upload and manage files is a fundamental feature for many applications, especially those centered around media management like photo albums. Implementing a secure and efficient file upload system ensures that users can seamlessly add content while safeguarding the application’s integrity.

This eBook delves into building a secure file upload feature for albums using Spring Boot. We’ll explore essential configurations, manage static resources, design robust models, and implement controllers and services that handle file operations effectively. By the end of this guide, you’ll have a comprehensive understanding of creating a feature-rich, secure, and user-friendly file upload system.

Importance of Secure File Uploads

User Experience: Smooth file upload processes enhance user satisfaction.
Security: Proper configurations prevent unauthorized access and potential vulnerabilities.
Scalability: Efficient file management supports application growth.

Pros and Cons

Pros	Cons
Enhanced user engagement	Requires meticulous security handling
Facilitates media management	Potential for increased storage needs
Scalable with proper architecture	Complexity in implementation

When and Where to Use

Photo Gallery Applications: For managing user-uploaded images.
Content Management Systems: To handle various media files.
Social Media Platforms: Facilitating user interactions through media sharing.

Setting Up the Spring Boot Project

Before diving into the file upload feature, setting up a robust Spring Boot project is crucial.

Prerequisites

Java Development Kit (JDK): Ensure you have JDK 8 or higher installed.
Maven: For project management and dependency handling.
Integrated Development Environment (IDE): IntelliJ IDEA, Eclipse, or VS Code.
Database: H2, MySQL, or any preferred relational database.

Initializing the Project

Create a New Spring Boot Project:
- Use Spring Initializr to generate the project structure.
- Include dependencies:
  - Spring Web
  - Spring Security
  - Spring Data JPA
  - H2 Database (for development)
  - Lombok (optional for boilerplate code reduction)

Project Structure Overview:

spring-file-upload/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/fileupload/
│   │   │       ├── config/
│   │   │       ├── controller/
│   │   │       ├── model/
│   │   │       ├── repository/
│   │   │       ├── service/
│   │   │       └── SpringFileUploadApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   └── test/
└── pom.xml

spring-file-upload/

├── src/

│ ├── main/

│ │ ├── java/

│ │ │ └── com/example/fileupload/

│ │ │ ├── config/

│ │ │ ├── controller/

│ │ │ ├── model/

│ │ │ ├── repository/

│ │ │ ├── service/

│ │ │ └── SpringFileUploadApplication.java

│ │ └── resources/

│ │ ├── application.properties

│ │ └── static/

│ └── test/

└── pom.xml

Configuring pom.xml:

Ensure all necessary dependencies are included.

&lt;dependencies&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
        &lt;artifactId&gt;spring-boot-starter-data-jpa&lt;/artifactId&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;com.h2database&lt;/groupId&gt;
        &lt;artifactId&gt;h2&lt;/artifactId&gt;
        &lt;scope&gt;runtime&lt;/scope&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;org.projectlombok&lt;/groupId&gt;
        &lt;artifactId&gt;lombok&lt;/artifactId&gt;
        &lt;optional&gt;true&lt;/optional&gt;
    &lt;/dependency&gt;
    &lt;dependency&gt;
        &lt;groupId&gt;io.springfox&lt;/groupId&gt;
        &lt;artifactId&gt;springfox-boot-starter&lt;/artifactId&gt;
        &lt;version&gt;3.0.0&lt;/version&gt;
    &lt;/dependency&gt;
    &lt;!-- Add other dependencies as needed --&gt;
&lt;/dependencies&gt;

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-security</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<groupId>com.h2database</groupId>

<scope>runtime</scope>

</dependency>

<groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId>

</dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-boot-starter</artifactId>

</dependency>

</dependencies>

Running the Application

Execute the following Maven command to build and run the project:

mvn spring-boot:run

1	mvn spring-boot:run

Upon successful startup, access the Swagger documentation at http://localhost:8080/swagger-ui/ to explore available APIs.

Configuring Security for File Uploads

Security is paramount when handling file uploads to protect against unauthorized access and potential vulnerabilities.

Simple Security Configuration

Initially, permit all requests without authentication for development purposes.

// SecurityConfig.java
package com.example.fileupload.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .anyRequest().permitAll();
    }
}

// SecurityConfig.java

package com.example.fileupload.config;

import org.springframework.context.annotation.Configuration;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration

@EnableWebSecurity

public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Override

protected void configure(HttpSecurity http) throws Exception {

http

.csrf().disable()

.authorizeRequests()

.anyRequest().permitAll();

}

Enhancing Security

For production, implement robust security measures:

JWT Authentication: Secure endpoints using JSON Web Tokens.
Role-Based Access Control (RBAC): Restrict access based on user roles.
Input Validation: Validate uploaded files to prevent malicious content.

Refer to the Spring Security Documentation for advanced configurations.

Managing Static Resources and File Paths

To handle file uploads efficiently, configure static resource paths and manage file storage.

Configuring Static Paths in `application.properties`

Define minimum upload sizes and static file access paths.

# application.properties

# File upload settings
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

# Static resource settings
spring.web.resources.static-locations=classpath:/static/

# application.properties

# File upload settings

spring.servlet.multipart.max-file-size=10MB

spring.servlet.multipart.max-request-size=10MB

# Static resource settings

spring.web.resources.static-locations=classpath:/static/

Serving Static Files

Enable direct access to uploaded files by configuring resource handlers.

// WebConfig.java
package com.example.fileupload.config;

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

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry
            .addResourceHandler("/static/uploads/**")
            .addResourceLocations("file:src/main/resources/static/uploads/");
    }
}

// WebConfig.java

package com.example.fileupload.config;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.config.annotation.EnableWebMvc;

import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration

@EnableWebMvc

public class WebConfig implements WebMvcConfigurer {

@Override

public void addResourceHandlers(ResourceHandlerRegistry registry) {

registry

.addResourceHandler("/static/uploads/**")

.addResourceLocations("file:src/main/resources/static/uploads/");

}

With this configuration, files placed in src/main/resources/static/uploads/ can be accessed via URLs like http://localhost:8080/static/uploads/{filename}.

Designing the Photo Model

The Photo model represents the uploaded images and their associated metadata.

Photo.java

// Photo.java
package com.example.fileupload.model;

import javax.persistence.*;

@Entity
public class Photo {
    
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
    
    private String name;
    
    private String description;
    
    private String originalFileName;
    
    private String fileName;
    
    @ManyToOne
    @JoinColumn(name = "album_id", nullable = false)
    private Album album;

    // Getters and Setters
    // toString(), Constructors
}

// Photo.java

package com.example.fileupload.model;

import javax.persistence.*;

@Entity

public class Photo {

@Id

@GeneratedValue(strategy = GenerationType.SEQUENCE)

private Long id;

private String name;

private String description;

private String originalFileName;

private String fileName;

@ManyToOne

@JoinColumn(name = "album_id", nullable = false)

private Album album;

// Getters and Setters

// toString(), Constructors

}

Key Components

id: Unique identifier for each photo.
name: User-defined name for the photo.
description: Description or tags associated with the photo.
originalFileName: Original name of the uploaded file.
fileName: System-generated name to prevent conflicts.
album: Association to the Album entity.

Creating the Album Controller

The AlbumController manages album-related operations, including file uploads.

AlbumController.java

// AlbumController.java
package com.example.fileupload.controller;

import com.example.fileupload.model.Photo;
import com.example.fileupload.service.PhotoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;

@RestController
@RequestMapping("/albums")
public class AlbumController {

    @Autowired
    private PhotoService photoService;

    @PostMapping("/add")
    public ResponseEntity<List<String>> uploadPhotos(
            @RequestParam("albumId") Long albumId,
            @RequestParam("files") MultipartFile[] files) {
        
        return ResponseEntity.ok(photoService.savePhotos(albumId, files));
    }

    // Additional endpoints
}

// AlbumController.java

package com.example.fileupload.controller;

import com.example.fileupload.model.Photo;

import com.example.fileupload.service.PhotoService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController

@RequestMapping("/albums")

public class AlbumController {

@Autowired

private PhotoService photoService;

@PostMapping("/add")

public ResponseEntity<List<String>> uploadPhotos(

@RequestParam("albumId") Long albumId,

@RequestParam("files") MultipartFile[] files) {

return ResponseEntity.ok(photoService.savePhotos(albumId, files));

}

// Additional endpoints

}

Uploading Photos

The /albums/add endpoint accepts multiple files and saves them to the specified album.

Implementing the Photo Service and Repository

Service and repository layers abstract the business logic and data access respectively.

PhotoRepository.java

// PhotoRepository.java
package com.example.fileupload.repository;

import com.example.fileupload.model.Photo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface PhotoRepository extends JpaRepository<Photo, Long> {
    // Additional query methods if needed
}

// PhotoRepository.java

package com.example.fileupload.repository;

import com.example.fileupload.model.Photo;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

@Repository

public interface PhotoRepository extends JpaRepository<Photo, Long> {

// Additional query methods if needed

}

PhotoService.java

// PhotoService.java
package com.example.fileupload.service;

import com.example.fileupload.model.Photo;
import com.example.fileupload.repository.PhotoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.List;

@Service
public class PhotoService {

    @Autowired
    private PhotoRepository photoRepository;

    public List<String> savePhotos(Long albumId, MultipartFile[] files) {
        List<String> fileNames = new ArrayList<>();
        List<String> fileNamesWithError = new ArrayList<>();

        for (MultipartFile file : files) {
            try {
                // Validate file type and size
                if (!isImage(file)) {
                    throw new Exception("Invalid file type");
                }

                // Generate unique file name
                String fileName = generateFileName(file.getOriginalFilename());

                // Save file to the server
                file.transferTo(new java.io.File("src/main/resources/static/uploads/" + albumId + "/" + fileName));

                // Save file metadata to the database
                Photo photo = new Photo();
                photo.setName(fileName);
                photo.setOriginalFileName(file.getOriginalFilename());
                photo.setFileName(fileName);
                // Set album reference
                // photo.setAlbum(albumService.findById(albumId));
                photoRepository.save(photo);

                fileNames.add(fileName);
            } catch (Exception e) {
                fileNamesWithError.add(file.getOriginalFilename());
            }
        }

        // Return successful uploads
        return fileNames.isEmpty() ? fileNamesWithError : fileNames;
    }

    private boolean isImage(MultipartFile file) {
        String contentType = file.getContentType();
        return contentType.equals("image/jpeg") || 
               contentType.equals("image/png") || 
               contentType.equals("image/gif");
    }

    private String generateFileName(String originalFileName) {
        return System.currentTimeMillis() + "_" + originalFileName;
    }
}

// PhotoService.java

package com.example.fileupload.service;

import com.example.fileupload.model.Photo;

import com.example.fileupload.repository.PhotoRepository;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;

import java.util.List;

@Service

public class PhotoService {

@Autowired

private PhotoRepository photoRepository;

public List<String> savePhotos(Long albumId, MultipartFile[] files) {

List<String> fileNames = new ArrayList<>();

List<String> fileNamesWithError = new ArrayList<>();

for (MultipartFile file : files) {

try {

// Validate file type and size

if (!isImage(file)) {

throw new Exception("Invalid file type");

}

// Generate unique file name

String fileName = generateFileName(file.getOriginalFilename());

// Save file to the server

file.transferTo(new java.io.File("src/main/resources/static/uploads/" + albumId + "/" + fileName));

// Save file metadata to the database

Photo photo = new Photo();

photo.setName(fileName);

photo.setOriginalFileName(file.getOriginalFilename());

photo.setFileName(fileName);

// Set album reference

// photo.setAlbum(albumService.findById(albumId));

photoRepository.save(photo);

fileNames.add(fileName);

} catch (Exception e) {

fileNamesWithError.add(file.getOriginalFilename());

}

// Return successful uploads

return fileNames.isEmpty() ? fileNamesWithError : fileNames;

}

private boolean isImage(MultipartFile file) {

String contentType = file.getContentType();

return contentType.equals("image/jpeg") ||

contentType.equals("image/png") ||

contentType.equals("image/gif");

}

private String generateFileName(String originalFileName) {

return System.currentTimeMillis() + "_" + originalFileName;

}

Explanation

savePhotos: Processes each uploaded file, validates it, saves it to the server, and records its metadata in the database.
isImage: Validates the file type to ensure only images are uploaded.
generateFileName: Generates a unique file name to prevent overwriting existing files.

Handling File Uploads and Validations

Ensuring that only valid files are uploaded protects the application from malicious content.

Validating File Types and Sizes

In the PhotoService, the isImage method checks the MIME type of the uploaded files.

private boolean isImage(MultipartFile file) {
    String contentType = file.getContentType();
    return contentType.equals("image/jpeg") || 
           contentType.equals("image/png") || 
           contentType.equals("image/gif");
}

private boolean isImage(MultipartFile file) {

String contentType = file.getContentType();

return contentType.equals("image/jpeg") ||

contentType.equals("image/png") ||

contentType.equals("image/gif");

}

Handling File Storage

Uploaded files are stored in a structured directory based on the album ID.

String filePath = "src/main/resources/static/uploads/" + albumId + "/" + fileName;
file.transferTo(new java.io.File(filePath));

1 2	String filePath = "src/main/resources/static/uploads/" + albumId + "/" + fileName; file.transferTo(new java.io.File(filePath));

Ensure that the uploads directory exists and has appropriate permissions.

Error Handling

Files that fail validation are tracked and reported back to the user.

catch (Exception e) {
    fileNamesWithError.add(file.getOriginalFilename());
}

catch (Exception e) {

fileNamesWithError.add(file.getOriginalFilename());

}

Enhancing Security and Error Handling

Beyond initial configurations, implementing comprehensive security measures is essential.

Restricting Access to Uploaded Files

Ensure that only authenticated users can access certain files.

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .antMatchers("/albums/**").authenticated()
        .anyRequest().permitAll();
}

@Override

protected void configure(HttpSecurity http) throws Exception {

http

.csrf().disable()

.authorizeRequests()

.antMatchers("/albums/**").authenticated()

.anyRequest().permitAll();

}

Implementing JWT Authentication

Secure APIs with JWT tokens to authenticate requests.

Add JWT Dependencies:

&lt;dependency&gt;
    &lt;groupId&gt;io.jsonwebtoken&lt;/groupId&gt;
    &lt;artifactId&gt;jjwt&lt;/artifactId&gt;
    &lt;version&gt;0.9.1&lt;/version&gt;
&lt;/dependency&gt;

<groupId>io.jsonwebtoken</groupId>

</dependency>

Generate and Validate Tokens:
Implement utility classes to handle JWT creation and validation.
Protect Endpoints:
Use JWT filters to secure critical endpoints.

Comprehensive Error Handling

Provide meaningful error messages and handle exceptions gracefully.

// GlobalExceptionHandler.java
package com.example.fileupload.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.Date;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;ErrorDetails&gt; handleGlobalException(Exception ex) {
        ErrorDetails error = new ErrorDetails(new Date(), ex.getMessage(), "File Upload Error");
        return new ResponseEntity&lt;&gt;(error, HttpStatus.BAD_REQUEST);
    }

    // Additional exception handlers
}

// GlobalExceptionHandler.java

package com.example.fileupload.exception;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.ControllerAdvice;

import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.Date;

@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(Exception.class)

public ResponseEntity<ErrorDetails> handleGlobalException(Exception ex) {

ErrorDetails error = new ErrorDetails(new Date(), ex.getMessage(), "File Upload Error");

return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);

}

// Additional exception handlers

}

Testing the File Upload Feature

Thorough testing ensures reliability and robustness of the file upload system.

Unit Testing with JUnit

Write unit tests for service methods to validate functionality.

// PhotoServiceTest.java
package com.example.fileupload.service;

import com.example.fileupload.model.Photo;
import com.example.fileupload.repository.PhotoRepository;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

class PhotoServiceTest {

    @Mock
    private PhotoRepository photoRepository;

    @InjectMocks
    private PhotoService photoService;

    @Test
    void testSavePhotos() {
        // Mock MultipartFile array
        MultipartFile[] files = new MultipartFile[2];
        // Initialize mock files

        // Call savePhotos
        List&lt;String&gt; result = photoService.savePhotos(1L, files);

        // Verify interactions and assert results
    }
}

// PhotoServiceTest.java

package com.example.fileupload.service;

import com.example.fileupload.model.Photo;

import com.example.fileupload.repository.PhotoRepository;

import org.junit.jupiter.api.Test;

import org.mockito.InjectMocks;

import org.mockito.Mock;

import org.springframework.web.multipart.MultipartFile;

import java.util.List;

import static org.mockito.Mockito.*;

import static org.junit.jupiter.api.Assertions.*;

class PhotoServiceTest {

@Mock

private PhotoRepository photoRepository;

@InjectMocks

private PhotoService photoService;

@Test

void testSavePhotos() {

// Mock MultipartFile array

MultipartFile[] files = new MultipartFile[2];

// Initialize mock files

// Call savePhotos

List<String> result = photoService.savePhotos(1L, files);

// Verify interactions and assert results

}

Integration Testing

Test the entire upload flow from controller to repository.

Initialize Test Database: Use H2 for in-memory testing.
Mock Security Context: Authenticate requests during tests.
Verify File Storage: Ensure files are correctly saved to the designated directories.
Check Database Entries: Validate that photo metadata is accurately recorded.

Conclusion

Implementing a secure file upload feature for albums in Spring Boot involves meticulous planning and execution. From configuring security settings to designing robust models and handling file validations, each step contributes to building a reliable and user-friendly system. By following this guide, you’ve established a foundational framework that not only caters to current requirements but also scales with future enhancements.

Key Takeaways

Security Configurations: Essential to protect against unauthorized access and vulnerabilities.
Structured File Management: Organizing uploaded files systematically facilitates easy access and maintenance.
Robust Error Handling: Enhances user experience by providing clear feedback and maintaining application stability.
Comprehensive Testing: Ensures the reliability and robustness of the file upload feature.

Embrace these practices to elevate your Spring Boot applications, ensuring they are both secure and efficient in handling user-generated content.

Note: This article is AI generated.

S04L06 – Build files upload for album continues

Building a Secure File Upload Feature for Albums in Spring Boot

Table of Contents

Introduction

Importance of Secure File Uploads

Pros and Cons

When and Where to Use

Setting Up the Spring Boot Project

Prerequisites

Initializing the Project

Running the Application

Configuring Security for File Uploads

Simple Security Configuration

Enhancing Security

Managing Static Resources and File Paths

Configuring Static Paths in `application.properties`

Serving Static Files

Designing the Photo Model

Photo.java

Key Components

Creating the Album Controller

AlbumController.java

Uploading Photos

Implementing the Photo Service and Repository

PhotoRepository.java

PhotoService.java

Explanation

Handling File Uploads and Validations

Validating File Types and Sizes

Handling File Storage

Error Handling

Enhancing Security and Error Handling

Restricting Access to Uploaded Files

Implementing JWT Authentication

Comprehensive Error Handling

Testing the File Upload Feature

Unit Testing with JUnit

Integration Testing

Conclusion

Key Takeaways

Building a Secure File Upload Feature for Albums in Spring Boot

Table of Contents

Introduction

Importance of Secure File Uploads

Pros and Cons

When and Where to Use

Setting Up the Spring Boot Project

Prerequisites

Initializing the Project

Running the Application

Configuring Security for File Uploads

Simple Security Configuration

Enhancing Security

Managing Static Resources and File Paths

Configuring Static Paths in application.properties

Serving Static Files

Designing the Photo Model

Photo.java

Key Components

Creating the Album Controller

AlbumController.java

Uploading Photos

Implementing the Photo Service and Repository

PhotoRepository.java

PhotoService.java

Explanation

Handling File Uploads and Validations

Validating File Types and Sizes

Handling File Storage

Error Handling

Enhancing Security and Error Handling

Restricting Access to Uploaded Files

Implementing JWT Authentication

Comprehensive Error Handling

Testing the File Upload Feature

Unit Testing with JUnit

Integration Testing

Conclusion

Key Takeaways

Configuring Static Paths in `application.properties`