SpringMVC学习十九 Servlet 3.0整合Spring MVC

2022-07-17 10:33:37 阅读：141 来源： 互联网

标签：匹配 appDemo SpringMVC Servlet user 3.0 http 上下文 servlet

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

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、路径匹配和扩展名匹配无法同时设置