Serving static content in Spring Boot

In this tutorial, we are going to show how to serve static content in Spring Boot. Static content consists of HTML, JavaScript, CSS files, or various types of images.

Spring is a popular Java application framework. Spring Boot is an effort to create stand-alone, production-grade Spring based applications with minimal effort.

Spring Boot automatically adds static web resources located within any of the following directories:

The directories are located in the classpath or in the root of the ServletContext.

In our application, we have one HTML file which contains a simple link. The link triggers a response from the web Boot application. It returns a plain text message.

$ tree
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── zetcode
    │   │           ├──
    │   │           ├── bean
    │   │           │   └──
    │   │           └── controller
    │   │              └──
    │   └── resources
    │       ├──
    │       └── static
    │           ├── css
    │           │  └── main.css
    │           └── index.html
    └── test
        └── java
            └── com
                └── zetcode
                    └── controller

This is the project structure of the Spring Boot application.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="" 


This is the Maven build file. The spring-boot-starter-web is starter for building web applications using Spring MVC. The spring-boot-starter-test imports necessary testing modules. The application is packaged into a JAR file.
package com.zetcode.bean;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

public class Message {
    private String msg;
    public String get() {
        return msg;

The Message sets up the Spring Boot application. The @SpringBootApplication annotation enables auto-configuration and component scanning.

private String msg;

We inject a value from the into the msg variable.
app.message=Hello there

The file contains various configuration settings of a Spring Boot application. We define a custom property having a text message.
package com.zetcode.controller;

import com.zetcode.bean.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

public class MyController {

    private Message message;

    @RequestMapping(path = "/msg", method = RequestMethod.GET)
    public String message() {

        return message.get();

This is the controller class for the Spring Boot web application. A controller is decorated with the @Controller annotation. The controller has one mapping; it is mapped to the /msg path and returns a plain text message.

private Message message;

A Message object is injected into the property.

@RequestMapping(path = "/msg", method = RequestMethod.GET)
public String message() {

    return message.get();

The message() method responds to a GET request. The @ResponseBody annotation puts the string value to the web response body.

<!DOCTYPE html>
        <title>Home page</title>
        <link href="css/main.css" rel="stylesheet" type="text/css">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <h2>This is home page</h2>
        <a href="/msg">Get message</a>

In the index.html file we have a link that invokes a response from the web application. The file is located in the src/main/resources/static directory, which is a default directory where Spring looks for static content.

<link href="css/main.css" rel="stylesheet" type="text/css">

In the link tag we refer to the main.css static resource, which is located in the src/main/resources/static/css directory.

h2 { color: blue }

In the main.css file, we set the h2 tag to blue colour.
package com.zetcode.controller;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.forwardedUrl;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

public class MyControllerTest {

    private WebApplicationContext wac;

    private MockMvc mockMvc;

    public void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();

    public void getHome() throws Exception {

    public void getMessage() throws Exception {
                .andExpect(content().string("Hello there"));

In the MyControllerTest we have two tests: one for the home page and one for the returned message text.
package com.zetcode;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

public class Application {

    public static void main(String[] args) {, args);

The Application sets up the Spring Boot application. The @SpringBootApplication annotation enables auto-configuration and component scanning.

In this tutorial, we have served static context in a Spring Boot application. You might also be interested in the related tutorials: Spring Boot DataSourceBuilder tutorial, Spring Boot iText tutorial, Spring Boot RESTFul application, Introduction to Spring web applications, Standalone Spring applications, Java tutorial.