SpringMVC详解
SpringMVC概念概念springmvc：是基于spring的一个框架，实际上就是spring的一个专门做web开发的模块。可以理解成servlet的升级。web开发的底层是servletspringmvc能够创建对象（控制器对象）:springmvc使用的是@controller注解创建控制器对象，放入到容器中（springmvc容器），springmvc容器中放入的是控制器对象。...
SpringMVC
SpringMVC 概念
springmvc：是基于spring的一个框架，实际上就是spring的一个专门做web开发的模块。可以理解成servlet的升级。web开发的底层是servlet。
springmvc能够创建对象（控制器对象）:springmvc使用的是@controller注解创建控制器对象，放入到容器中（springmvc容器），springmvc容器中放入的是控制器对象。使用@Controller注解创建的是一个普通了类的对象，不是Servlet。springmvc赋予了控制器对象一些额外的功能。
Web开发的底层是servlet：springmvc中有一个对象是servlet——DispatcherServlet（中央调度器）
DispatcherServle：负责接收客户端（Browser）或者用户所有的请求，用户把请求给了DispatcherServlet，之后DispatcherServlet将请求转发或分发给Controller对象，最后是Controller对象处理请求。
重点：在web.xml中注册springmvc框架核心对象DispatcherServlet1、DispatcherServlet叫做中央调度器（也叫：前端控制器），是一个Servlet，他的父类是HttpsServlet。
2、DispatcherServlet负责接收用户提交的请求，调用其他的控制器对象，并把请求的处理结果返回并显示给用户。
SpringMVC的架构
DispatcherServlet：前端控制器，也叫中央调度器
1、负责创建springmvc容器对象，读取springmvc.xml配置文件，创建文件中的Controller对象
2、负责接收用户的请求，分派或转发给自定义的Controller对象。
处理器和控制器：有@Controller注解修饰的Controller类
SpringMVC的核心配置及代码
1、springmvc的maven依赖
<!--spring-mvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
2、springmvc的核心配置文件springmvc.xml
加入<context:component-scan base-package="xxx"/>进行包扫描
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--声明组件扫描器-->
<context:component-scan base-package="com.springmvc"/>
<!--处理静态资源的方式（两种：二者选其一即可）-->
<!--第一种处理静态资源的方式（依赖服务器）
需要在springmvc.xml配置文件中加入 <mvc:default-servlet-handler/>
原理：加入这个标签后，框架会创建控制器对象 DefaultServletHttpRequestHandler处理器对象（类似自己创建的MyController）。
DefaultServletHttpRequestHandler这个对象可以吧接受的请求转发给tomcat的default这个servlet。
-->
<mvc:default-servlet-handler/>
<!--第二种处理静态资源的方式
<mvc:reources mapping="" location="" /> 加入后框架会创建 ResourceHttpRequestHandler这个处理器对象，
这个对象是处理静态资源的访问，不依赖tomcat服务器。（项目中常用）
mapping：访问静态资源的地址，使用通配符 *
location：静态资源在项目中目录的位置。
/static/**：image下的任意字符，可表示文件或多及目录
/static/
-->
<mvc:reources mapping="/static/**" location="/static/" />
<!--注解驱动
<mvc:default-servlet-handler/> 与 @RespnseMapping注解有冲突，需要下入 <mvc:annotation-driven />
<mvc:resources mapping = "" location = "" />
引入 @RespnseMapping 注解的时候需要加入<mvc:annotation-driven />
-->
<mvc:annotation-driven />
</beans>
3、web.xml配置文件
<?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">
<!--声明、注册springmvc的核心对象DispatcherServlet
需要在tomcat服务器启动后，创建DispatcherServlet对象的实例
为什么要创建DispatcherServlet实例呢？
因为DispatcherServlet在创建的过程中，会同时创建springmvc的容器对象，
读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起请求时就可以直接使用对象了。
servlet的初始化会执行init()方法，DispatcherServlet在init()中：
//创建容器对象，读取文件
WebApplicationContext context = new ClassPathXmlApplicationContext("springmvc.xml");
//把同期对象放入ServletContext中
getServletContext().setAttribute(key,context);
-->
<!--启动tomcat报错，要读取配置文件 /WEB-INF/springmvc-servlet.xml
springmvc创建容器对象时，读取配置文件默认的是/WEB-INF/<servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--自定义springmvc的读取配置文件的位置-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--在tomcat启动后，创建Servlet对象
load-on-startup：表示tomcat启动后创建对象的顺序。他的值是一个整数，
数值越小，tomcat创建对象的时间就越早，数值>=0的整数
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--
使用框架的时候，url-pattern可以使用两种值
1、使用扩展名的方式，语法 *.xxx，xxx是自定义扩展名。常用的方式：*.do,*.action,*.mvc等
http://localhost:8080/springmvc/some.do 表示.do但是的请求交给springmvc处理
2、使用斜杠 "/"，使用：@RequestMapping(value="/pathName/pathName1")
当项目中使用 "/"时，他会替代tomcat中的default。导致所有静态资源都交给DisPatcherServlet
(中央调度)处理,默认情况下DisPatcherServlet没有处理静态资源的能力。没有控制器对象能处理
静态资源的访问。所有的静态资源都是404
动态资源doSome.do是可以访问的，程序中有MyController控制器对象，能处理doSome.do请求。
使用斜杠 "/" 可以不写 .do 类似扩展名。
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
4、controller对象的创建
（1）控制器类上使用@Controller注解创建控制器对象，并放入springmvc容器中
（2）控制器类中的方法使用@RequestMapping()注解,映射路径的扫描。
package com.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
//创建控制器对象
/**
* 处理请求的都是控制器（处理器）：MyController能处理请求，叫做后端控制器（back controller）
*/
/**
*@RequestMapping放在类的上面表示url的公共部分
*/
@Controller
//@@RequestMapping("/path")
public class MyController {
/**
* 处理用户提交的请求，springmvc中是使用方法来处理的。
* 方法是自定义的，可以有多种返回值， 多种参数,方法名称自定义
* 准备使用dosome方法处理some. do请求。
* @RequestMapping: 请求映射,作用是把一个请求地址和一个方法绑定在一起。一个请求指定一个方法处理。
* 属性:1.value：是-个string[]数组,表示请求的uri地址的。
* value的值必须是唯一的，不能 重复。
* 2、method：枚举类型
* 位置：类的上面和方法的上面都可以使用
*
* 返回值：ModelAndView：表示本次请求处理的结果
* Model：数据，请求完成后，要显示给用户的数据
* View：视图，比如jsp等
*/
@RequestMapping(value = {"/doSome.do","/some.do"})
public ModelAndView doSome() {
System.out.println("执行了doSome");
//成功返回
ModelAndView mv= new ModelAndView();
//封装数据,框架在请求的最后把数据放入到request的作用域
mv.addObject("msg","正在使用springmvc进行开发");
mv.addObject("fun","执行的是doSome方法");
//指定视图，指定视图的完整路径
//框架对视图执行的转发操作：forward，request.getRequestDispatcher("/show.jsp").forward(..)
mv.setViewName("/show.jsp");
return mv;
}
}
5、MVC其它层对象的创建，使用<bean>注解的形式创建
springmvc请求处理分析
用户发起
====>doSome.do
====>tomcat(加载web.xml，由【url-pattern】知道.do的请求给中央调度器【DispatchServlet】)
====>中央调度器（DispatcherServlet）可以根据springmvc.xml配置文件知道doSome.do对应的是doSome()方法。即：DispatcherServlet将doSome.do请求转发给doSome()方法
====>框架执行doSome()方法后，把得到的ModelAndView进行数据的封装和转发给show.jsp
springmvc执行过程分析
Servlet的生命周期
Servlet 生命周期
Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程：
- Servlet 初始化后调用 init () 方法。
- Servlet 调用 service() 方法来处理客户端的请求。servlet会在是当时候调用do…()方法，取决于service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。
- Servlet 销毁前调用 destroy() 方法。
- 最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
springmvc执行过程
1、tomcat启动，创建容器的过程：Servlet调用init()方法
通过load-on-startup标签指定的1，创建DispatcherServlet对象，DispatcherServlet的父类是继承HttpServlet，所以DispatcherServlet也是一个Servlet，在被创建时会执行
init()方法，在init()方法中//创建容器对象，读取文件 WebApplicationContext context = new ClassPathXmlApplicationContext("springmvc.xml"); //把同期对象放入ServletContext（即：spring容器放入到全局作用域）中 getServletContext().setAttribute(key,context);
创建容器的作用：创建@Controller注解所在的类的对象，创建了MyController对象，这个对象是放入了springmvc容器中，容器还是map，类似map.put(“myController”,new MyController()【MyController对象】")
2、请求的处理过程：Servlet调用service()方法
（1）调用init()方法初始化创建springmvc容器对象之后，对请求的处理调用执行servlet的
service()方法protected void service(HttpServletRequest request,HttpSevletResponse response){ doDispatch(request,reponse); } protected void doDispatch(HttpServletRequest request,HttpSevletResponse response){ //调用MyController.doSome()方法 }
视图解析器
1、为什么要配置视图解析器？
图解：
（1）webapp目录下的页面是对用户公开的，可以通过手动在地址栏中输入地址直接进行页面资源的访问，如：http://localhost:8080/index.jsp，而在一些特定的情况中，期望用户通过点击等事件操作才能够目标界面，而非直接访问的情况该怎么办呢？来看（2）中描述。
（2）webapp目录下中的WEB-INF目录对用户是不可直接访问的。那么需要通过在springmvc.xml中配置视图解析器来访问。<!--声明springmvc框架中的视图解析器，帮助开发人员设置视图的路径--> <!--国际化视图解析器配置（最普遍通用视图解析器）--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- 前缀 ：视图文件的路径--> <property name="prefix" value="/WEB-INF/view/"/> <!-- 后缀 ：视图文件的扩展名--> <property name="suffix" value=".jsp"/> </bean>在配置了视图解析器后，可以使用逻辑名称(视图文件名)，指定视图。框架会使用视图解析器：
前缀+逻辑名称（视图名）+后缀组成完整路径，这里就是字符串连接的操作/* /WEN-INF/view/show.jsp */ modelAndView.setViewName("show")
SpringMVC框架的注解
@Controller
@Controller注解用于创建的控制器对象，创建的对象放入springmvc容器中，位置：放在声明类的上面。
属性：value: 表示对象名称，String类型，通常不写，使用默认值，创建的对象为类的首字母小写。
@RequestMapping
@RequestMapping注解用于请求映射。放在方法的上面。
属性：1、value：表示请求的映射路径，String[] 类型。只有value属性时，可不写。
2、method：枚举类型，表示指定请求方式
（1）RequestMethod.GET
（2）RequestMethod.HEAD
（3）RequestMethod.POST
（4）RequestMethod.PUT
（5）RequestMethod.PATCH
（6）RequestMethod.DELETE
（7）RequestMethod.OPTIONS
（7）RequestMethod.TRACE
@RequestParam
@RequestParam用于解决请求中参数和形参名不一样问题，逐个接收简单类型参数
属性：1、value：请求中参数的名称
2、required：是一个boolean类型，默认为 true，即请求中必须包含该参数，如果没有包含，将会抛出异常（可选配置）
3、defaultValue：默认值，如果设置了该值，required 将自动设为 false，无论你是否配置了required，配置了什么值，都是 false（可选配置）
位置：在处理器方法的形参定义的前面public void doSome(@RequestParam(value = "userName") String name){ //... }
@ResponseBody
@ResponseBody的作用其实是将java对象转为json格式的数据。
1、@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。
2、@ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】。
SpringMVC框架的请求参数
接收请求参数
接收简单类型的参数
要求：处理器（控制器）方法的形参名和请求中的参数名必须需一致。同名的请求参数赋值给同名的形参。
框架接受请求的参数：
1、使用HttpServletRequest对象的接收请求参数：
String strName = request.getParameter("name");2、springmvc框架通过中央控制器DisPatcherServlet调用doSome()方法，调用方法时，按名称对应，把接收的参数赋值给形参doSome(strName)，框架会提供一个类型转换的功能，将字符串转为形参的数据类型。
接收引用类型（Java对象）的参数
要求：
1、该类的属性名与参数名一致，同时还需要get、set方法。处理器方法形参名是Java对象，这个对象的属性名和请求中参数名一样。
2、框架会创建Java对象，并给属性赋值。请求中的参数名name。框架会调用setName()给属性赋值。和set注入一样。
过滤器：案例一（请求参数乱码问题）
使用过滤器解决乱码问题，过滤请求的参数：
1、自定义过滤器
（1）实现过滤器类
package com.springmvc.filter;
import javax.servlet.*;
import java.io.IOException;
public class MyFilter implements Filter {
private String encoding;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
/*读取web.xml文件中的字符参数*/
encoding = filterConfig.getInitParameter("encoding");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding(encoding);
response.setCharacterEncoding(encoding);
chain.doFilter(request, response);
}
@Override
public void destroy() {
}
}
（2）配置过滤器，与 2 中类似
<!--注册声明过滤器，解决post请求乱码问题-->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>com.springmvc.filter.MyFilter</filter-class>
<!--设置项目中使用的字符编码-->
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<!-- /* ，表示所有的请求先通过过滤器处理-->
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
2、框架自带的过滤器
<!--注册声明过滤器，解决post请求乱码问题-->
<filter>
<filter-name>characterEncodingFilter</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>
<!--强制请求对象使用（HttpServletRequest）使用encoding编码值-->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!--强制应答对象使用（HttpServletResponse）使用encoding编码值-->
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!-- /* ，表示所有的请求先通过过滤器处理-->
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
返回值类型
1、ModelAndView：ModelAndView包含了数据和视图部分，用于封装数据并转发到指定的视图。
2、String：表示只返回视图，视图名可以是逻辑名称（需要配置视图解析器），也可以是完整路径（,使用完整路径不能配置视图解析器）。不包含数据，用于不带数据跳转的功能。forward转发操作。如果这种方式想要返回数据，可以使用HttpServletRequest的setAttribute()手动设置数据request.setAttibute("name")，添加数据到目标视图的界面。
3、void：不能表示数据，也不能表示视图。在处理ajax的时候可以使用void返回值。通过HttpServletResponse输出数据，响应ajax请求。ajax请求服务器返回的是数据，和视图无关。
4、Object：返回对象，需要使用@ResponseBody注解，转换后的json数据放在响应体中。ajax请求中需要的是数据，而不是视图，可以采用这种放回结果方式。
（1）json相关maven依赖包<!--配置jackson--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.12.1</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.12.1</version> </dependency>（2）springmvc.xml配置文件中需要加
注解驱动:<mvc:annotation-driven />
拦截器
1、拦截器的概念及特点：
（1）拦截器是 springmvc 中的一种，需要实现 HandlerInterceptor 接口。
（2）拦截器和过滤器类似，功能方向侧重点不同：过滤器是用来过滤请求参数，设置编码字符集等工作。拦截器是拦截用户的请求，队请求做判断处理的
（3）拦截器的特点：拦截器是全局的，可以对多个Controller做拦截。一个项目中可以有 0个 或 多个 拦截器，他们在一起拦截用户的请求。拦截器常用在：用户登录处理，权限检查，记录日志等。
（4）使用的是AOP的思想
（5）拦截器的执行顺序：
在框架中保存的多个拦截器是ArrayList,按先声明的先后顺序加入到ArrayList中，即多个拦截器的执行顺序：先声明的限制性，后声明的后执行。
2、拦截器的使用步骤：
（1）定义类实现 HandlerInterceptor 接口
package com.springmvc.handler;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 拦截器类：拦截用户的请求
*/
public class MyHandlerInterceptor implements HandlerInterceptor {
/**
* preHandler：预处理方法
*
* 参数:
* @param request
* @param response
* @param handler : 被拦截的控制器对象
*
* @return boolean值
* true：请求通过了拦截器的验证，可以执行处理器方法。
* 拦截器执行 MyInterceptor 的 preHandler()
* Controller 的执行结果：Student{name='张三', age=20}
* 拦截器执行 MyInterceptor 的 postHandle()
* 拦截器执行 MyInterceptor 的 afterCompletion()
* false：请求没有通过拦截器的验证，请求到达拦截器就截至了，请求没有被处理器处理。
* 拦截器执行 MyInterceptor 的 preHandler()
* @throws Exception
*
* 特点：
* 1、在控制器方法之前先执行的：用户的请求首先到达此方法。
* 2、在这个方法中可以验证请求的信息，验证是否符合要求
* 可以验证用户是否登录。验证用户是否有权限访问某个链接地址（url），
* 如果验证失败，可以截断请求，请求不能被处理。如果验证成功，可以放行请求，
* 此时控制器方法才能执行处理请求。（生活案例：检票员）
*
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("拦截器执行 MyInterceptor 的 preHandler()");
return false;
}
/**
* postHandler：后处理方法
* 参数：
* @param request
* @param response
* @param handler 被拦截的处理器MyController
* @param modelAndView 处理器方法的返回值
* @throws Exception
* 特点：
* 1、在处理器方法之后执行的
* 2、能够获取到处理器方法的返回值 ModelAndView，可以修改 ModelAndView 中的数据和视图
* 可以影响最后的执行结果。
* 3、主要是对原来的执行结果做二次修正
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截器执行 MyInterceptor 的 postHandle()");
}
/**
* afterCompletion：最后执行的方法
* 参数：
* @param request
* @param response
* @param handler 被拦截的处理器对象
* @param ex 程序中发生的异常
* @throws Exception
* 特点：
* 1、在请求处理完成后执行。框架中规定当视图处理完成后，对视图执行了forward。
* 就认为请求处理完成
* 2、一般做资源回收工作的。程序在请求过程中创建了一些对象，在这里可以清除，
* 把占用的内存回收
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("拦截器执行 MyInterceptor 的 afterCompletion()");
}
}
（2）在springmvc.xml配置文件中，声明拦截器，让框架知道拦截器的存在。
<!--声明拦截器,可以声明一个或多个
在框架中保存的多个拦截器是ArrayList,按先声明的先后顺序加入到ArrayList中
多个拦截器的执行顺序：先声明的限制性，后声明的后执行。
-->
<mvc:interceptors>
<!--声明第 1 个拦截器-->
<mvc:interceptor>
<!--声明拦截器请求的uri地址
path：就是uri地址，可以是用通配符：**
**：表示任意的字符，文件或多及目录和目录中的文件
-->
<mvc:mapping path="/**"/>
<!--声明拦截器对象-->
<bean class="com.springmvc.handler.MyHandlerInterceptor1"/>
</mvc:interceptor>
<!--声明第 2 个拦截器-->
<mvc:interceptor>
<!--声明拦截器请求的uri地址
path：就是uri地址，可以是用通配符：**
**：表示任意的字符，文件或多及目录和目录中的文件
-->
<mvc:mapping path="/**"/>
<!--声明拦截器对象-->
<bean class="com.springmvc.handler.MyHandlerInterceptor2"/>
</mvc:interceptor>
</mvc:interceptors>
3、拦截器执行的时间：
（1）在请求执行之前，也就是在Controller类中的方法执行之前先被拦截。preHandle
（2）在控制器方法执行之后也会执行拦截器。postHandle
（3）在请求处理完成后也会执行拦截器。afterCompletion
4、登录拦截器（实例）
过滤器和拦截器的区别
1、过滤器是Servlet中的对象；拦截器是springmvc框架中的对象。
2、过滤器是用来是先Filter接口；拦截器实现的是HandlerInterceptor接口。
3、过滤器的作用是设置 request 、response对象的参数、属性的，侧重对数据的过滤的；而拦截器是用来验证请求的，能拦截请求。
4、过滤器是在拦截器之前先执行的。
5、过滤器是Tomcat服务器中创建的对象；拦截器是springmvc容器中创建的对象。
6、过滤器是一个执行时间点，拦截器有三个执行时间点。
7、过滤器可以处理 jsp、js、html等等；拦截器是侧重于拦截对Controller的请求，如果请求不能被中央调度器（DispatcherServlet）接收，这个请求不会到达拦截器。
8、过滤器过滤Servlet请求响应；拦截器拦截普通类方法执行。
处理器映射器
处理器映射器：springmvc框架中的一种对象，框架吧实现了的HandlerMapping的类都叫做映射器（可以有多个）。
处理器映射器作用：根据请求，从springmvc容器对象中获取处理器对象（MyController mc = context.getBean(“myController”)）。框架把找到的处理器对象放到一个叫做处理器执行链（handlerExecutionChain）的类保存。
处理器执行链（handlerExecutionChain）类中保存着：1、处理器对象
2、项目中所有的拦截器List<HandlerIntercptor>
处理器适配器
处理器适配器：springmvc框架中的对象需要实现HandlerAdapter接口。
处理器适配器作用：执行处理器方法（调用MyController.doSome()方法得到返回值ModelAndView）
springmvc执行过程流理解及描述分析
springmvc内部请求的处理流程：也就是springmvc接受请求，到处理完成的过程
1、用户发起请求 doSome.do
2、DispatcherServlet（中央调度器）接受请求doSome.do，把请求转交给处理器映射器【处理器映射器】。
3、DispatcherServlet把 2 中的HandlerExecutionChain中的处理器对象交给处理器适配器对象【处理器适配器】(可以有多个)。
4、DispatcherServlet把 3 中获取的ModelAndView交给视图解析器对象。
视图解析器：springmvc中的对象，需要实现ViewResolver接口（可以有多个）。
视图解析器作用：组成视图的完整路径，使用前缀、后缀。并创建视图（View）对象。
View是一个接口，表示视图的，在框架中jsp、html不是String表示，而是使用View和其实现类表示视图。
5、DispatcherServlet把 4 中创建的View对象获取到，调用View类自己的方法，把Model数据放入request作用域。执行视图对象的forward。请求结束。
可结合此文章完成ssm框架的搭建：
https://blog.csdn.net/qq_36763419/article/details/114031704
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
2
0- 0
已为社区贡献10条内容
所有评论(0)