1. Overview
The tutorial illustrates how tocreate a Web Application with Spring.
We’ll look into the Spring Boot solution for building the application and also see a non-Spring Boot approach.
We’ll primarily use Java configuration, but also have a look at their equivalent XML configuration.
Further reading:
Spring Boot Tutorial - Bootstrap a Simple Application
Configure a Spring Boot Web Application
Migrating from Spring to Spring Boot
2. Setting Up Using Spring Boot
2.1. Maven Dependency
First, we’ll need thespring-boot-starter-web dependency:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>This starter includes:
- spring-web and thespring-webmvc module that we need for our Spring web application
- a Tomcat starter so that we can run our web application directly without explicitly installing any server
2.2. Creating a Spring Boot Application
The most straightforward way to get started using Spring Boot is to create a main class and annotate it with @SpringBootApplication:
@SpringBootApplicationpublic class SpringBootRestApplication { public static void main(String[] args) { SpringApplication.run(SpringBootRestApplication.class, args); }}This single annotation is equivalent to using@Configuration,@EnableAutoConfiguration, and@ComponentScan.
By default, it will scan all the components in the same package or below.
Next, for Java-based configuration of Spring beans, we need to create a config class and annotate it with@Configuration annotation:
@Configurationpublic class WebConfig {}This annotation is the main artifact used by the Java-based Spring configuration; it is itself meta-annotated with@Component, which makes the annotated classes standard beans and as such, also candidates for component-scanning.
The main purpose of@Configuration classes is to be sources of bean definitions for the Spring IoC Container. For a more detailed description, see theofficial docs.
Let’s also have a look at a solution using the corespring-webmvc library.
3. Setting Up Using spring-webmvc
3.1. Maven Dependencies
First, we need thespring-webmvc dependency:
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.3</version></dependency>3.2. The Java-based Web Configuration
Next, we’ll add the configuration class that has the@Configuration annotation:
@Configuration@EnableWebMvc@ComponentScan(basePackages = "com.baeldung.controller")public class WebConfig { }Here, unlike the Spring Boot solution, we’ll have to explicitly define@EnableWebMvc for setting up default Spring MVC Configurations and @ComponentScan to specify packages to scan for components.
The@EnableWebMvc annotation provides the Spring Web MVC configuration such as setting up the dispatcher servlet, enabling the@Controller and the@RequestMapping annotations and setting up other defaults.
@ComponentScan configures the component scanning directive, specifying the packages to scan.
3.3. The Initializer Class
Next, we need toadd a class that implements the WebApplicationInitializer interface:
public class AppInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext container) throws ServletException { AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext(); context.scan("com.baeldung"); container.addListener(new ContextLoaderListener(context)); ServletRegistration.Dynamic dispatcher = container.addServlet("mvc", new DispatcherServlet(context)); dispatcher.setLoadOnStartup(1); dispatcher.addMapping("/"); }}Here, we’re creating a Spring context using the AnnotationConfigWebApplicationContext class, which means we’re using only annotation-based configuration. Then, we’re specifying the packages to scan for components and configuration classes.
Finally, we’re defining the entry point for the web application – theDispatcherServlet.
This class can entirely replace theweb.xml file from <3.0 Servlet versions.
4. XML Configuration
Let’s also have a quick look at the equivalent XML web configuration:
<context:component-scan base-package="com.baeldung.controller" /><mvc:annotation-driven />We can replace this XML file with theWebConfig class above.
To start the application, we can use an Initializer class that loads the XML configuration or a web.xml file. For more details on these two approaches, check outour previous article.
5. Conclusion
In this article, we looked into two popular solutions for bootstrapping a Spring web application, one using the Spring Boot web starter and other using the core spring-webmvc library.
Inthe next article on REST with Spring, I cover setting up MVC in the project, configuration of the HTTP status codes, payload marshalling, and content negotiation.
