1. Overview
1.概述
In this article we’ll cover three different approaches of configuring a DispatcherServlet available in recent versions of the Spring Framework:
在本文中，我们将介绍配置DispatcherServlet的三种不同方法，这些方法在最近的Spring框架版本中可用：。
- We’ll start with an XML configuration and a web.xml file
- Then we’ll migrate the Servlet declaration from the web.xml file to Java config, but we’ll leave any other configuration in XML
- Finally in the third and final step of the refactoring, we’ll have a 100% Java-configured project
2. The DispatcherServlet
2.DispatcherServlet
One of the core concepts of Spring MVC is the DispatcherServlet. The Spring documentation defines it as:
Spring MVC的核心概念之一是DispatcherServlet。Spring文档将其定义为。
A central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service exporters. Dispatches to registered handlers for processing a web request, providing convenient mapping and exception handling facilities.
HTTP请求处理程序/控制器的中央调度器，例如Web UI控制器或基于HTTP的远程服务输出器。派遣到注册的处理程序来处理一个web请求，提供方便的映射和异常处理设施。
Basically the DispatcherServlet is the entry point of every Spring MVC application. Its purpose is to intercept HTTP requests and to dispatch them to the right component that will know how to handle it.
基本上，DispatcherServlet是每个Spring MVC应用程序的入口点。它的目的是拦截HTTP请求，并将其分派给知道如何处理的正确组件。
3. Configuration With web.xml
3.用web.xml配置
If you deal with legacy Spring projects it is very common to find XML configuration and until Spring 3.1 the only way to configure the DispatcherServlet was with the WEB-INF/web.xml file. In this case there are two steps required.
如果你处理传统的Spring项目，很容易发现XML配置，直到Spring3.1，配置DispatcherServlet的唯一方法是使用WEB-INF/web.xml文件。在这种情况下，需要两个步骤。
Let’s see an example configuration – the first step is the Servlet declaration:
让我们看一个配置的例子–第一步是Servlet声明。
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/dispatcher-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>With this block of XML we are declaring a servlet that:
通过这个XML块，我们声明了一个servlet，该servlet。
- Is named “dispatcher“
- Is an instance of org.springframework.web.servlet.DispatcherServlet
- Will be initialized with a parameter named contextConfigLocation which contains the path to the configuration XML
load-on-startup is an integer value that specifies the order for multiple servlets to be loaded. So if you need to declare more than one servlet you can define in which order they will be initialized. Servlets marked with lower integers are loaded before servlets marked with higher integers.
load-on-startup是一个整数值，用于指定多个Servlet的加载顺序。因此，如果你需要声明一个以上的Servlet，你可以定义它们被初始化的顺序。标记为较低整数的Servlet将在标记为较高整数的Servlet之前加载。
Now our servlet is configured. The second step is declaring a servlet-mapping:
现在我们的Servlet已经配置好了。第二步是声明一个servlet-mapping。
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>With the servlet mapping we are bounding it by its name to a URL pattern that specifies what HTTP requests will be handled by it.
通过servlet映射，我们将它的名字与URL pattern绑定，指定它将处理哪些HTTP请求。
4. Hybrid Configuration
4.混合配置
With the adoption of the version 3.0 of Servlet APIs, the web.xml file has become optional, and we can now use Java to configure the DispatcherServlet.
随着3.0版Servlet APIs的采用，web.xml文件变得可有可无，我们现在可以使用Java来配置DispatcherServlet。
We can register a servlet implementing a WebApplicationInitializer. This is the equivalent of the XML configuration above:
我们可以注册一个实现WebApplicationInitializer的Servlet。这就相当于上面的XML配置。
public class MyWebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) {
XmlWebApplicationContext context = new XmlWebApplicationContext();
context.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");
ServletRegistration.Dynamic dispatcher = container
.addServlet("dispatcher", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
}In this example we are:
在这个例子中，我们是。
- Implementing the WebApplicationInitializer interface
- Overriding the onStartup method we create a new XmlWebApplicationContext configured with the same file passed as contextConfigLocation to the servlet in the XML example
- Then we are creating an instance of DispatcherServlet with the new context that we just instantiated
- And finally we are registering the servlet with a mapping URL pattern
So we used Java to declare the servlet and bind it to a URL mapping but we kept the configuration in a separated XML file: dispatcher-config.xml.
所以我们用Java来声明servlet，并将其与URL映射绑定，但我们将配置保存在一个独立的XML文件中。dispatcher-config.xml。
5. 100% Java Configuration
5.100%的Java配置
With this approach our servlet is declared in Java, but we still need an XML file to configure it. With WebApplicationInitializer you can achieve a 100% Java configuration.
通过这种方法，我们的Servlet是用Java声明的，但是我们仍然需要一个XML文件来配置它。使用WebApplicationInitializer，你可以实现100%Java配置。
Let’s see how we can refactor the previous example.
让我们看看如何重构前面的例子。
The first thing we will need to do is create the application context for the servlet.
我们需要做的第一件事是为Servlet创建应用上下文。
This time we will use an annotation based context so that we can use Java and annotations for configuration and remove the need for XML files like dispatcher-config.xml:
这次我们将使用基于注解的上下文，这样我们就可以使用Java和注解进行配置，而不再需要XML文件，比如dispatcher-config.xml。
AnnotationConfigWebApplicationContext context
= new AnnotationConfigWebApplicationContext();This type of context can then be configured registering a configuration class:
然后，这种类型的上下文可以配置注册一个配置类。
context.register(AppConfig.class);Or setting an entire package that will be scanned for configuration classes:
或设置整个包，将被扫描的配置类。
context.setConfigLocation("com.example.app.config");Now that our application context is created, we can add a listener to the ServletContext that will load the context:
现在我们的应用程序上下文已经创建，我们可以向ServletContext添加一个监听器，它将加载上下文。
container.addListener(new ContextLoaderListener(context));The next step is creating and registering our dispatcher servlet:
下一步是创建和注册我们的dispatcher servlet。
ServletRegistration.Dynamic dispatcher = container
.addServlet("dispatcher", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");Now our WebApplicationInitializer should look like this:
现在我们的WebApplicationInitializer应该看起来像这样。
public class MyWebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) {
AnnotationConfigWebApplicationContext context
= new AnnotationConfigWebApplicationContext();
context.setConfigLocation("com.example.app.config");
container.addListener(new ContextLoaderListener(context));
ServletRegistration.Dynamic dispatcher = container
.addServlet("dispatcher", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
}Java and annotation configuration offers many advantages. Usually it leads to shorter and more concise configuration and annotations provide more context to declarations, as it’s co-located with the code that they configure.
Java和注解配置有很多优点。通常情况下，它会导致更短、更简洁的配置，而且注解为声明提供了更多的上下文，因为它与它们所配置的代码共处一室。
But this is not always a preferable or even possible way. For example some developers may prefer keeping their code and configuration separated, or you may need to work with third party code that you can’t modify.
但这并不总是一种可取的甚至是可能的方式。例如，一些开发者可能更喜欢将他们的代码和配置分开，或者你可能需要与第三方代码一起工作，而你又不能修改。
6. Conclusion
6.结论
In this article we covered different ways to configure a DispatcherServlet in Spring 3.2+ and it’s up to you to decide which one to use based on your preferences. Spring will accommodate to your decision whatever you choose.
在这篇文章中，我们介绍了在Spring 3.2+中配置DispatcherServlet的不同方法，由你根据自己的喜好决定使用哪种方法。Spring将适应你的决定，无论你选择什么。
You can find the source code from this article on Github here and here.