Building an Application with Spring Boot
What you will build
You will build a simple web application with Spring Boot and add some useful services to it.
Learn What you Can do With Spring Boot
Spring Boot offers a fast way to build applications. It look at your classpth and at the beans you have configured, makes reasonable assumptions about what you are missing, and adds those items. With Spring Boot, you can focus more on business and less on infrastructure.
The following examples show what Spring Boot can do for you:
-
Is Spring MVC on the classpath? There are several specific beans you almost always need, and Spring Boot adds them automatically. A Spring Boot application also needs a servlet container, so Spring Boot automatically configures embedded Tomcat.
-
Is Jetty on the classpath? If so, you probably do NOT want Tomcat but instead want imbedded Jetty. Spring Boot handles that for you.
-
Is Thymeleaf on the classpath? If so, there are a few beans that must always be added to your application context. Spring boot adds them for you.
These are just a few examples of the automatic configuration Spring Boot provides. As the same time, Spring Boot does not get in your way. for example, if Thymeleaf is on your path, Spring Boot automatically adds a SpringTempleteEngine
to your application context. But if you define your own SpringTempleteEngine
with your own settings, Spring Boot does not add one. This leaves you in control with little effort on your part.
Spring Boot does not generate code or make edits to your files. Instead, when you start your application, Spring Boot dynamically wires up beans and settings and applies them to your application contex.
Create a Simple Web Application
Now you can create a web controller for a simple web application, as the following listing shows:
package com.example.springboot; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController { @GetMapping("/") public String index() { return "Greetings from Spring Boot!"; } }
The class is flagged as a @RestController
, meaning it is ready for use by Spring MVC to handle web requests. @GetMapping
maps /
to the index()
method. When invoked from a browser or by curl on the command line, the method returns pure text. That is becausse @RestController
combines @Controller
and @ResponseBody
, two annotations that results in web requests returning data rather than a view.
Create an Application class
The Spring Initializer creates a simple application class for you. However, in this case, it is too simple. You need to modify the application class to match the following listing:
package com.example.springboot; import java.util.Arrays; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.Bean; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Bean public CommandLineRunner commandLineRunner(ApplicationContext ctx) { return args -> { System.out.println("Let's inspect the beans provided by Spring Boot:"); String[] beanNames = ctx.getBeanDefinitionNames(); Arrays.sort(beanNames); for (String beanName : beanNames) { System.out.println(beanName); } }; } }
@SpringBootApplication
is a convenience annotation that adds all of the following:
-
@Configuration
: Tags the class as a source of bean definitions for the application context. -
@EnableAutoConfiguration
: Tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings. For example, ifspring-webmvc
is on the classpath, this annotation flags the application as a web application and activates key behaviors, such as setting up aDispatcherServlet
. -
@ComponentScan
: Tells Spring to look for other components, configurations, and services in thecom/example
package, letting it find the controllers.
The main()
method uses Spring Boot's SpringApplication.run()
method to launch an application. Did you notice that there was not a single line of XML? There is no web.xml
file, either. This web application is 100% pure java and you did not have to deal with configuring any plumbing or infrastructure.
There is also a CommandLineRunner
method marked as a @Bean
, and this runs on start up. It retrieves all the beans that were created by your application or that were automatically added by Spring Boot. It sorts them and prints them out.
Run the Application
If you use Maven, run the following command in a terminal window (in the complete
) directory:
./mvnw spring-boot:run
You should see output similar to the following:
Let's inspect the beans provided by Spring Boot: application beanNameHandlerMapping defaultServletHandlerMapping dispatcherServlet embeddedServletContainerCustomizerBeanPostProcessor handlerExceptionResolver helloController httpRequestHandlerAdapter messageSource mvcContentNegotiationManager mvcConversionService mvcValidator org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$DispatcherServletConfiguration org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$EmbeddedTomcat org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration org.springframework.boot.context.embedded.properties.ServerProperties org.springframework.context.annotation.ConfigurationClassPostProcessor.enhancedConfigurationProcessor org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor org.springframework.context.annotation.internalAutowiredAnnotationProcessor org.springframework.context.annotation.internalCommonAnnotationProcessor org.springframework.context.annotation.internalConfigurationAnnotationProcessor org.springframework.context.annotation.internalRequiredAnnotationProcessor org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration propertySourcesBinder propertySourcesPlaceholderConfigurer requestMappingHandlerAdapter requestMappingHandlerMapping resourceHandlerMapping simpleControllerHandlerAdapter tomcatEmbeddedServletContainerFactory viewControllerHandlerMapping
You can clearly see org.springframework.boot.autoconfigure
beans. There is also a tomcatEmbeddedServletContainerFactory
.
Now run the service with curl (in a separate terminal window), by running the following command (shown with its output):
$ curl localhost:8080 Greetings from Spring Boot!
Add Unit Tests
You will want to add a test for the endpoint you added, and Spring Test provides some machinery for that.
If you use Maven, add the following to your pom.xml
file:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency>
Now write a simple unit test that mocks the servlet request and response through your endpoint, as the following listing shows:
package com.example.springboot; import static org.hamcrest.Matchers.equalTo; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; 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.http.MediaType; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; @SpringBootTest @AutoConfigureMockMvc public class HelloControllerTest { @Autowired private MockMvc mvc; @Test public void getHello() throws Exception { mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(content().string(equalTo("Greetings from Spring Boot!"))); } }
MockMvc
comes from Spring Test and lets you, through a set of convenience builder classes, send HTTP requests into the DispatcherServlet
and make assertions about the result. Note the use of @AutoConfigureMockMvc
and @SpringBootTest
to inject a MockMvc
instance. Having used @SpringBootTest
, we are asking for the whole application context to be created. An alternative would be to ask Spring Boot to create only the web layers of the context by using @WebMvcTest
. In either case, Spring Boot automatically tries to locate main application class of your application, but you can override it or narrow it down if you want to build something different.
As well as mocking the HTTP request cycle, you can also use Spring Boot to write a simple full-stack integration test. For example, instead of (or as well as) the mock test shown earlier, we could create the following test:
package com.example.springboot; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.web.client.TestRestTemplate; import org.springframework.http.ResponseEntity; import static org.assertj.core.api.Assertions.assertThat; @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) public class HelloControllerIT { @Autowired private TestRestTemplate template; @Test public void getHello() throws Exception { ResponseEntity<String> response = template.getForEntity("/", String.class); assertThat(response.getBody()).isEqualTo("Greetings from Spring Boot!"); } }
The embedded server starts on a random port because of webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT
, and the actual port is configured automatically in the base URL for the TestRestTemplete
.
Add Production-grade Services
If you are building a web site for your business, you probably need to add some management services. Spring Boot provides several such services (such as health, audits, beans, and more) with its actuator module
.
If you use Maven, add the following dependency to your pom.xml
file:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency>
Then restart the application. If you use Maven, run the following command in a terminal window (in the complete
directory):
./mvnw spring-boot:run
You should see that a new set of RESTful end points have been added to the application. These are management services provided by Spring Boot. The following listing shows typical output:
management.endpoint.configprops-org.springframework.boot.actuate.autoconfigure.context.properties.ConfigurationPropertiesReportEndpointProperties management.endpoint.env-org.springframework.boot.actuate.autoconfigure.env.EnvironmentEndpointProperties management.endpoint.health-org.springframework.boot.actuate.autoconfigure.health.HealthEndpointProperties management.endpoint.logfile-org.springframework.boot.actuate.autoconfigure.logging.LogFileWebEndpointProperties management.endpoints.jmx-org.springframework.boot.actuate.autoconfigure.endpoint.jmx.JmxEndpointProperties management.endpoints.web-org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties management.endpoints.web.cors-org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties management.health.diskspace-org.springframework.boot.actuate.autoconfigure.system.DiskSpaceHealthIndicatorProperties management.info-org.springframework.boot.actuate.autoconfigure.info.InfoContributorProperties management.metrics-org.springframework.boot.actuate.autoconfigure.metrics.MetricsProperties management.metrics.export.simple-org.springframework.boot.actuate.autoconfigure.metrics.export.simple.SimpleProperties management.server-org.springframework.boot.actuate.autoconfigure.web.server.ManagementServerProperties
View Spring Boot's Starters
You have seen some of Spring Boot's "Starters". You can see them all here in source code.
Summary
Congratulations! You built a simple web application with Spring Boot and learned how it can ramp up your development pace. You also turned on some handy production services. This is only a small sampling of what Spring Boot can do. See Spring Boot's online docs for much more information.
See Also
The following guides may also be helpful: