1. 什么是MVC
2. DispatcherServlet的配置
3. DispatcherServlet的工作原理
4. 一个简单的GET和POST控制器的例子
5. Servlet 3.0方式配置DispatcherServlet
6. Spring MVC简单的类配置

什么是MVC

1. 在Web容器初始化的时候插入一个DispatcherServlet, 用这个Servlet拦截符合要求的所有Web请求, 一般是拦截全部请求.
2. DispatcherServlet解析Http请求信息, 根据其中的内容和HandlerMapping类, 确定对应的Handler. 所谓Handler, 就是处理请求的对象, Spring MVC并没有一个Handler接口, 任意类只要符合要求, 都可以当成处理请求的对象
3. Spring采取反射技术, 使用一个HandlerAdapter接口来适配所有的Handler, 并且来调用相关的方法.
4. Handler完成处理请求之后, 会返回一个ModelAndView对象给DispatcherServlet, 即使你的Handler的代码中没有显式返回ModelAndView对象, 框架最后也会让你的Handler实际上返回ModelAndView对象.
5. DispatcherServlet拿到ModelAndView之后, 从里边获取逻辑视图名称, 然后使用ViewResolver将逻辑视图名称解析成真正的视图对象(文件)路径.
6. 得到视图对象后, 使用Model中的数据, 渲染视图对象. 将渲染结果写入到Http响应中.
7. 将Http响应发回给客户端, 根据渲染的结果, 客户端会得到不同的media-type对应的内容.

DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">

    //第一部分
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:/applicationContext.xml</param-value>
    </context-param>

    //第二部分
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    //第三部分
    <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-mvc-crm.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>
</web-app>

1. 首先这是一个web.xml, 所以最先启动的并不是Spring, 而是Web容器, 就像IDEA里如果创建Spring, 启动的是Tomcat, 而不是某个具体的Spring IOC容器. Web容器启动的时候最先干什么呢, 当然就是生成一个ServletContext, 即Web容器的上下文. 在这个时候Web容器还没有完全启动, 因为Servlet都还没有创建.
2. Web容器之后会继续启动, 来读取web.xml文件的第一部分, 可以知道, 这些是给Web容器看的, 实际上就是给Web容器配置上了一个属性和对应的值.
3. Web容器启动的是第二部分的配置, 也就是监听器, 还记得之前学JSP的时候, 监听器是比Servlet要早启动的. 这个监听器是Spring框架里的监听器, 既然是Spring框架的, 很显然就是要做点事情了.
4. ContextLoaderListener监听器启动的时候, 在JSP中可以知道, 监听器是可以获取ServletContext对象的, 这个监听器就获取了当前Web容器的上下文, 然后去找这个contextConfigLocation属性对应的配置文件的路径, 然后使用这个配置文件, 启动一个Spring IOC容器, 通过之前的学习, 知道这其实是一个XmlWebApplicationContext对象.
5. 监听器创建了Spring 容器之后, 将这个容器以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为key, 将其存储到ServletContext里, 这样Web容器就有了对这个Spring IOC容器的引用.
6. 监听器工作完毕. 带有了Spring IOC容器引用的Web容器继续向下创建Servlet对象, 这里的Servlet对象是DispatcherServlet.
7. DispatcherServlet创建过程中, 会从ServletContext里获取刚刚的Spring IOC容器, 将其设置成为自己的父容器.
8. DispatcherServlet有了父容器对象后, 再初始化自己的上下文, 也是一个IOC容器. 这个上下文中就存放了视图解析, 映射等一系列所需要的服务Bean. 最后会将自己的这个子IOC容器, 也设置到ServletContext中.
9. 全部的Servlet创建完毕之后, Web容器成功启动. 此时Web容器中有一个父IOC容器, 还有一个子IOC容器(也可能有多个). 父IOC容器中的Bean被所有的子IOC容器共享. 每个子IOC容器中的Bean是属于自己的.

1. contextConfigLocation, 表示子IOC容器创建的时候对应的配置文件路径, 可以使用完整路径, classpath:等写法, 还可以使用逗号分割多个xml文件, 会一并使用这些配置文件来创建子IOC.
2. nameSpace, 表示这个DispatcherServlet对应的命名空间, 如果显示配置了该属性, 配置文件就变成WEB-INF/<nameSpace>.xml. 如果不配置, 默认配置文件是WEB-INF/<servlet-name>-servlet.xml.
3. publishContext, 布尔值, 表示是否将子IOC容器设置到Web容器的上下文里, 默认是true, 也就是上边的标准启动流程. 如果设置的话, key属性名是.getServeltContextAttributeName()的返回值.
4. publishEvents, 布尔值, 默认为true. 表示每次DispatcherServlet处理完一个请求之后, 是否向Web容器内发布一个ServletRequestHandlerEvent事件. 如果不需要监听此事件, 可以将该属性设置为false.

DispatcherServlet的工作原理

protected void initStrategies(ApplicationContext context) {
        this.initMultipartResolver(context);
        this.initLocaleResolver(context);
        this.initThemeResolver(context);
        this.initHandlerMappings(context);
        this.initHandlerAdapters(context);
        this.initHandlerExceptionResolvers(context);
        this.initRequestToViewNameTranslator(context);
        this.initViewResolvers(context);
        this.initFlashMapManager(context);
    }

private void initMultipartResolver(ApplicationContext context) {
    try {
        this.multipartResolver = (MultipartResolver)context.getBean("multipartResolver", MultipartResolver.class);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Detected " + this.multipartResolver);
        } else if (this.logger.isDebugEnabled()) {
            this.logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
        }
    } catch (NoSuchBeanDefinitionException var3) {
        this.multipartResolver = null;
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("No MultipartResolver 'multipartResolver' declared");
        }
    }

}

//默认的DispatcherServlet生成的实现类, 用于在没有子IOC容器中找到对应的Bean使用, 不要更改此文件
# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

1. MultipartResolver, 这个没有写在properties文件中, 是通过方法来定义的. 如果没有显式定义, 不会自行创建, 不存在该Bean
2. LocaleResolver, 这个i18n之后的, 是本地化解析器. 如果没有显式定义, 不会自行创建, 不存在该Bean
3. ThemeResolver, 主题解析器, 如果没有显式定义, 不会自行创建, 不存在该Bean
4. HandlerMapping, 非常重要的请求处理器的映射, 如果没有显式定义, 会创建文件里的两个Bean
5. HandlerAdapter, 也是非常重要的, 如果没有显式定义, 会创建三个适配器类, 添加到适配器列表中
6. HandlerExceptionResolver, 异常处理器, 如果没有显式定义, 也会自行创建.
7. RequestToViewNameTranslator, 视图名称翻译器, 查找名称为viewNameTranslator, 类型是RequestToViewNameTranslator的Bean, 如果找不到, 就会用上边的默认实现类创建Bean.
8. ViewResolver, 非常重要的视图解析器, 不显式配置也会创建.

一个简单的GET和POST控制器的例子

@Controller与@RequestMapping

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/register")
    public String register() {
        return "user/register";
    }
}

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/view/"/>
    <property name="suffix" value=".jsp"/>
</bean>

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>用户注册</title>
</head>
<body>
<form method="post" action="<c:url value="/user"/>">
    <table>
        <tr>
            <td>用户名: </td>
            <td><input type="text" name="userName"></td>
        </tr>
        <tr>
            <td>密码: </td>
            <td><input type="password" name="password"></td>
        </tr>
        <tr>
            <td>姓名: </td>
            <td><input type="text" name="realName"></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" name="提交"></td>
        </tr>
    </table>
</form>
</body>
</html>

处理POST请求

    @RequestMapping(path = "/user",method = RequestMethod.POST)
    public ModelAndView createUser(User user) {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("user/createSuccess");
        modelAndView.addObject("user", user);
        return modelAndView;
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <meta charset="UTF-8">
    <title>成功创建用户</title>
</head>
<body>
<p>${user.userName}创建成功.</p>
<p>详细信息是:</p>
<ol>
    <li>${user}</li>
</ol>

</body>
</html>

<filter>
    <description>字符编码过滤器</description>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Servlet 3.0方式配置DispatcherServlet

package cc.conyli.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class MyDispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    //这个方法指定配置父IOC容器的类, 返回配置类的class列表
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }

    //这个方法指定配置子IOC容器的配置类, 返回配置类的class列表
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    //ServletMapping, 也就是DispatcherServlet对应的路径, 一般设置成"/". 因为是一个列表, 实际上可以设置多个.
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

//Web容器启动完毕, 在部署项目
[2020-02-12 03:40:37,450] Artifact securitydemo:war: Artifact is being deployed, please wait...
//容器在扫描ServletContainerInitializer接口类
12-Feb-2020 15:40:42.350 淇℃伅 [RMI TCP Connection(3)-127.0.0.1] org.apache.jasper.servlet.TldScanner.scanJars
//配置父容器
12-Feb-2020 15:40:42.443 淇℃伅 [RMI TCP Connection(3)-127.0.0.1] org.springframework.web.context.ContextLoader.initWebApplicationContext Root WebApplicationContext: initialization started
12-Feb-2020 15:40:42.976 淇℃伅 [RMI TCP Connection(3)-127.0.0.1] org.springframework.web.context.ContextLoader.initWebApplicationContext Root WebApplicationContext initialized in 533 ms
//创建DispatcherServlet, 同时会创建子容器
12-Feb-2020 15:40:43.593 淇℃伅 [RMI TCP Connection(3)-127.0.0.1] org.springframework.web.servlet.FrameworkServlet.initServletBean Initializing Servlet 'dispatcher'
12-Feb-2020 15:40:44.040 淇℃伅 [RMI TCP Connection(3)-127.0.0.1] org.springframework.web.servlet.FrameworkServlet.initServletBean Completed initialization in 446 ms

Spring MVC简单的类配置

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
public class WebConfig {
}

package cc.conyli.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
//启用组件扫描并配置扫描的目录. 准备将所有Web相关的内容放置到web包内
@ComponentScan("cc.conyli.web")
public class WebConfig extends WebMvcConfigurationSupport {

    @Bean
    @Override
    public ViewResolver mvcViewResolver() {
        System.out.println("执行了解析器");
        InternalResourceViewResolver resourceViewResolver = new InternalResourceViewResolver();
        resourceViewResolver.setPrefix("/WEB-INF/views/");
        resourceViewResolver.setSuffix(".jsp");
        resourceViewResolver.setExposeContextBeansAsAttributes(true);
        return resourceViewResolver;
    }

    @Override
    protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}