1. Overview

When we are building some sort of content management solution, we need to solve two problems. We need a place to store the files themselves, and we need some sort of database to index them.

It’s possible to store the content of the files in the database itself, or we could store the content somewhere else and index it with the database.

In this article, we’re going to illustrate both of these methods with a basic Image Archive Application. We’ll also implement REST APIs for upload and download.

2. Use Case

Our Image Archive Application will allow us to upload and download JPEG images.

When we upload an image, the application will create a unique identifier for it. Then we can use this identifier to download it.

We’ll use a relational database, with Spring Data JPA and Hibernate.

3. Database Storage

Let’s start with our database.

3.1. Image Entity

First, let’s create our Image entity:

class Image {

    Long id;

    byte[] content;

    String name;
    // Getters and Setters

The id field is annotated with @GeneratedValue. This means the database will create a unique identifier for each record we add. By indexing the images with these values, we don’t need to worry about multiple uploads of the same image conflicting with each other.

Second, we have the Hibernate @Lob annotation. It’s how we tell JPA our intention of storing a potentially large binary.

3.2. Image Repository

Next, we need a repository to connect to the database.

We’ll use the spring JpaRepository:

interface ImageDbRepository extends JpaRepository<Image, Long> {}

Now we’re ready to save our images.  We just need a way to upload them to our application.

4. REST Controller

We will use a MultipartFile to upload our images. Uploading will return the imageId we can use to download the image later.

4.1. Image Upload

Let’s start by creating our ImageController to support upload:

class ImageController {

    ImageDbRepository imageDbRepository;

    Long uploadImage(@RequestParam MultipartFile multipartImage) throws Exception {
        Image dbImage = new Image();

        return imageDbRepository.save(dbImage)

The MultipartFile object contains the content and original name of the file. We use this to construct our Image object for storing in the database.

This controller returns the generated id as the body of its response.

4.2. Image Download

Now, let’s add a download route:

@GetMapping(value = "/image/{imageId}", produces = MediaType.IMAGE_JPEG_VALUE)
Resource downloadImage(@PathVariable Long imageId) {
    byte[] image = imageRepository.findById(imageId)
      .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND))

    return new ByteArrayResource(image);

The imageId path variable contains the id that was generated at upload. If an invalid id is provided, then we’re using ResponseStatusException to return an HTTP response code 404 (Not Found). Otherwise, we’re wrapping the stored file bytes in a ByteArrayResource which allows them to be downloaded.

5. Database Image Archive Test

Now we’re ready to test our Image Archive.

First, let’s build our application:

mvn package

Second, let’s start it up:

java -jar target/image-archive-0.0.1-SNAPSHOT.jar

5.1. Image Upload Test

After our application is running, we’ll use the curl command-line tool to upload our image:

curl -H "Content-Type: multipart/form-data" \
  -F "[email protected]" http://localhost:8080/image

As the upload service response is the imageId, and this is our first request, the output will be:


5.2. Image Download Test

Then we can download our image:

curl -v http://localhost:8080/image/1 -o image.jpeg

The -o image.jpeg option will create a file named image.jpeg and store the response content in it:

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0*   Trying ::1...
* Connected to localhost (::1) port 8080 (#0)
> GET /image/1 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.54.0
> Accept: */*
< HTTP/1.1 200 
< Accept-Ranges: bytes
< Content-Type: image/jpeg
< Content-Length: 9291

We got an HTTP/1.1 200, which means that our download was successful.

We could also try downloading the image in our browser by hitting http://localhost:8080/image/1.

6. Separate Content and Location

So far, we’re capable of uploading and downloading images within a database.

Another good option is uploading the file content to a different location. Then we save only its filesystem location in the DB.

For that we’ll need to add a new field to our Image entity:

String location;

This will contain the logical path to the file in some external storage. In our case, it will be the path on our server’s filesystem. 

However, we can equally apply this idea to different Stores. For example, we could use cloud storage – Google Cloud Storage or Amazon S3. The location could also use a URI format, for example, s3://somebucket/path/to/file.

Our upload service, rather than writing the bytes of the file to the database, will store the file in the appropriate service – in this case, the filesystem – and will then put the location of the file into the database.

7. Filesystem Storage

Let’s add the capability to store the images in the filesystem to our solution.

7.1. Saving in the Filesystem

First, we need to save our images to the filesystem:

class FileSystemRepository {

    String RESOURCES_DIR = FileSystemRepository.class.getResource("/")

    String save(byte[] content, String imageName) throws Exception {
        Path newFile = Paths.get(RESOURCES_DIR + new Date().getTime() + "-" + imageName);

        Files.write(newFile, content);

        return newFile.toAbsolutePath()

One important note – we need to make sure that each of our images has a unique location defined server-side at upload time. Otherwise, our uploads may overwrite each other.

The same rule would apply to any cloud storage, where we should create unique keys. In this example, we’ll add the current date in milliseconds format to the image name:


7.2. Retrieving From Filesystem

Now let’s implement the code to fetch our image from the filesystem:

FileSystemResource findInFileSystem(String location) {
    try {
        return new FileSystemResource(Paths.get(location));
    } catch (Exception e) {
        // Handle access or file not found problems.
        throw new RuntimeException();

Here we’re looking for the image using its location. Then we return a FileSystemResource.

Also, we’re catching any exception that may happen while reading our file. We might also wish to throw exceptions with particular HTTP statuses.

7.3. Data Streaming and Spring’s Resource

Our findInFileSystem method returns a FileSystemResource, an implementation of Spring’s Resource interface.

It will start reading our file only when we use it. In our case, it’ll be when sending it to the client via the RestController. Also, it’ll stream the file content from the filesystem to the user, saving us from loading all the bytes into memory.

This approach is a good general solution for streaming files to a client. If we’re using cloud storage instead of the filesystem, we can replace the FileSystemResource for another resource’s implementation, like the InputStreamResource or ByteArrayResource.

8. Connecting the File Content and Location

Now that we have our FileSystemRepository, we need to link it with our ImageDbRepository.

8.1. Saving in the Database and Filesystem

Let’s create a FileLocationService, starting with our save flow:

class FileLocationService {

    FileSystemRepository fileSystemRepository;
    ImageDbRepository imageDbRepository;

    Long save(byte[] bytes, String imageName) throws Exception {
        String location = fileSystemRepository.save(bytes, imageName);

        return imageDbRepository.save(new Image(imageName, location))

First, we save the image in the filesystem. Then we save the record containing its location in the database.

8.2. Retrieving From Database and Filesystem

Now, let’s create a method to find our image using its id:

FileSystemResource find(Long imageId) {
    Image image = imageDbRepository.findById(imageId)
      .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));

    return fileSystemRepository.findInFileSystem(image.getLocation());

First, we look for our image in the database. Then we get its location and fetch it from the filesystem.

If we don’t find the imageId in the database, we’re using ResponseStatusException to return an HTTP Not Found response.

9. Filesystem Upload and Download

Finally, let’s create the FileSystemImageController:

class FileSystemImageController {

    FileLocationService fileLocationService;

    Long uploadImage(@RequestParam MultipartFile image) throws Exception {
        return fileLocationService.save(image.getBytes(), image.getOriginalFilename());

    @GetMapping(value = "/image/{imageId}", produces = MediaType.IMAGE_JPEG_VALUE)
    FileSystemResource downloadImage(@PathVariable Long imageId) throws Exception {
        return fileLocationService.find(imageId);

First, we made our new path start with “/file-system“.

Then we created the upload route similar to that in our ImageController, but without the dbImage object.

Lastly, we have our download route, which uses the FileLocationService to find the image and returns the FileSystemResource as the HTTP response.

10. Filesystem Image Archive Test

Now, we can test our filesystem version the same way we did with our database version, though the paths now start with “file-system“:

curl -H "Content-Type: multipart/form-data" \
  -F "[email protected]" http://localhost:8080/file-system/image


And then we download:

curl -v http://localhost:8080/file-system/image/1 -o image.jpeg

11. Conclusion

In this article, we learned how to save file information in a database, with the file content either in the same row or in an external location.

We also built and tested a REST API using multipart upload, and we provided a download feature using Resource to allow streaming the file to the caller.

As always, the code samples can be found over on GitHub.

Course – LSD (cat=Persistence)

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

res – Persistence (eBook) (cat=Persistence)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.