Serving static content with custom Content-Type in Spring 5

3 min read 06-10-2024

Serving Static Content with Custom Content-Type in Spring 5

Serving static content like images, CSS files, and JavaScript is a fundamental part of many web applications. By default, Spring Boot automatically serves static content from the static or public directories. However, sometimes you need to serve files with a custom Content-Type header, which is essential for proper rendering or handling by the browser.

This article will guide you through the process of serving static content with custom Content-Type headers in your Spring 5 application.

The Problem

Imagine you have a file named my_custom_file.ext with a unique file extension .ext that represents a specific file format. By default, Spring Boot will try to serve this file with a generic Content-Type like application/octet-stream, which might not be what you want. To ensure the browser correctly handles your my_custom_file.ext, you need to specify a custom Content-Type header.

Setting up Custom Content-Type

Here's a step-by-step guide on how to serve static content with custom Content-Type in Spring 5:

1. Create a WebMvcConfigurer implementation:

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

@Configuration
public class CustomContentTypeConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry
                .addResourceHandler("/static/**")
                .addResourceLocations("classpath:/static/")
                .setCachePeriod(0)
                .resourceChain(true)
                .addResolver(new CustomContentTypeResolver());
    }
}

2. Create a custom ResourceResolver:

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.web.servlet.resource.ResourceResolver;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.List;

public class CustomContentTypeResolver implements ResourceResolver {

    private final ResourcePatternResolver resolver;

    public CustomContentTypeResolver(ResourcePatternResolver resolver) {
        this.resolver = resolver;
    }

    @Override
    public Resource resolveResource(HttpServletRequest request, String requestPath) {
        if (requestPath.endsWith(".ext")) {
            try {
                Resource resource = resolver.getResource("classpath:/static/" + requestPath);
                if (resource.exists()) {
                    return resource;
                }
            } catch (Exception e) {
                // Handle exceptions as needed
            }
        }
        return null;
    }

    @Override
    public String resolveUrlPath(String resourcePath, List<String> locations, HttpServletRequest request) {
        return resourcePath;
    }

    @Override
    public Resource resolveResource(String resourcePath, List<String> locations) {
        return null;
    }

    @Override
    public List<String> getLocations() {
        return Arrays.asList("classpath:/static/");
    }
}

Explanation:

The CustomContentTypeResolver class implements the ResourceResolver interface. This class is responsible for resolving the requested resource and setting the custom Content-Type.
The resolveResource method checks if the requested resource has the .ext extension. If it does, it tries to find the resource in the static directory and returns it if found.
The CustomContentTypeConfig class defines a ResourceHandlerRegistry that maps the /static/** path to the classpath:/static/ directory. It also uses the CustomContentTypeResolver to customize the content type for .ext files.

3. Specify the custom Content-Type in your application.properties file:

spring.resources.static-locations=classpath:/static/
spring.resources.chain.strategy.content.mappings.ext=application/custom-type

4. Serve your files:

Place your my_custom_file.ext file in the static directory. When you access the file at /static/my_custom_file.ext, the browser will receive the file with the custom Content-Type specified in your application.properties.

Additional Considerations

Resource Locations: You can modify the ResourceHandlerRegistry to map other directories or use multiple directories for static content.
Multiple Custom Content-Types: You can define multiple custom content types by adding more entries in your application.properties file.
Security: If you are dealing with sensitive files, consider implementing appropriate security measures to protect your resources.

Example:

Let's say you have a file named my_data.ext in your static directory. The browser will receive the file with the Content-Type application/custom-type because of the application.properties configuration.

By following these steps, you can easily serve static content with custom Content-Type headers in your Spring 5 application, ensuring proper rendering and handling by the browser.

Serving static content with custom Content-Type in Spring 5