Creating a Web Application with Spring 5 – 用Spring 5创建一个Web应用程序

最后修改: 2013年 11月 25日


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.

我们将研究构建应用程序的Spring Boot解决方案,也会看到一种非Spring Boot的方法。

We’ll primarily use Java configuration, but also have a look at their equivalent XML configuration.


2. Setting Up Using Spring Boot

2.使用Spring Boot进行设置

2.1. Maven Dependency


First, we’ll need the spring-boot-starter-web 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

2.2.创建一个Spring Boot应用程序

The most straightforward way to get started using Spring Boot is to create a main class and annotate it with @SpringBootApplication:

开始使用Spring Boot的最直接方法是创建一个主类,并用@SpringBootApplication对其进行注释。

public class SpringBootRestApplication {

    public static void main(String[] args) {, 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:

接下来,对于基于Java的Spring Bean配置,我们需要创建一个config类,并用@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.

@Configuration类的主要目的是成为Spring IoC容器的bean定义的来源。有关更详细的描述,请参阅官方文档

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:



3.2. The Java-based Web Configuration


Next, we’ll add the configuration class that has the @Configuration annotation:


@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.

在这里,与Spring Boot解决方案不同,我们必须明确定义@EnableWebMvc以设置默认的Spring MVC配置,以及@ComponentScan以指定要扫描组件的包。

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.

@EnableWebMvc注解提供了Spring Web MVC的配置,如设置dispatcher servlet、启用@Controller@RequestMapping注解以及设置其他默认值。

@ComponentScan configures the component scanning directive, specifying the packages to scan.

@ComponentScan 配置组件扫描指令,指定要扫描的包。

3.3. The Initializer Class


Next, we need to add a class that implements the WebApplicationInitializer interface:


public class AppInitializer implements WebApplicationInitializer {

    public void onStartup(ServletContext container) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        container.addListener(new ContextLoaderListener(context));

        ServletRegistration.Dynamic dispatcher = 
          container.addServlet("mvc", new DispatcherServlet(context));

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.

这个类可以完全取代<3.0 Servlet版本中的web.xml文件。

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

在这篇文章中,我们研究了两种流行的引导Spring Web应用的解决方案,一种是使用Spring Boot Web Starter,另一种是使用核心的spring-webmvc库。

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.