In this article, we will present how to create a Spring Boot application that uploads a file to the PostgreSQL database. The server application based on REST architecture will use Spring Data JPA for executing queries on the database and MultipartFile interface for handling multi-part requests.
2. Technology
Spring Boot application will use the following technology stack:
Java 8
Spring Boot 2
Spring Data JPA
PostgreSQL
Maven 3.6.1
3. Project structure
Project contains:
FileEntity class that is a data model entity object related to a table in the PostgreSQL database,
FileResponse is a POJO object used to listing files,
FileRepository is a Spring Data repository used to save and retrieve files to/from the database,
FileService is our service that will be calling methods from FileRepository,
FilesController used to handle HTTP requests like POST (for uploading files), GET (for listing and downloading files),
RestExceptionHandler class handles exceptions that could occur when processing requests,
application.properties is a Spring Boot configuration file used to setup database connection and set file upload size limits,
pom.xml for project dependencies.
4. REST API for uploading/downloading files
The Spring Boot application will provide a fully REST-ful API for:
uploading files to PostgreSQL database,
downloading files from the database,
retrieving a list of uploaded files.
Spring Boot application will provide the following API endpoints:
URL
Method
Action
/files
GET
Get list of uploaded files
/files
POST
Upload a single file
/files/{uuid}
GET
Download uploaded file
Files will be downloaded directly to the database with informations like:
Entity objects correspond to database tables. In our project we created a FileEntity class that will be related to the FILES table:
Two fields were marked with special annotations:
id - @Id, @GeneratedValue(generator = "uuid"), @GenericGenerator(name = "uuid", strategy = "uuid2") - this field will have auto-generated UUID,
data - @Lob special datatype that informs about storing large objects in the database.
Second POJO class used in model layer is FileResponse:
This object will be used to present a list of files with detailed information about them, such as name, content type, size.
7. Implement data access layer
In our data access layer, we have an interface FileRepository that extends JpaRepository. Thanks to this, we have access to crud methods like save(...), getById(...), delete(...) etc.
8. Create service for managing files
The FileService class will be responsible for:
saving uploaded files (transforming MultipartFile object into FileEntity),
uploading a single file by provided id,
return a list of uploaded files.
In most cases FileService just calls methods from FileRepository but it is a good place for future business logic.
9. Create a REST controller for handing HTTP requests
The FilesController will be responsible for handling HTTP requests.
This class has been marked with the following annotations:
@RestController - annotation is used to treat this class as a REST controller,
@RequestMapping - create a base endpoint to /files URI.
Other annotations used in this class like @GetMapping, @PostMapping and @DeleteMapping - are for mapping HTTP GET, POST and DELETE requests with specific class methods:
HTTP Method
Endpoint
Method
POST
/files
upload(...)
GET
/files
list(...)
GET
/files/{id}
getFile(...)
10. Configure JPA, Hibernate and file size upload limits
In the application.properties file we created a several entries:
We used the following properties:
spring.datasource.url - to define a datasource,
spring.datasource.username - database username,
spring.datasource.password - database password,
spring.jpa.hibernate.ddl-auto can be:
none - no change is made to the database structure,
update - Hibernate will change the database according to the given entity structures,
create - this will creates the database every time on server start,
create-drop - creates the database and drops it when SessionFactory closes.
spring.servlet.multipart.max-file-size - maximum file size for each request.
spring.servlet.multipart.max-request-size - maximum size for a multipart requests.
11. Create exception handler
The class annotated with @ControllerAdvice is responsible for handling exceptions that may occur during the uploading files process:
We handle just MaxUploadSizeExceededException but this could be extended to some other exceptions as well.
12. Main Spring Boot starting server class
The main Spring Boot application class that starts the server has the following structure:
13. Testing Application API
To run the Spring Boot server use mvn spring-boot:run command or find the generated jar in the /target folder and type java -jar upload-file-to-postgresql-0.0.1-SNAPSHOT.jar.
When everything is correctly configured You should see information about the started server:
Also in the database, there should be a new table called FILES with the following structure:
We will use Postman to make some API requests.
13.1. First, let's upload some file
In the FILES table a new record appeared:
13.2. Now check a list of uploaded files
13.3. Finally, download the upload file using a provided URL
14. Conclusion
In this tutorial, we presented step by step how to create a Spring Boot application that will upload files to the PostgreSQL database.
As usual, the code used in this tutorial is available in our GitHub repository.
{{ 'Comments (%count%)' | trans {count:count} }}
{{ 'Comments are closed.' | trans }}