springmvc简介
1.SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在 Spring3.0 后发布的.
2.SpringMVC：是基于spring的一个框架， 实际上就是spring的一个模块， 专门是做web开发的。其实就是servlet的一个升级.
3 . web开发底层是servlet ， 框架是在servlet基础上面加入一些功能，让你做web开发方便。
4.SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象，使用, @Component, @Repository, @Service, @Controller
SpringMVC能够创建对象， 放入到容器中（SpringMVC容器）， springmvc容器中放的是控制器对象，
5.我们要做的是 使用@Contorller创建控制器对象， 把对象放入到springmvc容器中， 把创建的对象作为控制器使用
这个控制器对象能接收用户的请求， 显示处理结果，就当做是一个servlet使用。
6.使用@Controller注解创建的是一个普通类的对象， 不是Servlet。 springmvc赋予了控制器对象一些额外的功能。
7.web开发底层是servlet， springmvc中有一个对象是Servlet ： DispatherServlet(*调度器)
DispatherServlet: 负责接收用户的所有请求， 用户把请求给了DispatherServlet， 之后DispatherServlet把请求转发给我们的Controller对象， 最后是Controller对象处理请求。
SpringMVC 优点:
1.基于 MVC 架构
基于 MVC 架构，功能分工明确。解耦合，
2.容易理解，上手快；使用简单。
可以开发一个注解的 SpringMVC 项目，SpringMVC 也是轻量级的，jar 很小。不依赖的特定的接口和类。
3.作 为 Spring 框 架 一 部 分 ， 能 够 使 用 Spring 的 IoC 和 Aop 。 方 便 整 合Strtus,MyBatis,Hiberate,JPA 等其他框架。
4.SpringMVC 强化注解的使用，在控制器，Service，Dao 都可以使用注解。方便灵活。使用@Controller 创建处理器对象,@Service 创建业务对象，@Autowired 或者@Resource在控制器类中注入 Service, Service 类中注入 Dao。
springmvc执行流程图
（1）浏览器提交请求到*调度器
（2）*调度器直接将请求转给处理器映射器。
（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后
返回给*调度器。
（4）*调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。
（5）处理器适配器调用执行处理器。
（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给
处理器适配器。
（7）处理器适配器直接将结果返回给*调度器。
（8）*调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
（9）视图解析器将封装了的视图对象返回给*调度器
（10）*调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
（11）*调度器响应浏览器。
第一个springMVC项目
第一个springmvc项目
需求：用户在页面发起一个请求，请求交给springmvc的控制器对象，并显示请求的处理结果
实现步骤
1：新建web，maven工程
2：加入依赖
spring-webmvc依赖，间接把spring依赖都加入到项目中
jsp,servlet依赖
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<!--springmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
3：重点：在web.xml文件中注册springmvc框架的核心对象 DispatcherServlet
1)DispatcherServlet叫做*调度器，是一个servlet，他的父类是继承HttpServlet
2)DispatcherServlet也叫前端控制器(fount controller)
3)DispatcherServlet负责用户接收的请求,调用其他的控制器对象，并把请求的处理结果显示给用户
<!--声明，注册springmvc的核心对象DispatcherServlet
[/WEB-INF/springmvc-servlet.xml]
springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml
-->
<servlet>
<servlet-name>myweb</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启动后创建对象的顺序。他的值是整数(大于0的整数)，值越小，tomcat创建对象的时间越早
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
使用框架的时候，url-pattern可以使用两种值
1：使用扩展名，语法*.xxxx,xxxx是自定义扩展名，常用的有*.do*.action*.mvc等
2：使用斜杠"/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
4：创建一个发起请求的页面 (index.jsp)
5:创建控制器类
1)在类的上面加入@Controller注解 创建对象，并放入到springmvc容器中
2)在类中的方法上面加入@RequestMapping注解。
6：创建一个显示页面，显示处理结果
7：创建springmvc配置文件 (和spring的配置文件一样)
1)声明主键扫描器，指定@Controller注解所在的包。
2)声明视图解析器。帮助处理视图的。
<!--声明组件扫描器-->
<context:component-scan base-package="com.ning.controller"/>
<!--声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀：视图文件地路径-->
<property name="prefix " value="/WEB-INF/view/"/>
<!--后缀：试图文件的拓展名-->
<property name="suffix" value=".jsp"/>
</bean>
@RequestMapping 的使用方法：
*@RequestMapping:请求映射，作用是把一个请求地址和一个方法绑定到一起
*一个请求指定一个方法处理
*属性：
*1：value是一个String，表示请求的uri地址的(some.do)
*value的值必须是唯一的，不可重复的，在使用时，推荐地址以“/”开头
*位置：
2：method,表示请求方式
例如；get请求方式：RequestMethod.GET
*post请求方式：RequestMethod.POST
*1：在方法的上面，常用
*2：在类的上面
*说明；使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法。
*使用@RequestMapping修饰的方法可以处理请求的，类似于servlet中的doGet()doPost()
*
*
1： 放在类的上面
/**@RequestMapping:
*value:所有请求地址的公共部分，叫做模块名称。
*位置：放在类上面
*
*/
@RequestMapping(value="/text")
2：放在方法的上面
@RequestMapping(value="/some.do",method=RequestMethod.GET)
解决POST请求下中文乱码问题
在web.xml文件中加入
<!--注册·声明过滤器，解决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编码的值(utf-8)-->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!--强制请求对象(HttpServletResponse)使用encoding编码的值(utf-8)-->
<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)HttpServletRequest
2)HttpServletResponse
3)HttpSession
4)用户提交的数据
接收用户提交的参数:
1)逐个接受
2)对象接受
1：逐个接收：
/**
逐个接收请求参数：
要求：处理器对象的形参名和请求中参数名必须一致
同名的请求参数赋值给同名的形参
框架接收请求参数：
框架会提供类型转功能
400状态码:客户端错错误，表示提交请求过程中，数据类型转换发生问题
*/
/**
*
请求中，参数名和处理器方法的形参名不一致
@RequestParam:解决逐个接收请求中参数名和形参名不一致的问题
属性：1)value(可省略)请求中参数名称
2)required是一个boolean，默认true表示请求中必须包含此参数
位置：在形参定义前面
*/
publicModelAndViewdoParam(@RequestParam(value="rname",required=false)Stringname,@RequestParam(value="rage",required=false)Integerage){
处理器方法的返回值
ch04-return : 处理器放方法的返回值表示请求的处理结果
1：ModelAndView:有数据和视图，对试图执行forward.
2:String 表示视图 ，可以逻辑名称，也可以是完整视图路径
3：void：不能表示数据，也不能表示视图。
在处理ajax请求的时候，可以使用void返回值。通过HttpServletResponse输出数据，相应Ajax请求。
Ajax 请求服务器端返回的是数据，和视图无关。
4:object:例如String Integer Map，List等等
对象有属性，属性就是数据，所以返回object表示数据，与视图无关。
可以使用·对象表示·数据，响应Ajax请求
现在做Ajax，主要是哟使用json的数据格式。实现步骤：
1：加入处理json的工具库依赖 Jackson依赖
2：在springmvc配置文件中加入<mvc:annotation-driven> 注解驱动 作用：将Java对象转成json
json = ow.writeValueAsString(student);
3：在处理器方法的上面加入@responseBody注解
response.setContentType("application/json;charset=utf-8");
PrintWriter pw = response.getWriter();
pw.println(json);
返回对象 Object
处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。
现在做ajax， 主要使用json的数据格式。 实现步骤：
1.加入处理json的工具库的依赖， springmvc默认使用的jackson。
<!--jackson依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
2.在sprigmvc配置文件之间加入 mvc:annotation-driven 注解驱动。
<!--加入注解驱动处理json-->
<mvc:annotation-driven/>
3.在处理器方法的上面加入@ResponseBody注解
@RequestMapping(value="/doStudent.do")
@ResponseBody
publicStudentdoStudent(Stringname,Integerage){
Studentstu=newStudent();
stu.setName("李四同学");
stu.setAge(20);
returnstu;
}
返回String表示数据
/**
*处理器方法返回String，String表示数据，不是视图
*区分返回值String是数据还是视图，看有没有@ResponseBody注解
*有该注解是表示数据，没有该注解表示视图
*
*默认使用text/plain;charset=ISO-8859-1作为contentType,导致中文乱码
*解决方案：给@RequestMapping增加一个属性，produces，使用这个属性指定一个新的contentType
*/
@RequestMapping(value="/doStringData.do",produces="text/plain;charset=utf-8")
@ResponseBody
publicStringdoStringData(Stringname,Integerage){
return"hellospringMVC返回对象，表示数据";
}
解读url-pattern 解决静态资源文件问题
可以写为/，因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png等资源的获取请求，当作是一个普通的 Controller 请求。*调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报 404 错误。
tomcat本身能处理静态资源的访问， 像html， 图片， js文件都是静态资源
使用斜杆 / 当这里使用了 / tomcat中的default Servlet就没有了导致所有的静态资源都给DispatcherServlet处理， 默认情况下DispatcherServlet没有处理静态资源的能力。没有控制器对象能处理静态资源的访问。所以静态资源（html，js，图片，css）都是404.
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
使用框架的时候，url-pattern可以使用两种值
1：使用扩展名，语法*.xxxx,xxxx是自定义扩展名，常用的有*.do*.action*.mvc等
2：使用斜杠"/"
当使用了/，他会替代tomcat中的default
导致所有的静态资源都交给DispatcherServlet处理，默认情况下DispatcherServlet没有处理静态资源的能力。
没有控制器对象能处理静态资源的访问。所以静态资源(html,css,js，图片)都是404
动态资源some.do是可以访问的，因为我们的程序中有MyController控制器对象，能处理some.do的请求。
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
第一种解决方案：
<!--加入注解驱动处理json-->
<!--
<mvc:default-servlet-handler/>和@RequestMapping注解有冲突，需要加入<mvc:annotation-driven/>解决这个冲突
-->
<mvc:annotation-driven/>
<!--第一种处理静态资源禁止访问的方式
需要在配置文件中加入<mvc:default-servlet-handler/>
原理是：加入这个标签后，框架会创建控制器对象DefaultServletHttpRequestHandler(类似与我们自己创建的myController)
DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给tomcat的default这个servlet
-->
<mvc:default-servlet-handler/>
解决方案2:
<!--第二种处理静态资源的方式
mvc:resources:加入后框架会创建DefaultServletHttpRequestHandler这个处理器对象
让这个对象处理静态资源的访问，不依赖tomcat服务器。
mapping：访问静态资源的uri地址，使用通配符**
location：静态资源在你项目中的位置。
-->
<mvc:resourcesmapping="/picture/**"location="/picture/"/>
<mvc:resourcesmapping="/html/**"location="/html/"/>
<mvc:resourcesmapping="/js/**"location="/js/"/>
<!--使用一个配置语句，指定多种静态资源的访问-->
<!--<mvc:resourcesmapping="/static/**"location="/static/"/>-->
<!--
mvc:resources和@RequestMapping注解有冲突，需要加入<mvc:annotation-driven/>解决这个冲突
-->
<mvc:annotation-driven/>
路径问题
ch06-path：解决jsp页面中路径问题， 用" / " 还是不用
在jsp , html中使用的地址，都是在前端页面中的地址，都是相对地址
地址分类：
1：绝对地址 带有协议名称的是绝对地址 http://www.baidu.com
2：相对地址 没有协议开头的 例如：text/some.do , /text/some.do
相对地址不能独立使用，必须有一个参考地址。通过 参考地址 + 相对地址本身 才能指定资源。
3：参考地址
1) 在你的页面中，访问地址不加 " / "
访问的是：http://localhost:8080/ch06_path_war_exploded/index.jsp
路径：http://localhost:8080/ch06_path_war_exploded/
资源：index.jsp
在index.jsp发起的是 text/some.do 请求 访问地址：http://localhost:8080/ch06_path_war_exploded/text/some.do
参考地址：http://localhost:8080/ch06_path_war_exploded/
当你的地址没有" / " 开头时 例如 text/some.do ，当你点击链接时，访问地址是你当前页面的 路径 + 链接(资源)的地址
http://localhost:8080/ch06_path_war_exploded/ + text/some.do
可以使用base标签
2) 在页面中，访问地址添加" / "
访问的是：http://localhost:8080/ch06_path_war_exploded/index.jsp
路径：http://localhost:8080/ch06_path_war_exploded/
资源：index.jsp
在index.jsp发起的是 /text/some.do 请求 访问地址：http://localhost:8080/text/some.do
参考地址：http://localhost:8080/
如果资源无法访问，在你的路径前面加入${pageContext.request.contextPath}
<p><a href="${pageContext.request.contextPath}/text/some.do">发起some.do的get请求</a></p><br/>
4. 解决路径问题：
1）访问地址添加" / " 加入 ${pageContext.request.contextPath}
2)访问地址不加 " / " 使用base标签
<%
String basePath = request.getScheme() + "://" +request.getServerName() + ":" +
request.getServerPort() + request.getContextPath() + "/" ;
%>
<head>
<title>Title</title>
<base href="<%=basePath%>" />
</head>
SSM整合开发
SSM整合开发
SSM: SpringMVC + Spring + Mybatis
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对象。
实现步骤：
1：创建maven项目
2：加入依赖
springmvc spring mybatis三个框架依赖，Jackson依赖，MySQL驱动，druid连接池，
jsp,servlet依赖、
3：写web.xml配制文件
1)注册DispatcherServlet, 目的：1、创建springmvc容器对象，才能创建controller类对象。
2、创建的是servlet，才能接收用户的请求
2)注册Spring的监听器：ContextLoaderListener ,目的：创建spring的容器对象，才能创建service，dao等对象
3)注册字符集过滤器，解决post请求乱码问题
4：创建包，controller包，dao包，service包，实体类包名创建好
5：写springmvc spring mybatis的配置文件
1)springmvc配置文件
2)spring配置文件
3)mybatis配置文件
4)数据库的属性配置文件
6：写代码 dao接口和mapper文件， service和实现类，controller，实体类
7：写jsp页面
全局异常处理
ch10-异常处理： 异常处理
两个注解的使用:
@ControllerAdvice
@ControllerAdvice: 控制器增强（也就是说给控制器类增加功能--异常处理功能）
*位置：在类的上面。
*特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器。
*指定@ControllerAdvice所在的包名
@ExceptionHandler
@ExceptionHandler(异常的class)：表示异常的类型，当发生此类型异常时，由当前方法处理
@ExceptionHandler(value=nameException.class)
异常处理的步骤：
1：创建maven项目
2：加入依赖
3：新建一个自定义异常类，MyUserException ,在定义它的子类 nameException ageException
4：在controller中抛出 nameException ageException
5: 新建一个普通类，作为全局异常处理类
1)在类的上面加@ControllerAdvice
2)在类中定义方法，在方法上加 @ExceptionHandler
6：创建异常的视图页面
7：创建springmvc配置文件
<!--处理异常需要的两步-->
<context:component-scan base-package="com.ning.handler"/>
<mvc:annotation-driven/>
1、组件扫描器，扫描@Controller注解
2、组件扫描器，扫描@ControllerAdvice
3、声明注解驱动
拦截器
拦截器：
1）拦截器是springmvc中的一种，需要实现HandlerInterceptor接口。
2）拦截器和过滤器类似，功能方向侧重点不同。 过滤器是用来过滤器请求参数，设置编码字符集等工作。
拦截器是拦截用户的请求，做请求做判断处理的。
3）拦截器是全局的，可以对多个Controller做拦截。
一个项目中可以有0个或多个拦截器， 他们在一起拦截用户的请求。
拦截器常用在：用户登录处理，权限检查， 记录日志。
拦截器的使用步骤：
1.定义类实现HandlerInterceptor接口
2.在springmvc配置文件中，声明拦截器， 让框架知道拦截器的存在。
拦截器的执行时间：
1）在请求处理之前， 也就是controller类中的方法执行之前先被拦截。
2）在控制器方法执行之后也会执行拦截器。
3）在请求处理完成后也会执行拦截器。
4)拦截器：看做是多个Controller中公用的功能，集中到拦截器统一处理。
使用的aop的思想
拦截器和过滤器的区别
1.过滤器是servlet中的对象， 拦截器是框架中的对象
2.过滤器实现Filter接口的对象， 拦截器是实现HandlerInterceptor
3.过滤器是用来设置request，response的参数，属性的，侧重对数据过滤的。 拦截器是用来验证请求的，能截断请求。
4.过滤器是在拦截器之前先执行的。
5.过滤器是tomcat服务器创建的对象
拦截器是springmvc容器中创建的对象
6.过滤器是一个执行时间点。
拦截器有三个执行时间点
7.过滤器可以处理jsp，js，html等等
拦截器是侧重拦截对Controller的对象。 如果你的请求不能被DispatcherServlet接收， 这个请求不会执行拦截器内容
8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应