spring mvc源码学习笔记之六

pom.xml 内容如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>com.qsm</groupId><artifactId>learn</artifactId><version>1.0.0</version></parent><groupId>com.qs.demo</groupId><artifactId>demo-077</artifactId><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.28</version></dependency><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version><scope>provided</scope></dependency></dependencies></project>

com.qs.demo.MyWebApplicationInitializer 内容如下

package com.qs.demo;import com.qs.demo.root.AppConfig;
import com.qs.demo.sub.DispatcherConfig;import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;/*** @author qs* @date 2024/09/24*/
public class MyWebApplicationInitializer implements WebApplicationInitializer {// 这个例子来自于 WebApplicationInitializer 的文档@Overridepublic void onStartup(ServletContext container) {// Create the 'root' Spring application contextAnnotationConfigWebApplicationContext rootContext =new AnnotationConfigWebApplicationContext();rootContext.register(AppConfig.class);// Manage the lifecycle of the root application contextcontainer.addListener(new ContextLoaderListener(rootContext));// Create the dispatcher servlet's Spring application contextAnnotationConfigWebApplicationContext dispatcherContext =new AnnotationConfigWebApplicationContext();dispatcherContext.register(DispatcherConfig.class);// Register and map the dispatcher servletServletRegistration.Dynamic dispatcher =container.addServlet("dispatcher", new DispatcherServlet(dispatcherContext));dispatcher.setLoadOnStartup(1);// 一个 DispatcherServlet 包圆了所有的请求// 可以搞多个 DispatcherServlet 分别处理不同的请求dispatcher.addMapping("/");}
}

com.qs.demo.root.AppConfig 内容如下

package com.qs.demo.root;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** @author qs* @date 2024/09/24*/
@Configuration
@ComponentScan("com.qs.demo.root")
public class AppConfig {}

com.qs.demo.root.AppleService 内容如下

package com.qs.demo.root;import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;import java.util.UUID;/*** @author qs* @date 2024/09/24*/
@Service
public class AppleService implements ApplicationContextAware {private ApplicationContext applicationContext;public String a() {System.out.println(applicationContext);return UUID.randomUUID().toString();}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}
}

com.qs.demo.sub.DispatcherConfig 内容如下

package com.qs.demo.sub;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;/*** @author qs* @date 2024/09/24*/
@EnableWebMvc
@Configuration
@ComponentScan(basePackages = "com.qs.demo.sub")
public class DispatcherConfig {}

com.qs.demo.sub.BananaService 内容如下

package com.qs.demo.sub;import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;import java.util.UUID;/*** @author qs* @date 2024/09/24*/
@Service
public class BananaService implements ApplicationContextAware {public String a() {return UUID.randomUUID().toString();}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println(applicationContext);}
}

com.qs.demo.sub.Demo01Controller 内容如下

package com.qs.demo.sub;import com.qs.demo.root.AppleService;import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;/*** @author qs* @date 2024/09/24*/
@RestController
public class Demo01Controller {@Resource private AppleService appleService;@Resource private BananaService bananaService;@GetMapping("/01")public String a() {return "01";}@GetMapping("/02")public String b() {return appleService.a();}@GetMapping("/03")public String c() {return bananaService.a();}
}

以上就是全部代码

写这个例子主要是为了介绍 WebApplicationInitializer 这个接口。简单点儿讲就是这个接口等价于 web.xml 这个配置文件。
写了这个接口就不用写 web.xml 配置文件了。
下面重点看下这个接口的 javadoc

/**  
* <p>
* 下面这段话的关键点：
* 1、适用于 servlet 3.0+ 环境
* 2、该接口可以看做是传统的 web.xml 的替代品
* </p>
*
* Interface to be implemented in Servlet 3.0+ environments in order to configure the  
* {@link ServletContext} programmatically -- as opposed to (or possibly in conjunction  
* with) the traditional {@code web.xml}-based approach.  
*
* <p>
* 下面这段话的意思：
* 1、该接口的实现会自动被 SpringServletContainerInitializer 检测到
* 2、而 SpringServletContainerInitializer 又会被 servlet 3.0 容器自动带起来
* </p>
*
* <p>Implementations of this SPI will be detected automatically by {@link  
* SpringServletContainerInitializer}, which itself is bootstrapped automatically  
* by any Servlet 3.0 container. See {@linkplain SpringServletContainerInitializer its  
* Javadoc} for details on this bootstrapping mechanism.  
*
* <p>注意下面这个例子。看本接口是怎样替换 web.xml 配置的</p>
*
* <h2>Example</h2>  
* <h3>The traditional, XML-based approach</h3>  
* Most Spring users building a web application will need to register Spring's {@code  
* DispatcherServlet}. For reference, in WEB-INF/web.xml, this would typically be done as  
* follows:  
* <pre class="code">  
* {@code  
* <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>  
*  
* <servlet-mapping>  
* <servlet-name>dispatcher</servlet-name>  
* <url-pattern>/</url-pattern>  
* </servlet-mapping>}</pre>  
*  
* <h3>The code-based approach with {@code WebApplicationInitializer}</h3>  
* Here is the equivalent {@code DispatcherServlet} registration logic,  
* {@code WebApplicationInitializer}-style:  
* <pre class="code">  
* public class MyWebAppInitializer implements WebApplicationInitializer {  
*  
* &#064;Override  
* public void onStartup(ServletContext container) {  
* XmlWebApplicationContext appContext = new XmlWebApplicationContext();  
* appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");  
*  
* ServletRegistration.Dynamic dispatcher =  
* container.addServlet("dispatcher", new DispatcherServlet(appContext));  
* dispatcher.setLoadOnStartup(1);  
* dispatcher.addMapping("/");  
* }  
*  
* }</pre>  
*
* <p>
* 上面的例子是实现 WebApplicationInitializer 接口。
* 也可以继承 AbstractDispatcherServletInitializer 类。
* </p>
*
* As an alternative to the above, you can also extend from {@link  
* org.springframework.web.servlet.support.AbstractDispatcherServletInitializer}.  
*  
* As you can see, thanks to Servlet 3.0's new {@link ServletContext#addServlet} method  
* we're actually registering an <em>instance</em> of the {@code DispatcherServlet}, and  
* this means that the {@code DispatcherServlet} can now be treated like any other object  
* -- receiving constructor injection of its application context in this case.  
*  
* <p>This style is both simpler and more concise. There is no concern for dealing with  
* init-params, etc, just normal JavaBean-style properties and constructor arguments. You  
* are free to create and work with your Spring application contexts as necessary before  
* injecting them into the {@code DispatcherServlet}.  
*  
* <p>Most major Spring Web components have been updated to support this style of  
* registration. You'll find that {@code DispatcherServlet}, {@code FrameworkServlet},  
* {@code ContextLoaderListener} and {@code DelegatingFilterProxy} all now support  
* constructor arguments. Even if a component (e.g. non-Spring, other third party) has not  
* been specifically updated for use within {@code WebApplicationInitializers}, they still  
* may be used in any case. The Servlet 3.0 {@code ServletContext} API allows for setting  
* init-params, context-params, etc programmatically.  
*
* <p>
* 在上面的例子中，web.xml 被替换了，但是 dispatcher-config.xml 依然存在。
* 下面的例子就彻底摆脱 xml 配置了。
* </p>
*
* <h2>A 100% code-based approach to configuration</h2>  
* In the example above, {@code WEB-INF/web.xml} was successfully replaced with code in  
* the form of a {@code WebApplicationInitializer}, but the actual  
* {@code dispatcher-config.xml} Spring configuration remained XML-based.  
* {@code WebApplicationInitializer} is a perfect fit for use with Spring's code-based  
* {@code @Configuration} classes. See @{@link  
* org.springframework.context.annotation.Configuration Configuration} Javadoc for  
* complete details, but the following example demonstrates refactoring to use Spring's  
* {@link org.springframework.web.context.support.AnnotationConfigWebApplicationContext  
* AnnotationConfigWebApplicationContext} in lieu of {@code XmlWebApplicationContext}, and  
* user-defined {@code @Configuration} classes {@code AppConfig} and  
* {@code DispatcherConfig} instead of Spring XML files. This example also goes a bit  
* beyond those above to demonstrate typical configuration of the 'root' application  
* context and registration of the {@code ContextLoaderListener}:  
* <pre class="code">  
* public class MyWebAppInitializer implements WebApplicationInitializer {  
*  
* &#064;Override  
* public void onStartup(ServletContext container) {  
* // Create the 'root' Spring application context  
* AnnotationConfigWebApplicationContext rootContext =  
* new AnnotationConfigWebApplicationContext();  
* rootContext.register(AppConfig.class);  
*  
* // Manage the lifecycle of the root application context  
* container.addListener(new ContextLoaderListener(rootContext));  
*  
* // Create the dispatcher servlet's Spring application context  
* AnnotationConfigWebApplicationContext dispatcherContext =  
* new AnnotationConfigWebApplicationContext();  
* dispatcherContext.register(DispatcherConfig.class);  
*  
* // Register and map the dispatcher servlet  
* ServletRegistration.Dynamic dispatcher =  
* container.addServlet("dispatcher", new DispatcherServlet(dispatcherContext));  
* dispatcher.setLoadOnStartup(1);  
* dispatcher.addMapping("/");  
* }  
*  
* }</pre>  
*  
* As an alternative to the above, you can also extend from {@link  
* org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer}.  
*  
* Remember that {@code WebApplicationInitializer} implementations are <em>detected  
* automatically</em> -- so you are free to package them within your application as you  
* see fit.  
*
* <p>
* 多个 WebApplicationInitializer 之间可以指定顺序。但是这种一般不常用。一个 WebApplicationInitializer 就够了。
* </p>
*
* <h2>Ordering {@code WebApplicationInitializer} execution</h2>  
* {@code WebApplicationInitializer} implementations may optionally be annotated at the  
* class level with Spring's @{@link org.springframework.core.annotation.Order Order}  
* annotation or may implement Spring's {@link org.springframework.core.Ordered Ordered}  
* interface. If so, the initializers will be ordered prior to invocation. This provides  
* a mechanism for users to ensure the order in which servlet container initialization  
* occurs. Use of this feature is expected to be rare, as typical applications will likely  
* centralize all container initialization within a single {@code WebApplicationInitializer}.  
*  
* <h2>Caveats</h2>  
*
* <p>
* 注意 web.xml 和 WebApplicationInitializer 不是相互排斥的。
* 二者可以同时存在。
* </p>
*
* <h3>web.xml versioning</h3>  
* <p>{@code WEB-INF/web.xml} and {@code WebApplicationInitializer} use are not mutually  
* exclusive; for example, web.xml can register one servlet, and a {@code  
* WebApplicationInitializer} can register another. An initializer can even  
* <em>modify</em> registrations performed in {@code web.xml} through methods such as  
* {@link ServletContext#getServletRegistration(String)}. <strong>However, if  
* {@code WEB-INF/web.xml} is present in the application, its {@code version} attribute  
* must be set to "3.0" or greater, otherwise {@code ServletContainerInitializer}  
* bootstrapping will be ignored by the servlet container.</strong>  
*  
* <h3>Mapping to '/' under Tomcat</h3>  
* <p>Apache Tomcat maps its internal {@code DefaultServlet} to "/", and on Tomcat versions  
* &lt;= 7.0.14, this servlet mapping <em>cannot be overridden programmatically</em>.  
* 7.0.15 fixes this issue. Overriding the "/" servlet mapping has also been tested  
* successfully under GlassFish 3.1.<p>  
*  
* @author Chris Beams  
* @since 3.1  
* @see SpringServletContainerInitializer  
* @see org.springframework.web.context.AbstractContextLoaderInitializer  
* @see org.springframework.web.servlet.support.AbstractDispatcherServletInitializer  
* @see org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer  
*/

多说一嘴，这个例子中用到了 DispatcherServlet 的有参构造（DispatcherServlet只有2个构造方法，一个无参一个有参，无参构造在其他文章中介绍了）。
这里就顺便详细看下这个有参构造的 javadoc

/*** 使用给定的 web 应用上下文来创建一个 DispatcherServlet。* 无参的构造是在 DispatcherServlet 内部自己创建维护 web 应用上下文。* 这个有参的构造是用外部传过来的 web 应用上下文。* 这个构造方法主要是用在 servlet 3.0+ 的环境中。* 用了这个构造方法以后，setContextClass setContextConfigLocation setContextAttribute setNamespace 这4个方法就无效了。* 对应的 contextClass contextConfigLocation contextAttribute namespace 等四个 servlet init-param 也无效了。* 传进来的 web 应用上下文可能已经 refresh() 了，也可能没有 refresh()。* 建议是不要 refresh()。* 如果不刷新的话，将会发生这些事情：* 1、如果传进来的web应用上下文还没有设置父应用上下文，则将 root web 应用上下文设置为它的父应用上下文。* 2、如果传进来的web应用上下文还没有设置id，将会给它设置一个id。* 3、将ServletContext和ServletConfig存到web应用上下文中。* 4、postProcessWebApplicationContext 方法会被调用。* 5、ApplicationContextInitializer 会被调用。可以用这个东西对web应用上下文进行自定义配置，其他文章也有提过。* 6、如果传进来的web应用上下文实现了ConfigurableApplicationContext的话，refresh()方法将会被调用。* 如果传进来的web应用上下文已经 refresh() 过了，上面提到的几点都不会发生。* * 另外，这个有参构造怎么用，可以参考 WebApplicationInitializer 接口。这不就跟本文写的代码对应上了么。** Create a new {@code DispatcherServlet} with the given web application context. This* constructor is useful in Servlet 3.0+ environments where instance-based registration* of servlets is possible through the {@link ServletContext#addServlet} API.* <p>Using this constructor indicates that the following properties / init-params* will be ignored:* <ul>* <li>{@link #setContextClass(Class)} / 'contextClass'</li>* <li>{@link #setContextConfigLocation(String)} / 'contextConfigLocation'</li>* <li>{@link #setContextAttribute(String)} / 'contextAttribute'</li>* <li>{@link #setNamespace(String)} / 'namespace'</li>* </ul>* <p>The given web application context may or may not yet be {@linkplain* ConfigurableApplicationContext#refresh() refreshed}. If it has <strong>not</strong>* already been refreshed (the recommended approach), then the following will occur:* <ul>* <li>If the given context does not already have a {@linkplain* ConfigurableApplicationContext#setParent parent}, the root application context* will be set as the parent.</li>* <li>If the given context has not already been assigned an {@linkplain* ConfigurableApplicationContext#setId id}, one will be assigned to it</li>* <li>{@code ServletContext} and {@code ServletConfig} objects will be delegated to* the application context</li>* <li>{@link #postProcessWebApplicationContext} will be called</li>* <li>Any {@code ApplicationContextInitializer}s specified through the* "contextInitializerClasses" init-param or through the {@link* #setContextInitializers} property will be applied.</li>* <li>{@link ConfigurableApplicationContext#refresh refresh()} will be called if the* context implements {@link ConfigurableApplicationContext}</li>* </ul>* If the context has already been refreshed, none of the above will occur, under the* assumption that the user has performed these actions (or not) per their specific* needs.* <p>See {@link org.springframework.web.WebApplicationInitializer} for usage examples.* @param webApplicationContext the context to use* @see #initWebApplicationContext* @see #configureAndRefreshWebApplicationContext* @see org.springframework.web.WebApplicationInitializer*/
public DispatcherServlet(WebApplicationContext webApplicationContext) {super(webApplicationContext);setDispatchOptionsRequest(true);
}