How to handle static content in Spring MVC

In the vast landscape of web development, delivering a seamless and high-performing user experience often hinges on the efficient handling of static assets. These include everything from cascading style sheets (CSS) and JavaScript files to images, fonts, and videos. While dynamic content is the heart of a Spring MVC application, the way you manage and serve your static resources significantly impacts loading times, responsiveness, and overall user satisfaction. Neglecting proper configuration can lead to broken layouts, slow interactions, or even security vulnerabilities. This comprehensive guide will delve into the intricacies of how to handle static content in Spring MVC, providing detailed strategies, best practices, and configuration examples to ensure your application performs optimally and securely, covering both traditional Spring MVC setups and Spring Boot simplifications.

Understanding Static Resources in Spring MVC

Static resources are files that do not change based on user input or server-side processing; they are served directly to the client’s browser as-is. In a typical web application, these files constitute a significant portion of the data transferred. Historically, web servers like Apache HTTP Server or Nginx were primarily responsible for serving these assets due to their efficiency. However, modern application servers and frameworks like Spring MVC also need robust mechanisms to manage them. The default behavior of Spring’s DispatcherServlet is to handle all incoming requests, attempting to map them to controllers. Without explicit configuration, this means your CSS, JavaScript, and image requests might incorrectly be routed through the servlet, leading to 404 errors or inefficient processing.

Properly handling static content involves telling the DispatcherServlet to ignore certain URL patterns and instead delegate them to a default servlet or a dedicated resource handler. This approach offloads the burden of serving static files from your application’s business logic, allowing the application server or a specialized resource handler to serve them directly and efficiently. This separation of concerns is crucial for performance, especially when dealing with high traffic volumes. It ensures that your application’s valuable threads are reserved for processing dynamic requests, not for serving unchanging files.

According to a study by Google, the probability of bounce increases by 32% as page load time goes from 1 second to 3 seconds. This highlights the critical importance of optimizing static resource delivery. Effective static resource management is not merely a technical detail; it’s a fundamental aspect of delivering a fast, reliable, and engaging web experience.

Configuring Resource Handlers in Spring MVC

Spring MVC offers robust mechanisms to declare static resource locations and mappings, ensuring they are served directly without passing through the DispatcherServlet’s controller mapping process. The most common and recommended way to achieve this is by using a dedicated resource handler. This configuration tells Spring where to find your static files and which URL patterns should be mapped to them. This is a crucial step for any Spring MVC application that serves web pages.

To effectively handle static content in Spring MVC, you configure resource handlers that map URL paths to physical locations on your server or classpath. This prevents the DispatcherServlet from attempting to resolve static file requests as controller mappings, ensuring efficient delivery of CSS, JavaScript, images, and other assets directly to the client’s browser.

Java-based Configuration

For modern Spring applications, Java-based configuration is the preferred method. You achieve this by extending WebMvcConfigurerAdapter (or implementing WebMvcConfigurer in Spring 5.0+) and overriding the addResourceHandlers method. This method provides a ResourceHandlerRegistry where you can register multiple resource handlers.

@Configuration @EnableWebMvc public class WebConfig implements WebMvcConfigurer { @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/resources/") .addResourceLocations("/WEB-INF/resources/") .setCachePeriod(31536000); // 1 year cache } } 

In this example, any request starting with /resources/ will be mapped to files located in the /WEB-INF/resources/ directory. The setCachePeriod method is vital for performance, instructing browsers to cache these resources for a specified duration, reducing subsequent requests to the server. You can add multiple resource handlers for different types of assets or locations, for instance, /js/ mapping to /WEB-INF/js/ and /css/ mapping to /WEB-INF/css/.

XML-based Configuration

For applications still using XML configuration, the mvc:resources tag within your Spring MVC configuration file (often servlet-context.xml or spring-mvc.xml) serves the same purpose. This approach is common in older or legacy Spring projects.

<mvc:resources mapping="/resources/" location="/WEB-INF/resources/" cache-period="31536000" /> 

This XML snippet achieves the same result as the Java configuration. The mapping attribute defines the URL pattern, and the location attribute specifies the physical path where the static files reside. The cache-period attribute is equivalent to setCachePeriod in Java configuration. Both methods ensure that requests for static files are intercepted by Spring’s resource handler and served efficiently, bypassing the controller mapping process entirely.

Beyond basic configuration, effective static content management in Spring MVC involves advanced techniques to boost performance, improve scalability, and enhance security. These strategies are critical for delivering a fast and reliable user experience, especially in high-traffic applications.

Caching Strategies

Caching is paramount for static resources. By leveraging browser and proxy caches, you can significantly reduce the number of requests to your server, speeding up page loads for repeat visitors. Spring’s resource handlers allow you to configure cache-control headers, such as Cache-Control and Expires. For example, setting setCachePeriod(31536000) in Java config tells browsers to cache the resource for one year, serving it directly from the client’s cache on subsequent visits without hitting the server. Additionally, enabling ETags and Last-Modified headers allows browsers to perform conditional requests, only downloading resources if they have changed since the last fetch. For a deeper dive into HTTP caching, consult Question & Answer :

I am developing a webapp using Spring MVC 3 and have the DispatcherServlet catching all requests to ‘/’ like so (web.xml):

<servlet> <servlet-name>app</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>app</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> 

Now this works as advertised, however how can I handle static content? Previously, before using RESTful URLs, I would have caught all *.html for example and sent that to the DispatcherServlet, but now it’s a different ball game.

I have a /static/ folder which includes /styles/, /js/, /images/ etc and I would like to exclude /static/* from the DispatcherServlet.

Now I could get static resources working when I did this:

<servlet-mapping> <servlet-name>app</servlet-name> <url-pattern>/app/</url-pattern> </servlet-mapping> 

But I want it to have nice URLs (the point of me using Spring MVC 3) not the landing page being www.domain.com/app/

I also don’t want a solution coupled to tomcat or any other servlet container, and because this is (relatively) low traffic I don’t need a webserver (like apache httpd) infront.

Is there a clean solution to this?

Since I spent a lot of time on this issue, I thought I’d share my solution. Since spring 3.0.4, there is a configuration parameter that is called <mvc:resources/> (more about that on the reference documentation website) which can be used to serve static resources while still using the DispatchServlet on your site’s root.

In order to use this, use a directory structure that looks like the following:

src/ springmvc/ web/ MyController.java WebContent/ resources/ img/ image.jpg WEB-INF/ jsp/ index.jsp web.xml springmvc-servlet.xml 

The contents of the files should look like:

src/springmvc/web/HelloWorldController.java:

package springmvc.web; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @Controller public class HelloWorldController { @RequestMapping(value="/") public String index() { return "index"; } } 

WebContent/WEB-INF/web.xml:

<?xml version="1.0" encoding="UTF-8"?> <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app> 

WebContent/WEB-INF/springmvc-servlet.xml:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <!-- not strictly necessary for this example, but still useful, see http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/mvc.html#mvc-ann-controller for more information --> <context:component-scan base-package="springmvc.web" /> <!-- the mvc resources tag does the magic --> <mvc:resources mapping="/resources/**" location="/resources/" /> <!-- also add the following beans to get rid of some exceptions --> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /> <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"> </bean> <!-- JSTL resolver --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" /> <property name="prefix" value="/WEB-INF/jsp/" /> <property name="suffix" value=".jsp" /> </bean> </beans> 

WebContent/jsp/index.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <h1>Page with image</h1> <!-- use c:url to get the correct absolute path --> <img src="<c:url value="/resources/img/image.jpg" />" />