Creating a Web Application with Spring 5

1. Overview

The tutorial illustrates how to create 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.

2. Setting Up Using Spring Boot

2.1. Maven Dependency

First, we’ll need the spring-boot-starter-web dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.4.0</version>
</dependency>

This starter includes:

  • spring-web and the spring-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:

@SpringBootApplication
public 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:

@Configuration
public 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 the official docs.

Let’s also have a look at a solution using the core spring-webmvc library.

3. Setting Up Using spring-webmvc

3.1. Maven Dependencies

First, we need the spring-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.maixuanviet.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 to add 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.maixuanviet");
        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 – the DispatcherServlet.

This class can entirely replace the web.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.maixuanviet.controller" />
<mvc:annotation-driven />

We can replace this XML file with the WebConfig 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 out our 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.

In the 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.

As always, the code presented in this article is available over on Github. This is a Maven-based project, so it should be easy to import and run as it is.

Related posts:

A Guide to System.exit()
Java Program to Construct a Random Graph by the Method of Random Edge Selection
Receive email using POP3
Java Program to Perform Sorting Using B-Tree
Constructor Dependency Injection in Spring
Java Program to Construct an Expression Tree for an Infix Expression
Java Program to Implement Heap
Java Program to Implement Quick Hull Algorithm to Find Convex Hull
Java Program to Implement Hash Tables with Quadratic Probing
Java Program to Implement Threaded Binary Tree
Java Program to Perform Insertion in a 2 Dimension K-D Tree
Introduction to Spring Cloud CLI
Debug a JavaMail Program
Java Program to Check Whether it is Weakly Connected or Strongly Connected for a Directed Graph
Java Program to Implement Radix Sort
Java Program to Find the GCD and LCM of two Numbers
Java Program to Perform LU Decomposition of any Matrix
Spring REST with a Zuul Proxy
Java Program to Find the Longest Subsequence Common to All Sequences in a Set of Sequences
Spring Autowiring of Generic Types
Java Program to Implement Quick Sort Using Randomization
Use Liquibase to Safely Evolve Your Database Schema
Java Program to Find ith Largest Number from a Given List Using Order-Statistic Algorithm
Java Program to Perform Addition Operation Using Bitwise Operators
Tính đa hình (Polymorphism) trong Java
How to Convert List to Map in Java
RestTemplate Post Request with JSON
Spring Security Logout
Ways to Iterate Over a List in Java
Java Multi-line String
Java Program to Implement Double Order Traversal of a Binary Tree
Spring – Injecting Collections