ZetCode

Serving static content in Spring Boot

last modified July 20, 2023

Spring Boot static content shows how to serve static content in a Spring Boot application.

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.

build.gradle
...
src
├───main
│   ├───java
│   │   └───com
│   │       └───zetcode
│   │           │   Application.java
│   │           ├───controller
│   │           │       MyController.java
│   │           └───model
│   │                   Message.java
│   └───resources
│       │   application.properties
│       └───static
│           │   index.html
│           └───css
│                   main.css
└───test
    └───java
        └───com
            └───zetcode
                └───controller
                        MyControllerTest.java

This is the project structure of the Spring Boot application.

build.gradle
plugins {
    id 'org.springframework.boot' version '3.1.1'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

This is the gradle 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.

com/zetcode/model/Message.java
package com.zetcode.model;

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

@Component
public class Message {

    @Value("${app.message}")
    private String message;

    public String get() {
        return message;
    }
}

Message is a model class which contains a simple text message for the client.

@Value("${app.message}")
private String message;

We inject a value from the application.properties into the message variable.

resources/application.properties
app.message=Hello there

The application.properties file contains various configuration settings of a Spring Boot application. We define a custom property having a text message.

com/zetcode/controller/MyController.java
package com.zetcode.controller;

import com.zetcode.model.Message;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class MyController {

    private final Message message;

    public MyController(Message message) {
        this.message = message;
    }

    @GetMapping(path = "/message")
    @ResponseBody
    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 /message path and returns a plain text message.

private final Message message;

public MyController(Message message) {
    this.message = message;
}

A Message object is injected into the property.

@GetMapping(path = "/message")
@ResponseBody
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.

resources/static/index.html
<!DOCTYPE html>
<html>
<head>
    <title>Home page</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="css/main.css" rel="stylesheet" type="text/css">
</head>
<body>

<h2>Home page</h2>

<a href="/message">Get message</a>
</body>
</html>

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.

resources/static/css/main.css
h2 { color: blue }

In the main.css file, we set the h2 tag to blue colour.

com/zetcode/controller/MyControllerTest.java
package com.zetcode.controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.forwardedUrl;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void getHome() throws Exception {
        this.mockMvc.perform(get("/"))
                .andDo(print())
                .andExpect(status().isOk())
                .andExpect(forwardedUrl("index.html"));
    }

    @Test
    public void getMessage() throws Exception {
        this.mockMvc.perform(get("/message"))
                .andDo(print())
                .andExpect(status().isOk())
                .andExpect(content().string("Hello there"));
    }
}

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

com/zetcode/Application.java
package com.zetcode;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

The Application sets up the Spring Boot application.

In this article we have served static context in a Spring Boot application.

Author

My name is Jan Bodnar and I am a passionate programmer with many years of programming experience. I have been writing programming articles since 2007. So far, I have written over 1400 articles and 8 e-books. I have over eight years of experience in teaching programming.

List all Spring Boot tutorials.