首页 > 其他分享> > SpringMVC学习十九 Servlet 3.0整合Spring MVC

SpringMVC学习十九 Servlet 3.0整合Spring MVC

2022-07-17 10:33:37 作者：互联网

10.1、Tomcat是如何自动加载Spring配置

10.1.1、SpringServletContainerInitializer

在Spring-web包下的META-IFN/services目录下有一个文件javax.servlet.ServletContainerInitializer，文件的内容是一个类的全路径名：

org.springframework.web.SpringServletContainerInitializer

SpringServletContainerInitializer类是一个实现了ServletContainerInitializer的类。SpringServletContainerInitializer会在tomcat启动时加载并运行其中的onStartup方法。这就是前面讲述的Servlet3.0规范中的内容。

SpringServletContainerInitializer的代码如下:

package org.springframework.web;

import java.lang.reflect.Modifier;
import java.util.LinkedList;
import java.util.List;
import java.util.ServiceLoader;
import java.util.Set;
import javax.servlet.ServletContainerInitializer;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.HandlesTypes;

import org.springframework.core.annotation.AnnotationAwareOrderComparator;


@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {

    
    @Override
    public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
            throws ServletException {

        List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>();

        if (webAppInitializerClasses != null) {
            for (Class<?> waiClass : webAppInitializerClasses) {
                // Be defensive: Some servlet containers provide us with invalid classes,
                // no matter what @HandlesTypes says...
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
                        WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        initializers.add((WebApplicationInitializer) waiClass.newInstance());
                    }
                    catch (Throwable ex) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                    }
                }
            }
        }

        if (initializers.isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
            return;
        }

        servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
        AnnotationAwareOrderComparator.sort(initializers);
        for (WebApplicationInitializer initializer : initializers) {
            initializer.onStartup(servletContext);
        }
    }

}

上述代码的目的是实例化WebApplicationInitializer接口的非抽象的所有子类，并循环调用这些子类的onStartup方法，参数为servletContext；

10.1.2、WebApplicationInitializer及其子类

WebApplicationInitializer接口的代码如下：

public interface WebApplicationInitializer {

    void onStartup(ServletContext servletContext) throws ServletException;

}

5.2.14继承图如下：

AbstractContextLoaderInitializer的作用创有两个：

创建一个ServletContextListener
通过createRootApplicationContext()方法创建一个AnnotationConfigWebApplicationContext的IOC容器作为根容器

代码如下：

protected void registerContextLoaderListener(ServletContext servletContext) {
        WebApplicationContext rootAppContext = createRootApplicationContext();
        if (rootAppContext != null) {
            ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
            listener.setContextInitializers(getRootApplicationContextInitializers());
            servletContext.addListener(listener);
        }
        else {
            logger.debug("No ContextLoaderListener registered, as " +
                    "createRootApplicationContext() did not return an application context");
        }
    }

AbstractDispatcherServletInitializer的作用也与两个：

创建一个dispatcherServlet实例，并配置映射路径等
通过createServletApplicationContext()方法创建第二个AnnotationConfigWebApplicationContext实例作为web容器
注册自定义的过滤器

代码如下：

protected void registerDispatcherServlet(ServletContext servletContext) {
        String servletName = getServletName();
        Assert.hasLength(servletName, "getServletName() must not return null or empty");

        WebApplicationContext servletAppContext = createServletApplicationContext();
        Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");

        FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
        Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
        dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());

        ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
        if (registration == null) {
            throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
                    "Check if there is another servlet registered under the same name.");
        }

        registration.setLoadOnStartup(1);
        registration.addMapping(getServletMappings());
        registration.setAsyncSupported(isAsyncSupported());

        Filter[] filters = getServletFilters();
        if (!ObjectUtils.isEmpty(filters)) {
            for (Filter filter : filters) {
                registerServletFilter(servletContext, filter);
            }
        }

        customizeRegistration(registration);
    }

AbstractAnnotationConfigDispatcherServletInitializer的作用实现父类以及祖先类中的一些抽象方法：

public abstract class AbstractAnnotationConfigDispatcherServletInitializer
        extends AbstractDispatcherServletInitializer {

    //创建一个根容器
    @Override
    @Nullable
    protected WebApplicationContext createRootApplicationContext() {
        Class<?>[] configClasses = getRootConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
            context.register(configClasses);
            return context;
        }
        else {
            return null;
        }
    }

    //创建SpringMVC容器
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        Class<?>[] configClasses = getServletConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            context.register(configClasses);
        }
        return context;
    }

    //Spring根配置类
    @Nullable
    protected abstract Class<?>[] getRootConfigClasses();

    //springMVC的配置类
    @Nullable
    protected abstract Class<?>[] getServletConfigClasses();

}

10.2、SpringMVC概述

Spring Web MVC是基于Servlet API构建的原始Web框架，并且从一开始就已包含在Spring框架中。正式名称“ Spring Web MVC”来自其源模块的名称（spring-webmvc），但通常称为“ Spring MVC”。

与Spring Web MVC并行，Spring Framework 5.0引入了一个反应式堆栈Web框架，其名称“ Spring WebFlux”也基于其源模块（spring-webflux）。本节介绍Spring Web MVC。下一节将介绍Spring WebFlux。

与其他许多Web框架一样，Spring MVC围绕前端控制器模式进行设计，在该模式下，核心Servlet DispatcherServlet提供了用于请求处理的共享算法，而实际工作是由可配置的委托组件执行的。该模型非常灵活，并支持多种工作流程。

DispatcherServlet与任何Servlet一样，都需要通过java规范或web.xm的方式进行声明与映射，且声明与映射必须根据Servlet规范进行。另外，DispatcherServlet可以使用Spring配置发现请求映射，视图解析，异常处理等所需的委托组件。

下例展示了通过java配置来注册和初始化DispatcherServlet:

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) {

        // Load Spring web application configuration
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        // Create and register the DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/app/*");
    }
}

下面的示例展示了通过web.xml配置来注册和初始化DispatcherServlet：

<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>

10.3、容器分层

对于许多应用程序而言，拥有一个WebApplicationContext很简单并且足够。也可能具有上下文层次结构，其中一个根WebApplicationContext在多个DispatcherServlet（或其他Servlet）实例之间共享，每个实例都有其自己的子WebApplicationContext配置。

根WebApplicationContext通常包含基础结构bean，例如需要在多个Servlet实例之间共享的数据存储库和业务服务。这些Bean是有效继承的，可以在Servlet特定的子WebApplicationContext中重写（即重新声明），该子WebApplicationContext通常包含给定Servlet本地的Bean。下图显示了这种关系：

实现原理：

要想很好理解这三个上下文的关系，需要先熟悉spring是怎样在web容器中启动起来的。spring的启动过程其实就是其IoC容器的启动过程，对于web程序，IoC容器启动过程即是建立上下文的过程。

spring的启动过程：

首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境；
其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListener会监听到这个事件，其contextInitialized方法会被调用，在这个方法中，spring会初始化一个启动上下文，这个上下文被称为根上下文，即WebApplicationContext，这是一个接口，确切的说，其实际的实现类是XmlWebApplicationContext。这个就是spring的IoC容器，其对应的Bean定义的配置由web.xml中的context-param标签指定。在这个IoC容器初始化完毕后，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，将其存储到ServletContext中，便于获取；
```
ContextLoaderListener的contextInitialized方法中，调用父类的ContextLoader的initWebApplicationContext方法。
在initWebApplicationContext方法中创建根容器，并servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);语句把根容器设置到servletContext中
```
再次，contextLoaderListener监听器初始化完毕后，开始初始化web.xml中配置的Servlet，这个servlet可以配置多个，以最常见的DispatcherServlet为例，这个servlet实际上是一个标准的前端控制器，用以转发、匹配、处理每个servlet请求。DispatcherServlet上下文在初始化的时候会建立自己的IoC上下文，用以持有spring mvc相关的bean。在建立DispatcherServlet自己的IoC上下文时，会利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先从ServletContext中获取之前的根上下文(即WebApplicationContext)作为自己上下文的parent上下文。有了这个parent上下文之后，再初始化自己持有的上下文。这个DispatcherServlet初始化自己上下文的工作在其initStrategies方法中可以看到，大概的工作就是初始化处理器映射、视图解析等。这个servlet自己持有的上下文默认实现类也是xmlWebApplicationContext。初始化完毕后，spring以与servlet的名字相关(此处不是简单的以servlet名为Key，而是通过一些转换，具体可自行查看源码)的属性为属性Key，也将其存到ServletContext中，以便后续使用。这样每个servlet就持有自己的上下文，即拥有自己独立的bean空间，同时各个servlet共享相同的bean，即根上下文(第2步中初始化的上下文)定义的那些bean。

Dispatcher继承图：

HttpServletBean.init()方法调用initServletBean()方法,initServletBean在类HttpServlet中是空方法，所以最终调用的是子类FrameworkServlet的initServletBean方法。

FrameworkServlet.initServletBean()方法中调用initWebApplicationContext方法，在initWebApplicationContext方法中完成父容器的设置

protected WebApplicationContext initWebApplicationContext() {
    //获取根上下文容器
        WebApplicationContext rootContext =
                WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;

        if (this.webApplicationContext != null) {
            // 在构造时注入了一个上下文实例->使用它
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                if (!cwac.isActive()) {
                    // 上下文尚未刷新->提供诸如设置父上下文，设置应用程序上下文ID等服务。
                    if (cwac.getParent() == null) {
                        //当前上下文容器没有父容器，将根应用程序上下文（如果有；可能为null）设置为父级
                        cwac.setParent(rootContext);
                    }
                    configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            // 在构造时未注入任何上下文实例->查看是否已在servlet上下文中注册了一个实例。 如果存在，则假定已经设置了父上下文（如果有），并且用户已经执行了任何初始化操作，例如设置了上下文ID。
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            //没有为此Servlet定义上下文实例->创建本地实例
            // No context instance is defined for this servlet -> create a local one
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            synchronized (this.onRefreshMonitor) {
                onRefresh(wac);
            }
        }

        if (this.publishContext) {
            // 将上下文发布为servlet上下文属性。
            String attrName = getServletContextAttributeName();
            getServletContext().setAttribute(attrName, wac);
        }

        return wac;
    }

10.4、Servlet中的url-pattern匹配规则

首先需要明确几容易混淆的规则：

servlet容器中的匹配规则既不是简单的通配，也不是正则表达式，而是特定的规则。所以不要用通配符或者正则表达式的匹配规则来看待servlet的url-pattern。
Servlet 2.5开始，一个servlet可以使用多个url-pattern规则，servlet-mapping标签声明了与该servlet相应的匹配规则，每个url-pattern标签代表1个匹配规则；
当servlet容器接收到浏览器发起的一个url请求后，容器会用url减去当前应用的上下文路径，以剩余的字符串作为servlet映射，假如url是http://localhost:8080/appDemo/index.html，其应用上下文是appDemo，容器会将http://localhost:8080/appDemo去掉，用剩下的/index.html部分拿来做servlet的映射匹配
url-pattern映射匹配过程是有优先顺序的
而且当有一个servlet匹配成功以后，就不会去理会剩下的servlet了

10.4.1、精确匹配

url-pattern中配置的项必须与url完全精确匹配。

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/user/users.html</url-pattern>
    <url-pattern>/index.html</url-pattern>
    <url-pattern>/user/addUser.action</url-pattern>
</servlet-mapping>

当在浏览器中输入如下几种url时，都会被匹配到该servlet

　http://localhost:8080/appDemo/user/users.html 　

　http://localhost:8080/appDemo/index.html 　

　http://localhost:8080/appDemo/user/addUser.action

注意：

　　http://localhost:8080/appDemo/user/addUser/ 是非法的url，不会被当作http://localhost:8080/appDemo/user/addUser识别。

　　另外上述url后面可以跟任意的查询条件，都会被匹配，如http://localhost:8080/appDemo/user/addUser?username=Tom&age=23 会被匹配到MyServlet。

10.4.2、路径匹配

以“/”字符开头，并以“/*”结尾的字符串用于路径匹配

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/user/*</url-pattern>
</servlet-mapping>

路径以/user/开始，后面的路径可以任意。比如下面的url都会被匹配。　　

http://localhost:8080/appDemo/user/users.html 　　

http://localhost:8080/appDemo/user/addUser.action 　　

http://localhost:8080/appDemo/user/updateUser.actionl

10.4.3、扩展名匹配

以“*.”开头的字符串被用于扩展名匹配

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

则任何扩展名为jsp或action的url请求都会匹配，比如下面的url都会被匹配　　

http://localhost:8080/appDemo/user/users.jsp 　　

http://localhost:8080/appDemo/toHome.action

10.4.4、缺省匹配

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

10.4.5、匹配顺序

精确匹配，

servlet-mapping1：
```
<url-pattern>/user/users.html</url-pattern>
```
servlet-mapping2：
```
<url-pattern>/*</url-pattern>
```
当一个请求http://localhost:8080/appDemo/user/users.html来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
路径匹配，先最长路径匹配，再最短路径匹配

servlet-mapping1：
```
<url-pattern>/user/*</url-pattern>
```
servlet-mapping2：
```
<url-pattern>/*</url-pattern>
```
当一个请求http://localhost:8080/appDemo/user/users.html来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
扩展名匹配

servlet-mapping1：
```
<url-pattern>/user/*</url-pattern>
```
servlet-mapping2：
```
<url-pattern>*.action</url-pattern>
```
当一个请求http://localhost:8080/appDemo/user/addUser.action来的时候，servlet-mapping1匹配到，不再用servlet-mapping2匹配
缺省匹配，以上都找不到servlet，就用默认的servlet，配置为
```
<url-pattern>/</url-pattern>
```

10.4.6、注意事项

1、路径匹配和扩展名匹配无法同时设置

　　匹配方法只有三种，要么是路径匹配（以“/”字符开头，并以“/*”结尾），要么是扩展名匹配（以“*.”开头），要么是精确匹配，三种匹配方法不能进行组合，不要想当然使用通配符或正则规则。

　　如下

<url-pattern>/user/*.action</url-pattern>路径是非法的

　　另外注意：

<url-pattern>/aa/*/bb</url-pattern>是精确匹配，合法，这里的*不是通配的含义

2 、"/*"和"/"含义并不相同

/*属于路径匹配，并且可以匹配所有request，由于路径匹配的优先级仅次于精确匹配，所以/*会覆盖所有的扩展名匹配，很多404错误均由此引起，所以这是一种特别恶劣的匹配模式，一般只用于filter的url-pattern

“/”是servlet中特殊的匹配模式，切该模式有且仅有一个实例，优先级最低，不会覆盖其他任何url-pattern，只是会替换servlet容器的内建default servlet ，该模式同样会匹配所有request。

配置“/”后，一种可能的现象是myServlet会拦截诸如http://localhost:8080/appDemo/user/addUser.action、http://localhost:8080/appDemo/user/updateUser的格式的请求，但是并不会拦截http://localhost:8080/appDemo/user/users.jsp、http://localhost:8080/appDemo/index.jsp，这是因为servlet容器有内置的“*.jsp”匹配器，而扩展名匹配的优先级高于缺省匹配，所以才会有上述现象。

3、默认Servlet

Tomcat在%CATALINA_HOME%\conf\web.xml文件中配置了默认的Servlet

代码如下：

<servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
<servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
 </servlet>
<servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern> 
</servlet-mapping>

    <!-- The mappings for the JSP servlet -->
<servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
        <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

“/*”和“/”均会拦截静态资源的加载，需要特别注意

标签：匹配,appDemo,SpringMVC,Servlet,user,3.0,http,上下文,servlet
来源： https://www.cnblogs.com/cplinux/p/16486012.html

SpringMVC学习 十九 Servlet 3.0整合Spring MVC

10.1、Tomcat是如何自动加载Spring配置

10.1.1、SpringServletContainerInitializer

10.1.2、WebApplicationInitializer及其子类

10.2、SpringMVC概述

10.3、容器分层

10.4、Servlet中的url-pattern匹配规则

10.4.1、精确匹配

10.4.2、路径匹配

10.4.3、扩展名匹配

10.4.4、缺省匹配

10.4.5、匹配顺序

10.4.6、注意事项

1、 路径匹配和扩展名匹配无法同时设置

2 、"/*"和"/"含义并不相同

3、默认Servlet

SpringMVC学习十九 Servlet 3.0整合Spring MVC

1、路径匹配和扩展名匹配无法同时设置