Spring MVC官方文档学习笔记（二）之DispatcherServlet

1.DispatcherServlet入门

(1) Spring MVC是以前端控制器模式(即围绕着一个中央的Servelt, DispatcherServlet)进行设计的,这个DispatcherServlet为请求的处理提供了一个共用的算法,即它都会将实际的请求处理工作委托给那些可配置的组件进行执行,说白了,DispatcherServlet的作用就是进行统一调度,并控制请求的处理流程,和其他的Servlet一样，DispatcherServlet需要根据Servlet规范，使用基于Java的配置或在web.xml中进行声明,与此同时,DispatcherServlet会使用Spring相关配置来发现它在请求映射、视图解析、异常处理等方面所需要的组件,而实际的工作也会交由这些组件进行执行，下面列出了注册DispatcherServlet的一些方式

@Configuration
@ComponentScan("cn.example.springmvc.boke")
public class WebConfig {
}

//使用基于Java的配置,注册并初始化一个DispatcherServlet
public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        //声明一个Spring-web容器
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(WebConfig.class);

        //创建并注册DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(ctx);
        //动态的添加Servlet
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcherServlet", servlet);
        registration.setLoadOnStartup(1);
        //指定由DispatcherServlet拦截所有请求(包括静态资源，但不拦截.jsp)
        registration.addMapping("/");
    }
}

上述是基于Java的配置,我们还可以基于web.xml来配置DispatcherServlet,如下

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

    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

(2) 现在DispatcherServlet有了,我们还需要@Controller与@RequestMapping注解,来标注某个访问应该由谁进行处理,如下,而到此为止,我们就已经完全不需要编写HttpServlet相关的内容了,可见通过DispatcherServlet帮助我们免去了冗杂的Servlet映射配置

@Controller
public class DemoController {
    @RequestMapping("/demo")
    @ResponseBody
    public String get(HttpServletRequest request) {
        return "aaa";
    }
}

启动容器,访问 http://localhost:8080/springmvc/demo, 页面显示aaa,说明访问正常,这便是我们的第一个Spring MVC项目

2.Spring容器的层次结构

(1) 根容器与Servlet子容器

通常情况下,一个web应用中有一个唯一的WebApplicationContext容器就足够了,但Spring还允许我们配置具有父子关系的根容器和它的Servlet子容器,来形成一个层次结构,如上图所示,可以很清楚的看到,Spring将表示层相关的组件全部放到了子容器中,而将公共的与基础服务有关的组件全部放到了根容器中,这样的话,当我们需要注册多个DispatcherServlet并共享那些基础服务组件的时候，不必重复注册Service和Dao了，因为每个Servlet子容器都可以从这个根容器中获取到Service和Dao,这便是层次结构的意义

当然，Spring也支持单容器配置，如开头中的示例那样，此外我们可以通过继承AbstractAnnotationConfigDispatcherServletInitializer来配置父子容器，如下

//配置父子容器，其中容器使用基于注解的配置方式
public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    //配置 DispatcherServlet 拦截的路径
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }

    //设置根容器的配置类
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] {RootConfig.class};
    }

    //设置子容器的配置类
    //如果不想形成父子容器，那么只需将下面这个getServletConfigClasses()方法返回null即可
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {WebConfig.class};
    }
}

//由于我们采用的是父子容器，因此这就要求我们编写父子容器的配置文件时，根容器的配置文件(RootConfig)配置非web组件的bean，而子容器的配置文件(WebConfig)配置web组件的bean，同时，也要防止同一组件在不同容器中分别注册初始化，从而出现两个相同bean
//根容器配置类，使用excludeFilters排除掉@Controller注解标注的类和@Configuration注解标注的类，这里之所以要排除掉@Configuration注解标注的类，是为了防止根容器扫描到子容器的配置类WebConfig
@Configuration
@ComponentScan(value = "cn.example.springmvc.boke",
                excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class),
                        @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Configuration.class)
                })
public class RootConfig {
}

//子容器配置类，使用includeFilters指定只扫描由@Controller注解标注的类
@Configuration
@ComponentScan(value = "cn.example.springmvc.boke",
        includeFilters = @ComponentScan.Filter(value = Controller.class, type = FilterType.ANNOTATION))
public class WebConfig {
}

也可以基于web.xml来配置父子容器，如下

<web-app ....>
    <!-- ContextLoaderListener用于配置根容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 设置根容器的xml配置文件路径 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springroot.xml</param-value>
    </context-param>

    <!-- DispatcherServlet用于配置子容器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 设置子容器的xml配置文件路径 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springweb.xml</param-value>
        </init-param>
    </servlet>
    
    <!-- 设置 DispatcherServlet 拦截的路径  -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3.特殊类型的bean

(1) 前面已经提过了，DispatcherServlet会将实际的请求处理过程委托给那些特殊的组件来干，而它本身起一个统一分配与调度的作用，这些特殊的组件已经由Spring提供了默认的实现，但同时Spring也允许我们自己实现替换它们，下表列出了由 DispatcherServlet检测到的这些特殊的Bean类型

4.Web MVC配置

(1) 我们可以自定义在上一节中所列出来的那些特殊的bean，DispatcherServlet会检查它们，如果没有，那么它将会使用DispatcherServlet.properties中所列出的默认类型的bean，如下

5.Servlet 配置

(1) 在Servlet环境中，我们可以选择以编程式的方式或基于web.xml的方式来配置Servlet容器，在本篇开头的位置也提到过了，如下是一个基于编程式的例子

public class IocInit implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        //创建一个基于xml配置的容器
        XmlWebApplicationContext appContext = new XmlWebApplicationContext();
        appContext.setConfigLocation("classpath:springmvc.xml");

        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcherServlet", new DispatcherServlet(appContext));
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

WebApplicationInitializer是由Spring MVC提供的一个接口，Spring MVC会确保该接口的实现类们会被正确调用以初始化Servlet容器，WebApplicationInitializer有一个抽象基类为AbstractDispatcherServletInitializer，通过继承该基类可以使得注册DispatcherServlet更加容易

(2) 除了上面的例子之外，还可以使用基于java的Spring配置，如下，前面也提到过了

public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    //创建一个基于注解配置的容器
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {WebConfig.class};
    }
}

(3) 除此之外，还可以继承AbstractDispatcherServletInitializer

public class IocInit extends AbstractDispatcherServletInitializer {
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        XmlWebApplicationContext cxt = new XmlWebApplicationContext();
        cxt.setConfigLocation("classpath:springmvc.xml");
        return cxt;
    }

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}

上面列出了常见的3种创建ioc容器的方式，我们可以根据自己的需要来进行选择

(4) AbstractDispatcherServletInitializer还提供了一种便捷的方式来创建Filter实例，并且这些Filter实例会被自动映射到DispatcherServlet上，如下

public class IocInit extends AbstractDispatcherServletInitializer {

    //...
    
    //这些Filter会被自动映射到DispatcherServlet上，并且会根据它们的类型来为其添加一个默认名称
    @Override
    protected Filter[] getServletFilters() {
        return new Filter[] {
                new HiddenHttpMethodFilter(), new CharacterEncodingFilter() };
    }
}

此外，如果我们希望需要进一步的定制DispatcherServlet，我们可以重写createDispatcherServlet方法

6.请求处理

(1) DispatcherServlet按照如下的方式来处理请求：

• 搜索WebApplicationContext并将其作为一个属性绑定到请求中，这样在请求的后续处理过程中我们就可以直接从请求中拿到ioc容器，如下

@Controller
public class DemoController {
    @RequestMapping("/demo")
    @ResponseBody
    public String get(HttpServletRequest httpServletRequest) {
        //从请求中获取到WebApplicationContext，这个ioc容器被绑定到了请求的DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE属性上
        WebApplicationContext ctx = (WebApplicationContext)httpServletRequest.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        Arrays.stream(ctx.getBeanDefinitionNames()).forEach(System.out::println);
        return "aaa";
    }
}

• Locale解析器也被绑定到了请求上，以便后续处理流程中进行使用

• Theme解析器也被绑定到了请求上，以便后续处理流程中进行使用

• 如果我们指定了multipart文件解析器，那么Spring会检查请求中是否含有multipart文件，如果有，那么该请求会被包裹在一个MultipartHttpServletRequest中，以便后续处理流程中进行进一步处理

• 针对请求搜索恰当的handler，如果搜索到的话，与该handler相关的执行链（HandlerExecutionChain）将会被执行，以准备渲染模型（model）

• 如果有模型返回，那么视图（view）就会被渲染，否则，如果没有模型返回，那么视图就不会被渲染

(2) 在WebApplicationContext中的HandlerExceptionResolver类型的bean将被用来解决请求处理过程中抛出的异常，这些异常解析器允许自定义处理异常的逻辑

(3) 我们可以在web.xml中的标签使用标签来添加Servlet初始化参数，这样就能达到定制DispatcherServlet的目的，下面列出了DispatcherServlet常见的初始化参数

具体的配置例子如下

<web-app ....>

    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置容器，容器需要实现ConfigurableWebApplicationContext接口，此处我们选择了XmlWebApplicationContext，这也是Spring的默认配置 -->
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
        </init-param>

        <!-- 因为我们上面选用的是XmlWebApplicationContext，一个基于xml配置的容器，因此通过contextConfigLocation属性来设置容器的xml配置文件路径 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springweb.xml</param-value>
        </init-param>

        <!-- 如下是配置一个基于注解的容器 -->
<!--        <init-param>-->
<!--            <param-name>contextClass</param-name>-->
<!--            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>-->
<!--        </init-param>-->
        <!-- 因为是基于注解的容器，因此通过contextConfigLocation属性来设置Configuration配置类的路径 -->
<!--        <init-param>-->
<!--            <param-name>contextConfigLocation</param-name>-->
<!--            <param-value>cn.example.springmvc.boke.config.Config</param-value>-->
<!--        </init-param>-->

        <!-- 设置WebApplicationContext的命名空间 -->
        <init-param>
            <param-name>namespace</param-name>
            <param-value>app</param-value>
        </init-param>

        <!-- 注意，单单将这个值设置为true，并不会生效(即不会抛出NoHandlerFoundException异常)，原因是Spring会默认加上ResourceHttpRequestHandler这个handler来进行处理，也就不会出现no handler的情况了，因此我们还需要配置spring.resources.add-mappings=false，这样在发生no handler时才会抛出NoHandlerFoundException异常 -->
        <init-param>
            <param-name>throwExceptionIfNoHandlerFound</param-name>
            <param-value>true</param-value>
        </init-param>
    </servlet>

    <!-- 设置 DispatcherServlet 拦截的路径  -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

7.拦截器

(1) 拦截器必须实现HandlerInterceptor接口，该接口提供了3个方法，分别为

• preHandle(..): 在handler执行之前执行

• postHandle(..): 在handler执行之后执行

• afterCompletion(..): 在整个请求完成后执行

preHandle方法返回一个boolean值，通过该方法我们可以决定是继续还是中断执行链的执行，若返回true，则执行链继续执行，若返回false，则DispatcherServlet会认为拦截器本身已经处理了该请求，因此会中断执行链中其他的拦截器以及handler的执行

postHandle方法在有@ResponseBody和ResponseEntity的方法中用处不大，因为这种方法在postHandle方法执行前已经在写入response了，等待postHandle方法执行时已经太迟了，而针对这种情况，我们可以使用ResponseBodyAdvice

8.异常

(1) 如果在请求映射处理过程中发生异常，DispatcherServlet会委托一个由HandlerExceptionResolver构成的异常处理链来处理这个异常，下面列出一些可用的HandlerExceptionResolver实现类

(2) 我们可以在容器中配置多个HandlerExceptionResolver类型的bean并根据需要设置它们的order属性来形成一个异常处理器链，其中order属性值越高，它在异常处理器链中的位置就越靠后，通常情况下，HandlerExceptionResolver返回

• 一个指向错误视图的ModelAndView

• 若异常在处理器中被处理，返回一个空的ModelAndView

• 若异常未被解决，则返回null，以便让后续的处理器尝试解决，如果到最后异常仍未解决，则允许将异常冒泡到Servlet容器中

使用MVC Config(通过@EnableWebMvc注解)后，会自动的向容器中添加Spring MVC异常，由@ResponseStatus注解标注的异常等异常的处理器，我们可以对它们进行替换

(3) 如果一个异常没有被任何HandlerExceptionResolver处理或者请求的http响应被设置为错误状态（即4xx，5xx），那么Servlet容器使用HTML来渲染一个默认的错误页面，而为了自定义容器的默认错误页面，我们可以在web.xml中配置错误页面映射url，如下

<error-page>
    <location>/error</location>
</error-page>

当配置好错误页面映射url后，如果此时有一个异常没有被任何HandlerExceptionResolver处理或者请求的http响应被设置为错误状态，那么Servlet容器将会请求我们所配置的这个url，此时，我们就可以返回一个自定义的错误视图或像下面这样直接返回一个字符串

@RequestMapping("/error")
@ResponseBody
public String error() {
    return "error";
}

9. view，locale，theme和logging这四节的内容略过，如果有需要可查看官方文档

10. Multipart解析器

(1) org.springframework.web.multipart包中的MultipartResolver可用于解析multipart类型(例如：文件上传)的请求，为了使用Multipart解析器，我们需要配置一个MultipartResolver类型的bean，并且这个bean的名称必须是multipartResolver，配置好之后，DispatcherServlet会检测到它并将其应用于后续的请求，当我们接收到一个类型为multipart/form-data的post请求时，Multipart解析器会解析请求内容并将当前这个HttpServletRequest包装成MultipartHttpServletRequest以便访问解析的内容，Spring MVC已为我们提供了两个MultipartResolver的实现类，如下

• CommonsMultipartResolver：基于Apache Commons FileUpload的MultipartResolver实现类，为了使用它，需要添加commons-fileupload依赖

• StandardServletMultipartResolver：基于Servlet 3.0 multipart请求解析的MultipartResolver实现类，为了使用它，我们需要在<web.xml/>或Servlet registration中进行一些配置:

<!-- 在web.xml的<servlet/>标签中添加<multipart-config/>标签,配置上传文件的大小等信息 -->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <multipart-config>
        <location>/</location>
        <max-file-size>2097152</max-file-size>
        <max-request-size>419304</max-request-size>
    </multipart-config>
</servlet>

也可在Servlet registration中进行配置

public class IocInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] {RootConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {WebConfig.class};
    }

    //使用ServletRegistration配置上传文件大小等信息
    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
        registration.setMultipartConfig(new MultipartConfigElement("/", 2097152, 419304, 0));
    }
}

热门相关：最强狂兵   重生当学神，又又又考第一了！   修仙界最后的单纯   学霸女神超给力   朕