。。。spring mvc
springmvc：基于spring的一个框架，实际上就是spring的一个模块，专门做web开发的。
理解是servlet的一个升级。
web开发底层是servlet，框架是在servlet基础之上加入一些功能，让你web开发方便。
springmvc就是一个spring，spring是容器，ioc能够管理对象，使用
,@Componet,@repository,@service,@Controller.
spring能够创建对象，放入到容器中（springMvc容器），spring容器中放的是控制器对象。
我们要做的是 使用@Controller创建控制器对象，把对象放入daospringmvc容器，把创建的对象作为控制器使用
这个控制器对象能接受用户的请求，显示处理结果，就当做是一个servlet使用
使用@Controller注解创建的是一个普通类的对象，不是servlet，spring赋予控制器对象一些额外的功能。
web开发的底层是servlet，springmvc中有一个对象是Servlet，DispatherServlet（中央调度器）
DispatherServlet，负责接收用户的所有请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求
转发给我们的Controller对象，最后是Controller对象处理请求。
index.jsp----DispatherServlet（Servlet）
–转发，分配给–Controller对象（@Controller注解创建的对象）。
第一个springmvc项目：
用户在页面发起一个请求，请求交给springmvc的控制器对象，并显示请求的处理结果（在结果页面显示一个欢迎语句）。
实现步骤：
1.新建一个web maven工程
2.加入依赖
spring-webmvc依赖，间接把spring的依赖都加入到项目
jsp，serverlet依赖
3.重点：在web.xml中注册sprngmvc框架的核心对象DispatherServlet
1）DispatherServlet叫做中央调度器，是一个Servlet，它的父类是继承HttpServlet
2）DispatherServlet页叫做前段控制器（front Controller）
3）DispatherServlet赋值接收用户提交的请求，调用其它的控制器对象，并把情趣的处理结果给用户。
4.创建一个发起请求的页面 index.Jsp
5.创建控制器类
1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMappping注解。
6.创建一个作为结果的jsp,显示请求的处理结果。
7创建springmvc的配置文件（spring的配置文件一样）
1）声明组件扫面器，指定Controller注解所在的包名
2）声明视图解析器，帮助处理视图的。
shift+f6文件重命名
springmvc请求的处理流程：
发起some.do–tomcat（web.xml
–url-pattern指定*.do的请求给DispatherServelt）—DispatcherServlet（根据springmvc配置）
—DispatherServlet把some.do转发给了MyController.dosome方法
框架执行dosome()把得到ModelAndView进行处理，转发到了show.jsp
简话过程
some.do–DispatherServlet–Controller
/*
处理用户提交的请求，springmvc中使用方法来处理的
方法是自定义的，可以由多种返回值，多种参数，方法名称自定义
*/
/**
* 准备使用dosome方法处理some.do请求
* @RequestMapping:请求映射：作用是和一个方法绑定在一起，一个请求绑定一个方法处理。
* 属性：1.value是一个string，表示请求的uri地址的
* value的值必须是唯一值的，不能重复，在使用时，推荐地址以"/"
* 位置：1.在方法的上面，常用的。
* 2.在类的上面
* 说明：使用@RequestMapping修饰的方法叫做处理方法或这控制器方法
* 使用@RequestMapping修饰的方法可以处理请求的，类似@Servlet中的doget，dopost
* 能处理请求的都是控制器对象，myController能处理请求，就叫他后端控制器。
*
*/
@RequestMapping(value = "/some.do")
// @RequestMapping(value = "/some.do","/orther.do")多个请求可以使用同意方法处理
//value是个数组, String[] value() default {};
public ModelAndView dosome(){//doget()..service请求
/*
返回值:ModelAndView
Model：数据，请求处理完成后，要显示给用户的数据
view：视图相，比如jsp等等
*/
//处理some.do请求，当于Service调用处理完成了。
ModelAndView mv=new ModelAndView();
//添加数据，框架在请求的最后把数据放入到request作用域
mv.addObject(“msg”,“欢迎使用springmvc做web开发”);
mv.addObject(“fun”,“执行的是dosome方法”);
//指定视图，指定视图的完整路径
//框架对视图执行的forward操作：request.getRequestDispather("/show.jsp").forward(..)
// mv.setViewName(“/WEB-INF/view/show.jsp”);
// //上面的代码，被下面的覆盖掉了，
// mv.setViewName(“/WEB-INF/view/orther.jsp”);
//配置了视图解析器后，可以使用逻辑名称（文件名）指定属于
//框架会使用视图解析器的前缀，逻辑名称，后缀，组成完整路径，这里就是字符串拼接
// /WEB-INF/view/+show.jsp
mv.setViewName("show");
//返回mv
return mv;
}
//@RequestMapping(value = "/test")
//@RequestMapping(value=“/orther.do”)
// @RequestMapping(value = “/test/orther.do”)
//要使方法上面的模块名称，使用方法的公共名称/test就将@RequstMapping提到类上面
public enum RequestMethod {
GET,
HEAD,
POST,
PUT,
PATCH,
DELETE,
OPTIONS,
TRACE;
@RequestMapping(value = "/some.do",method = RequestMethod.GET)
// @RequestMapping(value = "/some.do","/orther.do")多个请求可以使用同意方法处理
//value是个数组, String[] value() default {};
//@RequestMapping
//属性method：表示请求的方式，它的值RequestMethod类枚举值
//例如表示get请求方式，RequestMethod.GET
//post方式。RequestMethod.POST
处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序
员可在方法内直接使用。
➢ HttpServletRequest
➢ HttpServletResponse
➢ HttpSession
➢ 请求中所携带的请求参数（用户提交的参数）
public ModelAndView doorther(HttpServletRequest request,
HttpServletResponse response,
HttpSession session)
逐个参数接收：要求：处理器（控制器）方法的形参名和请求参数名必须一致。
@RequestMapping(value = “one.of”)
public ModelAndView one(String name,Integer age){
ModelAndView mv=new ModelAndView();
mv.addObject(“name”,name);
mv.addObject(“age”,age);
mv.setViewName(“one”);
//返回mv
return mv;
}
同名的请求参数赋值给同名的形参。
1.使用request对象接收请求参数
String strName=request.getparameter（“name”）;
String strAge=request.getparameter(“age”);
2.springmvc框架通过DispatcherServlet调用MyController的dosome（）方法。
调用方法是，按名称对应，把接收的参数赋值给形参。
dosome（StrName，strAge）
框架会提供类型转换的功能，能把string转为int，long，float，double等类型。
400状态码错误，表示接收请求参数的过程中，发生了问题。
注意：在提交请求参数时，使用get方法没有乱码。
使用post方式提交请求，中文有乱码。
使用过滤器解决中文乱码。
给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar 的
org.springframework.web.filter 包下的 CharacterEncodingFilter 类。
在web中生明
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
</filter>
需要配置以下参数
@Nullable
private String encoding;
private boolean forceRequestEncoding;
private boolean forceResponseEncoding;
CharacterEncodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
utf-8
forceRequestEncoding
true
forceResponseEncoding
true
CharacterEncodingFilter
/*
如果用户参数和方法中的参数不一致：
所谓校正请求参数名，是指若请求 URL 所携带的参数名称与处理方法中指定的参数名
不相同时，则需在处理方法参数前，添加一个注解@RequestParam(“请求参数名”)，指定请
求 URL 所携带参数的名称。该注解是对处理器方法参数进行修饰的。value 属性指定请求参
数的名称
//如果请求参数和方法参数不一致使用@RequestParam
//属性：1.value 请求中的参数名称
//2.required：表示请求包中必须包含参数。true表示含有，false表示不必含有
//位置：在处理其方法的形参定义的前面
public ModelAndView one(@RequestParam(value = “name”, required=false)
使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：
➢ 第一种：ModelAndView 返回数据和视图
➢ 第二种：String —返回视图，传输数据自己写
➢ 第三种：无返回值 void
➢ 第四种：返回自定义类型对象
根据不同的情况，使用不同的返回值。
返回 ModelAndView
若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时
处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中
需要定义 ModelAndView 对象。
在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何
资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多
余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。
返回 String，表示返回视图路劲，此时不能配置视图解析器
处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物
返回内部资源逻辑视图名
若要跳转的资源为内部资源，则视图解析器可以使用 InternalResourceViewResolver 内部
资源视图解析器。此时处理器方法返回的字符串就是要跳转页面的文件名去掉文件扩展名后
的部分。这个字符串与视图解析器中的 prefix、suffix 相结合，即可形成要访问的 URI。
当然，也可以直接返回资源的物理视图名。不过，此时就不需要再在视图解析器中再配
置前辍与后辍了。需要把解析器清掉。
对于处理器方法返回 void 的应用场景，AJAX 响应.
若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void。
只有数据，没有视图。
处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，
Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出
现的。
返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。
可以使用对象表示的数据，响应ajax请求。
现在做ajax，主要使用json的数据格式，实现步骤：
1.加入处理json的工具库的依赖，springmvc默认使用的jackson。
2.在springmvc配置文件之间加入mvc:annotation-drivern注解驱动。
json=cm.writeValueAstring(student);
即转化格式：
3.在处理器方法的上面加入@ResopnseBody注解
response.setContentType(“application/json;charset=utf-8”);
printwriter pw=response.getWriter();
pw.println(json);
springmvc处理器方法返回Object，可以转为json输出到浏览器，响应ajax的内部原理：
1.mvc:annotation-driven注解驱动。
注解驱动实现的功能是 完成java对象到json,xml,text,二进制等数据的转换。
HttpMesageConveter接口：消息转换器。
功能：定义了java转为Json，xml等数据格式的方法，这个接口有很多实现类。
这些实现类完成了java对象到json，java对象到xml，java对象到二进制的转换。
将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转
换器的开启，需要由mvc:annotation-driven/来完成。
SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间
的自动转换
当 Spring 容器进行初始化过程中，在mvc:annotation-driven/处创建注解驱动时，默认
创建了七个 HttpMessageConverter 对象。也就是说，我们注册mvc:annotation-driven/，就
是为了让容器为我们创建 HttpMessageConverter 对象。
HttpMessageConverter 接口 : HttpMessageConverter是 Spring3.0 新添加的一个接口，
负责将请求信息转换为一个对象（类型为 T），将对象（类型为 T）输出为响应信息
HttpMessageConverter接口定义的方法：
boolean canRead(Class<?> clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即 转 换 器 是 否 可 将 请 求 信 息 转 换 为 clazz 类 型 的 对 象 ， 同 时 指 定 支 持 MIME 类 型 (text/html,applaiction/json 等) boolean canWrite(Class<?> clazz,MediaType mediaType):指定转换器是否可将 clazz 类型的对
象写到响应流中，响应流支持的媒体类型在 MediaType 中定义。
LIst getSupportMediaTypes()：该转换器支持的媒体类
型。
T read(Class<? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为 T 类型
的对象。
void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将 T 类型的对象写
到响应流中，同时指定相应的媒体类型为 contentType
加入注解驱动mvc:annotation-driven/后适配器类的 messageConverters 属性值
@Responsebody
1.框架会把返回student类型，第哦啊用框架中的ArrayList中的每个类的canwriter（）方法，
检查那个HttpMesssageConverter接口的实现类能处理student类型的数据，MappingJackson2HttpMessageConverter
2.框架会调用实现类的writer（），MappingJackSon2HttpMessageConverter的writer（）方法
把李四同学的student对象转为json，调用jackson的bjectMapping实现转为java
3.框架会调用@Responsebody把2的结果数据输出到浏览器
返回值是string两种情况
处理器返回的是string表示数据时需要加@ResponseBody
表示的是视图时，不需要加@Responsebody.
默认使用text/plain;charset=ISO-8839-1"作为contentType，导致中文乱码。
解决方案，给RequestMapping增加一个属性produces，使用这个属性的contentType；
text/plain;charset=UTF-8"
处理静态资源：
index.jsp是交给tomcat处理的
tomcat有一个DefaultServlet
这个servlet是用来处理静态资源的，以及处理未被映射到其他SERvlet的请求。
/表示静态资源和未被映射的资源都给这个servlet处理。
的值并不是说写为/后，静态资源就无法访问了。经过一些配置后，该问
题也是可以解决的。
（1） 在springmvc的配置文件加入使用mvc:default-servlet-handler/
原理是加入这个标签之后，框架会创建控制器，DefaultServletRequestHandler（类似我们自己创建的MyController）
DefaultServletRequestHandler这个对象可以把接收的请求参数转发给tomcatDefaultservlet处理
声 明 了 <mvc:default-servlet-handler /> 后 ， springmvc 框 架 会 在 容 器 中 创 建
DefaultServletHttpRequestHandler 处理器对象。它会像一个检查员，对进入 DispatcherServlet
的 URL 进行筛查，如果发现是静态资源的请求，就将该请求转由 Web 应用服务器默认的
Servlet 处理。一般的服务器都有默认的 Servlet。
在 Tomcat 中，有一个专门用于处理静态资源访问的 Servlet 名叫 DefaultServlet。其
为 default。可以处理各种静态资源访问请求。该 Servlet 注册在 Tomcat 服务
器的 web.xml 中。
但是该注解和@RequstMapping注解有冲突，需要加入annotation-driven解决问题。
解决动态资源和静态资源冲突的问题，在 springmvc 配置文件加入：
mvc:annotation-driven/
第二种方式：
使用<mvc:resources/>（掌握）
在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器
ResourceHttpRequestHandler。并且添加了mvc:resources/标签，专门用于解决静态资源无
法访问问题。需要在 springmvc 配置文件中添加如下形式的配置：
location 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。
mapping 表 示 对 该 资 源 的 请 求 （ 以 /images/ 开 始 的 请 求 ， 如 /image/beauty.jpg ,
/images/car.png 等）。注意，后面是两个星号**。
mvc：resources
加入后会创建ResourceHttpRequestHandler这个处理器对象，
这个对象处理静态资源的访问，不依赖tomcat服务器
mapping表示访问静态资源uri地址，使用通配符**
location：静态资源在你的项目中的位置。
<mvc:resources mapping=“images/" location=“/images/”/>
<mvc:resources mapping="html/” location=“/html/”/>
以上还是会和requestmapping有冲突
需要加mvc:annotation-driven/
如果想要一句话搞定所有静态资源
name创建一个static目录，将images，html，js放入这个文件夹，只需配置这个static
<mvc:resources mapping=“static/**” loaction=“/satic/”/>
在jsp，html中使用的地址，都是在前段页面中的地址，都是相对地址
地址分类：
1.绝对地址，带有协议名称的是绝对地址，http://www.baidu.com.ftp://202.122.23.1
2.相对地址：没有协议开头的，例如user/some.do,/user/some.do
相对地址不能独立使用，必须有一个参考地址，通过参考地址，相对地址本身才能制定资源。
2.参考地址：
在你的页面中的，访问地址不加"/"
当你的地址，没有斜杆开头，例如user/some.do，当你点击链接时，访问地址是当前页面的地址
加上链接的地址。
2）在你的页面中的，访问地址加"/"
访问的是：http://localhost:8080加你的地址
http://localhost:8080是参考地址。
如果加/name就要加上你的项目地址。
/myweb/user/some.do
项目地址可能发生改变，为了解决这种问题
使用el表达式
${pageContext.request.contextPath}
${pageContext.request.contextPath}/user/some.do
解决方案：
1.加入${pageContext.request.contextpath}
2.加入一个base标签，是html语言中的标签，表示当前页面中访问地址的基地址。
你的页面中所有 没有"/“开头的地址，都是以base标签中的地址为参考地址。
使用base中的地址+user/some.do
在标签中加入标签http://localhost:8080/myweb
在项目中项目地址了能发生改变。
指定路径：
<%
String basepath=request.getScheme()+”😕/“+
request.getServerName()+”:“+request.getServerPort()+
request.getContextPath()+”/";
%>
指定base标签
ssm整合开发
springmvc：视图层，界面层，负责接收请求，显示处理结果的
spring：业务层，管理service，dao，工具类对象的。
mybatis：持久层，访问数据库
用户发起请求–springmvc接收，spring中的service对象，mybatis处理数据
SSM整合也叫SSi（Ibatis也就是mybatis的前身）整合中有容器
1、第一个容器，springmvc容器，管理Controller控制器对象的
2.第二个容器spring容器，管理service，Dao，工具类对象的
我们要做的把使用的对象交给合适的容器创建，管理，把Controller还有web开发的相关对象交给springmvc容器。这些web用品那个的对象写在
springmvc配置文件中。
service，dao对象定义在spring的配置文件中，让spring管理这些对象。
springmvc容器和spring容器是有关系的，关系已经确定好了
springmvc容器是spring容器的子容器，类似java中的集成，子可以访问父的内容
在子容器中的Controller可以访问父容器中的service对象，就是可以使用Controller使用Service对象。
实现步骤：
0.使用spring的mysql库，表使用student（id auto——increment，name，age）
1.新建maven项目
2.加入依赖
springmvc，spring，mybatis三个框架的依赖，jackson依赖，mysql有驱动，druid连接池
jsp，servlet
3.写web.xml
1）注册DispatcherServlet，目的，1.创建springmvc对象，才能创建Controller对象
2.创建的是Servlet，才能接受用户的请求。
2）注册spring的监听器：Context：LoaderListener，目的：创建spring的容器对象，才能创建service，dao等对象
3）注册字符集过滤器，解决post请求乱码的问题
4.创建包，Controller包，Service，dao，实体类包都创建好。
5.写springmvc，spring，mybatis的配置文件
1）springmvc配置文件
2）spring配置文件
3）mybatis配置文件
4）数据库的属性配置文件
6.写代码，dao接口和mapper文件，service和实现类，controller，实体类。
4.写jsp页面。
转发和重定向：
处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且
此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。
视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。
处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。
mv.setviewName(“forwoed:/hello.jsp”)
用于在有视图解析器的情况下，转发到视图解析器地址以外的位置。
请求重定向
在处理器方法返回的视图字符串的前面添加 redirect:，则可实现重定向跳转。
mv.setviewName(“redirect:/hello.jsp”)
框架对重定向的操作：
1.框架会把model中的简单类型的数据，转为string使用，作为hello.jsp的get请求参数使用。
目的是在doRedirect.do和hello.jsp两次请求之间传递数据。
2.在目标hello.jsp页面中可以使用参数集合对象${param}获取请求参数。
————————————————————————————————————
springmvc框架采用的是统一，全局的异常处理。
把controller中的所有异常处理都集中到一个地方去，采用的是aop的思想，把业务逻辑和异常代码分开，解耦合。
使用两个注释
1.@ExceptionHandler
2@ControllerAdvice
异常处理的步骤：
1.新建maven项目
2.加入依赖
3，新建一个自定义的异常类MyUserException，再定义它的子类NameException，AgeException
4.创建一个普通类，作用全局异常处理类。
1）在类的上面加入ControllerAdvice（控制器增强）
2）在类中定义方法，方法上面加入ExceptionHandler
5.在Controller抛出NameException，AgeException
6.创建处理异常的视图页面
7.配置springmvc的配置文件
1）组件扫描器，扫描@Controller注解
2）组件扫描器，扫描@ControllerAdvice所在的包名
3）声明注解驱动。
@Controller：控制器增强（也就是给控制器类增加功能–异常处理功能）
位置：在类的上面。
特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器。
指定@ControllerAdvice所在的包名。
拦截器：
1）拦截器是springmvc中的一种，需要实现HandlerInterceptor接口
2）拦截器和过滤器类似，功能方向侧重点不同过滤器是用来过滤器请求参数，设置编码字符集等工作。
拦截器就是拦截用过的请求，做请求做判断处理的。
3.拦截器是全局的，可以对多个Controller做拦截。
一个项目中可以有0个或多个拦截器，他们在一起拦截用户的请求。
拦截器常用在：用户登录处理，权限检查，记录日志。
拦截器的使用步骤：
1.定义类实现HandlerInteropter接口。
2.在springmvc配置文件中，声明拦截器，让框架知道拦截器的存在。
拦截器的执行时间：
1）在请求处理之前，也就是Controller类中的方法执行之前先被拦截。
2）在控制器方法执行之后也会执行拦截器。
3）在请求处理完成后也会执行拦截器。
拦截器处理步骤：
1.新建maven项目
2.加入依赖
3.创建Controller类
创建一个普通类，作为拦截器使用
1）实现HandlerInterceptor接口
2）实现接口中的三个方法
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//是否登录过的判断
if(request.getSession().getAttribute(“users”) == null){
//此时就是没有登录,打回到登录页面,并给出提示
request.setAttribute(“msg”,“您还没有登录,请先去登录!”);
request.getRequestDispatcher(“/WEB-INF/jsp/login.jsp”).forward(request,response);
return false;
}
return true;//放行请求
}
}
创建show.jsp
创建springmvc的配置文件
1）组件扫描器，臊面@Controller注解
2）声明拦截器，并指定拦截器的请求uri地址。
<!--添加包扫描-->
<context:component-scan base-package="com.bjpowernode.controller"></context:component-scan>
<!--添加视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!--添加注解驱动-->
<!--<mvc:annotation-driven></mvc:annotation-driven>-->
<!--注册拦截器-->
<mvc:interceptors>
<mvc:interceptor>
<!--映射要拦截的请求-->
<mvc:mapping path="/**"/>
<!--设置放行的请求-->
<mvc:exclude-mapping path="/showLogin"></mvc:exclude-mapping>
<mvc:exclude-mapping path="/login"></mvc:exclude-mapping>
<!--配置具体的拦截器实现功能的类-->
<bean class="com.bjpowernode.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
自定义拦截器，需要实现 HandlerInterceptor 接口。而该接口中含有三个方法：
➢ preHandle(request,response, Object handler)：
该方法在处理器方法执行之前执行。其返回值为 boolean，若为 true，则紧接着会执行处理器方
法，且会将 afterCompletion()方法放入到一个专门的方法栈中等待执行。
➢ postHandle(request,response, Object handler,modelAndView)：
该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。
由于该方法是在处理器方法执行完后执行，且该方法参数中包含 ModelAndView，所以该方法可以修
改处理器方法的处理结果数据，且可以修改跳转方向。
➢ afterCompletion(request,response, Object handler, Exception ex)： 当 preHandle()方法返回 true 时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有
工作完成之后才执行该方法。即该方法是在中央调度器渲染（数据填充）了响应页面之后执行的，此
时对 ModelAndView 再操作也对响应无济于事
preHandle(HttpRequest request,HttpResponse response,Object handler)
特点：
1.方法在控制器方法(MyController的dosome）之前先执行，用户的请求首先到达此方法
2.在这个方法中可以获取请求的信息，验证请求是否符合要求。
可以验证用户是否登录，验证用户是否有限限访问某个连接池（uri），
如果验证失败，可以截断请求，请求不能被处理。
如果验证成功，可以放心请求，此时控制器方法才能执行。
true会执行接下来的方法，false就不会执行接下来的方法。
postHandle(request,response, Object handler,modelAndView)：
后处理方法，要想这个方法能执行preHandle要为true
Object handler拦截器对象mycontroller
modelAndView mv：处理器方法的返回值
特点：1.在处理器方法之后执行的（MyController，dosome())
2.能够获取到处理器方法返回值ModelAndView，可以修改ModelAndView中的数据和视图，
可以影响到最后的执行结果。
3.主要是对原来的执行结果做二次修改。
➢ afterCompletion(request,response, Object handler, Exception ex)：
➢ afterCompletion:最后执行的方法
参数：
Object handler：被拦截器的处理器对象
Exception ex:程序中发生的异常
特点：
1.在请求处理完成后执行的，框架中规定是当你的视图处理完成后，对视图执行了forword，就被认为请求处理完成
2.一般是资源回收工作的，程序请求过程中创建了一些对象，在这路删除，把占用的内存回收。
拦截器可以有0或多个
mvc:interceptors
mvc:interceptor
多个拦截器：
在框架中是一个ArrayList
按照声明的先后顺序放入到ArrayList
执行顺序：perHandle-true 和perHandler-true
执行了1先拦截器preHandle
执行了2先拦截器preHandle
执行了SelectStudent方法
执行了2后拦截器postHandle
执行了1后拦截器postHandle
执行了2最终拦截器postHandle
执行了1最终拦截器postHandle
执行顺序：perHandle-true perHandler-false
执行了1先拦截器preHandle
执行了2先拦截器preHandle
执行了1最终拦截器postHandle（因为1的perHandle是true）
执行顺序：perHandle-false 后面的拦截器不管是ture还是false都不执行
拦截器和过滤器的区别：
1.过滤器是servlet中的对象，拦截器是框架中的对象。
2.过滤器是实现Filter接口的对象，拦截器是实现HandlerInterceptor
3.过滤器是用来设置request，response的参数，属性的，侧重对数据过滤的。
拦截器是用来验证请求的，能阶段请求。
4.过滤器是在拦截器之前先执行的。
5.过滤器是tomcat服务器创建的对象，
拦截器我是springmvc容器中创建的对象。
6.、过滤器是一个执行时间点。
拦截器有三个执行时间点。
过滤器可以处理jsp，JS,HTML等等
拦截器是侧重拦截对Controller的对象，如果你的请求不能被DispacherServlet接收，这个请求不会执行拦截器内容
8,。拦截器拦截普通类方法执行，过滤器过滤servlet请求响应。
登录验证：
实现步骤：
1.新建maven
2.修改web.xml注册中央调度器
3.新建index.jsp发起请求
4.创建MyController处理请求。
5.创建结果show.jsp
6.创建一个login.jsp。模拟登录操作（把用户的信息放入到Session）;
创建一个jsp，logout.jsp，模拟退出系统（送Session中删除数据）
7.创建拦截器，从session中获取用户的登录数据验证是否访问系统
8。创建一个验证的jsp，如果验证视图，给出提示
9.创建springmvc配置文件。
声明组件扫描器，
声明拦截器
2 执行流程简单分析
（1）浏览器提交请求到中央调度器
（2）中央调度器直接将请求转给处理器映射器。–处理器映射器：
springmvc框架中的一种对象，框架把视线了HandleMapping接口的类都叫做映射器（多个）
处理器映射器作用：根据请求，从springmvc容器对象中获取处理器对象。
（MyController controller=ctx.getbean(some.do））
框架把实现了HandleMapping接口的类都叫做映射器（多个）
框架把找到的处理器对象方法哦一个叫做处理器执行链（HandleExecutiononChain)的类保存。
HandleExecutionChain 类中保存着 1.处理器对象（MyController）；
2.项目中的所有拦截器List<HandlerIntercepter)
（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后
返回给中央调度器。
（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。
–DispatcherServlet把2中的HandlerExecutionChain中的处理器对象（多个）
处理器适配器：springmvc中的对象，需要实现HandleAdapter接口。
处理器适配器的作用：执行处理器方法（调用MyController.dosome{}得到返回值ModerlAndview）
（5）处理器适配器调用执行处理器。
（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给
处理器适配器。
（7）处理器适配器直接将结果返回给中央调度器。
（8）中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
视图解析器：springmvc中的对象，需要实现viewResoler接口（可以有多个）
视图解析器的作用：组成视图完整的路劲，使用前缀和后缀，并创建view对象。
view是一个接口，表示视图的，在框架中jsp，html不是string表示的，而是使用view和他的实现类表示视图。
InterResourceView：视图类，表示jsp文件，视图解析器会创建InterResourceView类对象。
这个类的里面，有一个属性rui=WEB-INF/view/show.jsp
（9）视图解析器将封装了的视图对象返回给中央调度器
（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
–DisptcherServlet把创建的view对象获取到，调用view类自己的方法，把Model数据放入到request作用域。
执行对象视图的forward，请求结束。
（11）中央调度器响应浏览器。
面试：
执行流程可以总结为
请求发给中央调度器，中央调度器将请求给处理器映射器handlermapping，
处理器映射器会根据请求，找到处理该请求的处理器handleradaptor，处理器适配器调用执行处理器controller，
controller处理完之后将处理结果和跳转页面封装为ModelAndView对象，返回给处理器对象，
处理器对象将试图对象给中央调度器，中央调度器调用试图解析器进行渲染，处理完之后给中央调度器，中央调度器将结果返回给浏览器。
声明注解驱动
将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转
换器的开启，需要由mvc:annotation-driven/来完成。
SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间
的自动转换
当 Spring 容器进行初始化过程中，在mvc:annotation-driven/处创建注解驱动时，默认
创建了七个 HttpMessageConverter 对象。也就是说，我们注册mvc:annotation-driven/，就
是为了让容器为我们创建 HttpMessageConverter 对象。
HttpMessageConverter 接口 : HttpMessageConverter是 Spring3.0 新添加的一个接口，
负责将请求信息转换为一个对象（类型为 T），将对象（类型为 T）输出为响应信息
HttpMessageConverter接口定义的方法：
boolean canRead(Class<?> clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即 转 换 器 是 否 可 将 请 求 信 息 转 换 为 clazz 类 型 的 对 象 ， 同 时 指 定 支 持 MIME 类 型 (text/html,applaiction/json 等) boolean canWrite(Class<?> clazz,MediaType mediaType):指定转换器是否可将 clazz 类型的对
象写到响应流中，响应流支持的媒体类型在 MediaType 中定义。
LIst getSupportMediaTypes()：该转换器支持的媒体类
型。
T read(Class<? extends T> clazz,HttpInputMessage inputMessage)：将请求信息流转换为 T 类型
的对象。
void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将 T 类型的对象写
到响应流中，同时指定相应的媒体类型为 contentType
加入注解驱动mvc:annotation-driven/后适配器类的 messageConverters 属性值
springmvc9大组件：
1、HandlerMapping
根据request找到相应的处理器。因为Handler（Controller）有两中形式，一种是基于类的Handler，另一种是基于Method的Handler（也就是我们常用的）
2、HandlerAdapter
调用Handler的适配器。如果把Handler（Controller）当做工具的话，那么HandlerAdapter就相当于干活的工人
3、HanderExceptionResolver
对异常的处理
4、ViewResolver
用来将String类型的视图名和Locale解析为View类型的视图
5、RequestToViewNameTranslator
有的Handler（Controller）处理完后没有设置返回类型，比如是Void方法，这是需要从request中获取的viewName
6、LocaleResolver
从request中解析出Locale。Locale表示一个区域，比如zh-cn，对于不同的区域的用户，显示不同的结果，这就是i18你（SpringMVC中有具体的拦截器LocaleChangelnterceptor）
7、ThemeResolver
主题解析，这种类似于我们手机的主题
8、MultipartResolver
处理上传请求，将普通的request封装成MultipartHttpServletRequest
9、FlashMapManager
用于管理FlashMap，FlashMap用于在redirect重定向中传递参数
515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
