本文总结了SpringMVC的注解式开发流程，包括创建Maven项目、配置pom.xml依赖、注册DispatcherServlet、自定义配置文件、处理器类创建、组件扫描、异常处理和拦截器的使用。详述了如何处理GET和POST请求，以及异常的捕获和全局处理。
根据动力节点的视频学习后做出的一点总结
https://www.bilibili.com/video/BV1sk4y167pD?p=73SpringMVC简介
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts 2(一般老项目使用)等等。
注解的SpringMVC程序
SpringMVC 的注解式开发:
在代码中通过对类与方法的注解，便可完成处理器 在 SpringMVC 容器的注册。注解式开发是重点。
1.新建maven web项目
2.配置pom.xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--springMVC依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.19.RELEASE</version>
</dependency>
<!--Jackson依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.13.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.1</version>
</dependency>
</dependencies>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 ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,ctx);
}
启动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>
<!--SpringMVC的配置文件的位置的属性-->
<param-name>contextConfigLocation</param-name>
<!--指定自定义文件的位置-->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--在tomcat启动后,创建Servlet对象
load-on-startup:表示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
http://localhost:8080/springmvc/other.do
2. 使用斜杠 "/"
当项目中使用斜杠 "/" ,它会替代 tomcat中的default.
导致所有的静态资源都给了DispatcherServlet处理,默认情况下DispatcherServlet没有处理静态资源的能力
没有控制器对象能处理静态资源的访问,所以静态资源(html,js,图片,css)都是404.
动态资源xxx.do是可以访问的,因为程序中有MyController控制器对象,能处理xxx.do的请求
处理静态资源的方式:
1.在SpringMVC配置文件中加入<mvc:default-servlet-handler/>
原理: 加入这个标签后,框架会创建控制器对象DefaultServletHttpRequestHandler(类似自己创建的MyController)
这个对象可以把接收的请求转发给Tomcat的default这个Servlet
2.<mvc:resources mapping="" location="">加入后框架会创建ResourceHttpRequestHandler这个处理器对象
让这个对象处理静态资源的访问,不依赖于服务器
mapping:访问静态资源的uri地址.使用通配符 **
location:静态资源在项目中的目录位置
-->
<!-- <url-pattern>*.do</url-pattern>-->
<url-pattern>/</url-pattern>
</servlet-mapping>
<!--声明过滤器声明编码方式,过滤器可以自定义,也可以使用框架中提供的 过滤器CharacterEncodingFilter-->
<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>
</web-app>4.创建SpringMVC配置文件
在工程的类路径即 src 目录下创建 SpringMVC 的配置文件 springmvc.xml。该文件名可以 任意命名。
5.创建处理器
package controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import exception.AgeException;
import exception.MyUserException;
import exception.NameException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import vo.Student;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* *@Controller:创建处理器对象,对象放在SpringMVC容器中
* 位置:在类的上面
* 和spring中讲的@service, @Component相似
*/
/**
* *@RequestMapping:
* value:所有请求地址的公共部分,叫做模块名称
* 位置:放在类的上面
*/
@Controller
@RequestMapping(value = "/test")
public class MyController {
/**
* 处理用户提交的请求,SpringMVC中时使用方法来处理的
* 方法是自定义的,可以有多种返回值,多种参数,方法名称自定义
*/
/**
* 准备使用doSome方法处理some.do请求
* *@RequestMapping: 请求映射,作用是把一个请求地址和一个方法绑定在一起.
* 一个请求指定一个方法处理
* 属性:1.value 是一个String表示请求的uri地址的(some.do)
* value的值必须是唯一的,不能重复,在使用时,推荐以"/"开头
* 2.method,表示请求的方式,例如:
* 表示get请求方式,RequestMethod.GET
* post方式,RequestMethod.POST
* 指定什么方式就用什么方式,否则会报出405异常
* 不特别指定处理方式,没有限制,可以用所有方式
* 位置:1.在方法的上面,常用的
* 2.在类的上面
* 说明:使用RequestMapping修饰的方法叫做处理器方法或者控制器方法
* 使用RequestMapping修饰的方法可以处理请求的,类似Servlet中的doGet,doPost
*
* 返回值:ModelAndView 表示本次请求的处理结果
* Model:数据,请求处理完成后,要显示给用户的数据
* View:视图,比如jsp等等
*/
//这里的value是一个数组,可以传入多个请求 例:
//@RequestMapping(value = {"/some.do","/other.do"})
//@RequestMapping放到类上面
// @RequestMapping(value = "test/some.do")
@RequestMapping(value = {"/some.do","/first.do"},method = RequestMethod.GET)
public ModelAndView doSome(){
//处理some.do的请求,相当于service调用处理完成了
ModelAndView mv = new ModelAndView();
//添加数据,框架在请求的最后把数据放入到request作用域
//request.setAttribute("msg","SpringMVC做web开发")
mv.addObject("msg","SpringMVC做web开发");
mv.addObject("fun","执行doSome方法");
//指定视图,指定视图的完整路径
//框架对视图执行的forward操作,request.getRequestDispatcher("/show.jsp").forward(...)
// mv.setViewName("/WEB-INF/view/show.jsp");
//当配置了视图解析器后,可以使用文件名指定视图
//框架会使用视图解析器的 前缀+逻辑名称+后缀 组成完成路径,使用的是字符连接操作
mv.setViewName("show");
return mv;
}
// @RequestMapping(value = "test/other.do")
@RequestMapping(value = "/other.do",method = RequestMethod.POST)
public ModelAndView doOther(){
//处理some.do的请求,相当于service调用处理完成了
ModelAndView mv = new ModelAndView();
//添加数据,框架在请求的最后把数据放入到request作用域
//request.setAttribute("msg","SpringMVC做web开发")
mv.addObject("msg","SpringMVC做web开发");
mv.addObject("fun","执行doOther方法");
//指定视图,指定视图的完整路径
//框架对视图执行的forward操作,request.getRequestDispatcher("/show.jsp").forward(...)
mv.setViewName("other");
return mv;
}
/**
* 处理器方法的参数:
* HttpServletRequest,HttpServletResponse,HttpSession,请求中所携带的参数
* 在参数列表中定义就可以了,定义后框架会自动赋值
*/
/**
* 逐个接收请求参数:
* 要求:处理器(控制器)方法的形参名和请求中参数名必须一致
* 同名的请求参数赋值给同名的形参
* 框架接收请求参数
* 1.使用request对象接收请求参数
* String strName request.getParameter("name");
* String strAge request.getParameter("age");
* 2.SpringMVC框架通过DispatcherServlet 调用MyController的receiverProperty02方法
* 调用方法时,按名称对应,把接收的参数赋值给形参
* receiverProperty02(strName,Integer.valueOf(strAge));
* 框架会提供类型转换的功能,能把string转为 int, long, float, double等类型
*
* 400状态是客户端错误,表示提交请求参数过程中,发生了问题
*/
@RequestMapping(value = "/receiverProperty01.do",method = RequestMethod.GET)
public ModelAndView receiverProperty01(String name,Integer age){
//可以在方法中直接使用name和age
ModelAndView mv = new ModelAndView();
mv.addObject("name",name);
mv.addObject("age",age);
mv.setViewName("show01");
return mv;
}
/**
* 使用post提交方式会出现中文乱码,可以使用request.setCharacterEncoding("UTF-8");解决,
* 但是只能解决当前的方法
* 也可以使用过滤器
*/
@RequestMapping(value = "/receiverProperty02.do",method = RequestMethod.POST)
public ModelAndView doOther01(String name,Integer age){
ModelAndView mv = new ModelAndView();
mv.addObject("name",name);
mv.addObject("age",age);
mv.setViewName("other01");
return mv;
}
/**
* 请求参数名和处理器方法的形参名不一样
* *@RequestParam: 逐个接收请求参数中,解决请求参数名形参名不一样的问题
* 属性: 1.value 请求中的参数名称
* 2.required 是一个boolean,默认是true
* true表示请求中必须包含此参数,可以修改为false
* 位置: 处理器方法的形参定义的前面
*/
@RequestMapping(value = "/receiverProperty03.do",method = RequestMethod.GET)
public ModelAndView receiverProperty02(@RequestParam("myName") String name,
@RequestParam(value = "myAge",required = false) Integer age){
ModelAndView mv = new ModelAndView();
mv.addObject("name",name);
mv.addObject("age",age);
mv.setViewName("show01");
return mv;
}
/**
* 处理器方法形参是java对象,这个对象的属性名和请求中的参数名是一致的
* 框架会创建形参的java对象,给属性赋值.请求中的参数是name,框架会调用setName()
*/
@RequestMapping(value = "/receiverObject.do",method = RequestMethod.GET)
public ModelAndView receiverObject(Student student){
ModelAndView mv = new ModelAndView();
mv.addObject("name",student.getName());
mv.addObject("age",student.getAge());
mv.addObject("student",student);
mv.setViewName("show01");
return mv;
}
/**
* 处理器方法返回的字符串可以指定逻辑视图名,通过视图解析器解析可以将其转化为物理视图地址
* 处理器方法返回String表示逻辑视图名称,需要配置视图解析器
*
* 使用完整视图路径时,项目中不能配置视图解析器,否则会出现路径字符串重复添加
* 导致404错误
*/
@RequestMapping(value = "/returnString.do",method = RequestMethod.GET)
public String returnView(HttpServletRequest request){
request.setAttribute("name",request.getParameter("name"));
request.setAttribute("age",request.getParameter("age"));
//show01:逻辑视图名称,项目中配置了视图解析器
//框架对视图执行forward转发操作
return "show01";
}
/**
* 在处理ajax的时候,可以使用void返回值,通过HttpServletResponse输出数据,响应ajax请求
* ajax请求服务器端返回的就是数据,与视图无关
*
* 处理器方法返回void,响应ajax请求
*
* 手工实现ajax,json数据,代码有重复的
* 1.java对象转为json. 2.通过HttpServletResponse输出json数据
*/
@RequestMapping(value = "/returnVoid.do",method = RequestMethod.POST)
public void returnVoidAjax(HttpServletResponse response,
String name,Integer age){
//处理ajax,使用json做数据的格式
//假设service已经调用完成,使用Student表示处理结果
Student student = new Student(name,age);
//可以交给框架
//把结果的对象转为json格式的数据
ObjectMapper om = new ObjectMapper();
String json = "";
try {
json = om.writeValueAsString(student);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
//可以交给框架
//输出数据,响应ajax请求
response.setContentType("application/json;charset=utf-8");
PrintWriter pw;
try {
pw = response.getWriter();
pw.println(json);
pw.flush();
pw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 返回Object表示数据,可以使用对象表示的数据,响应ajax请求
* 步骤:
* 1.加入处理json的工具库的依赖,SpringMVC默认使用的jackson
* 2.在SpringMVC配置文件中加入<mvc:annotation-driven>注解驱动
* 注解驱动实现的功能是 完成java对象到json,xml,text等数据的转换,实现使用了
* HttpMessageConverter接口:消息转换器,定义了java对象到其他格式转换的方法
* 在注解驱动加入到配置文件后,会自动创建HttpMessageConverter接口的8个实现类对象
* 3.在处理器方法上面加入ResponseBody注解,放在处理器方法的上面,
* 把处理器方法返回对象转为json后,通过HttpServletResponse输出数据,响应ajax请求
* 相当于完成了以下步骤
* response.setContentType("application/json;charset=utf-8");
* PrintWriter pw = response.getWriter();
* pw.println(json);
* 实际上为:
* 1.把返回的Student类型调用框架中的ArrayList<HttpMessageConverter>中的每个类的canWriter()
* 检查那个实现类能否处理Student类型的数据
* 2.框架会调用实现类的write(),MappingJackson2HttpMessageConverter的write()会把
* 当前Student数据类型转为json,调用Jackson的ObjectMapper实现转为json
* 2.框架会调用@ResponseBody把2的结果数据输出到浏览器,ajax请求处理完成
*/
@RequestMapping(value = "/returnObject.do",method = RequestMethod.POST)
@ResponseBody
public Student returnObjectAjax(String name,Integer age){
//处理ajax,使用json做数据的格式
//假设service已经调用完成,使用Student表示处理结果
return new Student(name,age);
}
/**
* 处理器方法返回的是List集合
*/
@RequestMapping(value = "/returnListObject.do",method = RequestMethod.POST)
@ResponseBody
public List<Student> returnListObjectAjax(String name, Integer age){
//处理ajax,使用json做数据的格式
//假设service已经调用完成,使用Student表示处理结果
return new ArrayList<>(Arrays.asList(new Student(name, age), new Student("李四",22)));
}
/**
* 返回字符串对象
* 区分返回值String是数据还是视图,看有没有@ResponseBody注解
* 如果有返回String数据,反之就是视图
*
* 返回字符串时,默认使用"text/plain;charset=ISO-8859-1"作为contentType,导致中文乱码
* 给RequestMapping增加一个属性produce,指定新的contentType
*/
@RequestMapping(value = "/returnDataString.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public String returnDataString(){
//处理ajax,使用json做数据的格式
//假设service已经调用完成,使用Student表示处理结果
return "返回文本数据:Hello World!";
}
/**
* 处理器方法返回ModelAndView
* 语法:setViewName("forward:视图文件完整路径")
* 特点:不和视图解析器一同使用,就当项目中没有视图解析器
*/
@RequestMapping(value = "/doForward.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public ModelAndView doForward(){
ModelAndView mv = new ModelAndView();
mv.addObject("name","张三");
mv.addObject("age",20);
//转发
mv.setViewName("forward:/WEB-INF/view/show01.jsp");
return mv;
}
/**
* 处理器方法返回ModelAndView,实现重定向redirect
* 语法:setViewName("redirect:试图完整路径")
* 特点:不和视图解析器一同使用,就当项目中没有视图解析器
*
* 框架对重定向的操作:
* 1.框架会把Model的简单类型的数据,转为String使用,作为show02.jsp的get请求参数使用
* 目的是在doRedirect.do和show02.jsp两次请求之间传递参数
* 2.在目标show02.jsp页面可以使用参数集合对象${param}获取请求参数值
* ${param.name} ${param.age}
* 3.重定向不能访问受保护的/WEB-INF资源
*/
@RequestMapping(value = "/doRedirect.do")
@ResponseBody
public ModelAndView doRedirect(){
ModelAndView mv = new ModelAndView();
//数据放入到request作用域
mv.addObject("name","张三");
mv.addObject("age",20);
//重定向
mv.setViewName("redirect:/show02.jsp");
return mv;
}
}6.声明组件扫描器
在 springmvc.xml 中注册组件扫描器
7.定义目标页面
在 webapp 目录下新建一个子目录 jsp，在其中新建一个 jsp 页面 show.jsp。展示收到的信息
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>show.jsp从request作用域获取数据</h1><br/>
<h2>msg数据:${msg}</h2>
<h2>fun数据:${fun}</h2>
</body>
</html>
8.修改视图解析器的注册
SpringMVC 框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver 中引入了请求的前辍与后辍。而 ModelAndView 中只需给出要跳 转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。
<!--声明组件扫描器-->
<context:component-scan base-package="controller"/>
<!--声明SpringMVC框架中的视图解析器,帮助设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀:视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/"/>
<!--后缀:视图文件的扩展名-->
<property name="suffix" value=".jsp"/>
<!--框架中的会连接对应信息 prefix + show + suffix-->
</bean>
<!--注册驱动-->
<mvc:annotation-driven/>
<!--处理静态资源的第一种方式-->
<!-- <mvc:default-servlet-handler/>-->
<!--处理静态资源的第二种方式-->
<!-- img**:表示img及其子目录中所有文件
这样的目录要写多个标签,在WEB-INF中创建一个文件夹,可以将所有的静态资源分类后都放入其中
然后将文件夹导入,可以只添加一个标签
-->
<mvc:resources mapping="img/**" location="img/"/>
<mvc:resources mapping="html/**" location="html/"/>9.主界面
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
<html>
<!--
在jsp,html中使用的地址,都是在前端页面中的地址,都是相对地址
地址分类:
绝对地址:
带有协议名称的是绝对地址,例: https://www.baidu,com, ftp://10.84.143.19
相对地址:
没有协议开头的,例如 user/some.do 相对地址不能独立使用,必须有一个参考地址+相对地址本身才行
参考地址:
1.在页面中的,访问地址不加"/"
访问的是:http://localhost:8080/SpringMVC_test_war_exploded/index.jsp
路径:http://localhost:8080/SpringMVC_test_war_exploded/
资源:test/some.do
在index.jsp发起test/some.do请求访问地址变为http://localhost:8080/SpringMVC_test_war_exploded/test/some.do
当地址没有斜杠开头 例如test/some.do,点击链接访问的是当前页面的地址加上连接的地址
即http://localhost:8080/SpringMVC_test_war_exploded/+test/some.do
2.在页面中的,访问地址加"/"
访问的是http://localhost:8080/SpringMVC_test_war_exploded/index.jsp
路径:http://localhost:8080/SpringMVC_test_war_exploded/
资源:index.jsp
点击/test/some.do访问地址变为http://localhost:8080/test/some.do
参考地址是服务器地址,不能访问
1.可以在资源前面加上${pageContext.request.contextPath}
让服务器获取路径并加上
2.加入一个base标签,是html语言中的标签,表示当前页面中访问地址的基地址
页面中所有没有以"/"开头的地址,都是以base标签中的地址为参考地址
使用base中的地址+test/some.do 组成访问地址
在<head>中<base href="http:localhost:8080/SpringMVC_test_war_exploded/ ">
3.可以使用request自动获取并储存到字符串
<%
// String basePath = request.getScheme() + "://" +
// request.getServerName() + ":" + request.getServerPort() +
// request.getContextPath() + "/";
%>
-->
<head>
<title>Title</title>
<script type="text/javascript" src="js/jquery-3.6.0.js"></script>
<script type="text/javascript">
function objectAjax(){
$.ajax({
// url:"test/returnVoid.do",
// url:"test/returnObject.do",
url:"test/returnListObject.do",
data:{
name:"zhangsan",
age:20
},
type:"post",
dataType:"json",
success:function (resp) {
$.each(resp,function (i,n){
alert(n.name + "......" +n.age);
})
}
})
}
function dataString(){
$.ajax({
// url:"test/returnVoid.do",
// url:"test/returnObject.do",
url:"test/returnDataString.do",
data:{
name:"zhangsan",
age:20
},
type:"post",
dataType:"text",
success:function (resp) {
alert(resp);
}
})
}
</script>
</head>
<body>
<p>SpringMVC-test</p>
<p><a href="${pageContext.request.contextPath}/test/some.do">发起some.do的get请求</a></p>
<p><a href="test/other.do">发起other.do的post请求</a></p>
<p>get方式逐个接收请求参数</p>
<form action="test/receiverProperty01.do" method="get">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="get请求receiverProperty.do">
</form>
<p>post方式逐个接收请求参数</p>
<form action="<%=basePath%>/test/receiverProperty02.do" method="post">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="post请求receiverProperty.do">
</form>
<p>逐个接收请求参数,请求参数名和处理器方法形参名不一致时</p>
<form action="test/receiverProperty03.do" method="get">
<input type="text" name="myName">
<input type="text" name="myAge">
<input type="submit" value="get请求receiverProperty.do">
</form>
<p>使用java对象接收请求参数</p>
<form action="test/receiverObject.do" method="get">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="提交参数">
</form>
<p>处理器方法返回String表示视图名称</p>
<form action="test/returnString.do" method="get">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="提交参数">
</form>
<br/>
<button onclick="objectAjax()">发起ajax请求</button>
<button onclick="dataString()">返回String数据</button>
<p>当处理方法返回ModelAndView实现forward</p>
<form action="test/doForward.do" method="post">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="提交">
</form>
<br/>
<p>当处理方法返回ModelAndView实现redirect</p>
<form action="test/doRedirect.do" method="post">
<input type="text" name="name">
<input type="text" name="age">
<input type="submit" value="提交">
</form>
<br/>
</body>
</html>
10.使用SpringMVC框架web请求的处理顺序
11.SpringMVC的MVC组件
12.SpringMVC的执行流程
异常处理
SpringMVC 框架处理异常的常用方式：使用@ExceptionHandler 注解处理异常。
@ExceptionHandler 注解
使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可 选属性 value，为一个 Class数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。
而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。
对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。
1.自定义异常类
定义三个异常类：NameException、AgeException、MyUserException。其中 MyUserException 是另外两个异常的父类。
package exception;
public class MyUserException extends Exception{
public MyUserException() {
super();
}
public MyUserException(String message) {
super(message);
}
}
package exception;
//表示当用户姓名异常,抛出NameExceptiona
public class NameException extends MyUserException{
public NameException() {
super();
}
public NameException(String message) {
super(message);
}
}
package exception;
//当年龄有问题时抛出的异常
public class AgeException extends MyUserException{
public AgeException() {
super();
}
public AgeException(String message) {
super(message);
}
}
2.修改Controller抛出异常
@RequestMapping(value = "/exception.do")
@ResponseBody
public ModelAndView doException(String name,Integer age) throws MyUserException {
ModelAndView mv = new ModelAndView();
//根据请求参数抛出异常
if (!"zs".equals(name)){
throw new NameException("姓名不正确");
}
if (age==null||age>80){
throw new AgeException("年龄不正确");
}
mv.addObject("name","张三");
mv.addObject("age",20);
//重定向
mv.setViewName("show01");
return mv;
}3.定义异常响应页面
不过，一般不这样使用。而是将异常处理方法专门定义在一个类中，作为全局的异常处理类。
4.定义全局异常处理类
package handler;
import exception.AgeException;
import exception.NameException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;
/**
* *@ControllerAdvice:控制器增强(给控制器类增加功能--异常处理功能)
* 位置:在类的上面
* 特点:必须让框架知道这个注解所在的包名,需要在SpringMVC配置文件中声明组件扫描器
* 指定@ControllerAdvice所在的包名
*/
@ControllerAdvice
public class GlobalExceptionHandler {
//定义方法,处理发生的异常
/*
处理异常的方法和控制器方法的定义一样,可以有多个参数,
可以有ModelAndView,String,void,对象类型的返回值
形参:Exception,表示Controller中抛出的异常对象
通过形参可以获取发生的异常信息
@ExceptionHandler(异常的class):表示异常的类型,当发生此类型的异常时
由当前方法处理
*/
@ExceptionHandler(value = NameException.class)
public ModelAndView doNameException(Exception ex){
//处理NameException的异常
/*
异常发生时处理逻辑:
1.需要把异常记录下来,记录到数据库,日志文件.
记录日志发生的时间,哪个方法发生的,异常错误内容.
2.发送通知,把异常的信息发送给相关人员.
3.给用户友好的提示.
*/
ModelAndView mv = new ModelAndView();
mv.addObject("msg","姓名必须是zs,其他用户不能访问");
mv.addObject("ex",ex);
mv.setViewName("nameError");
return mv;
}
@ExceptionHandler(value = AgeException.class)
public ModelAndView doAgeException(Exception ex){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","年龄出错了,不能为空且小于80");
mv.addObject("ex",ex);
mv.setViewName("ageError");
return mv;
}
//处理其他异常,NameException,AgeException以外不知名类型的异常
@ExceptionHandler
public ModelAndView doOtherException(Exception ex){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","出错了!");
mv.addObject("ex",ex);
mv.setViewName("defaultError");
return mv;
}
}
5.定义Spring配置文件
注册组件扫描器,注册注解驱动
拦截器
SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提 交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器， 在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时， 已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。
自定义拦截器
package handler;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
//拦截器类,拦截用户的请求
public class MyInterceptor implements HandlerInterceptor {
private long time;
/*
preHandle:预处理方法:
重要,整个项目的入口,门户
参数:
Object handler:被拦截的控制器对象
返回值:
true:通过验证,可以执行处理器方法
false:请求没有通过拦截器的验证,请求到达拦截器就截止了
特点:
1.在控制器方法(MyController的doInterceptor)之前先执行的
用户的请求首先到达此方法
2.在这个方法中可以获取请求的信息,验证用户是否有权限访问某个链接地址
如果验证失败,可以截断请求,请求不能被处理
如果验证成功,控制器才能执行
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
time = System.currentTimeMillis();
System.out.println("拦截器的preHandle方法");
// request.getRequestDispatcher("/tips.jsp").forward(request,response);
// return HandlerInterceptor.super.preHandle(request, response, handler);
return true;
}
/*
postHandle:后处理方法
参数:
Object handler:被拦截的控制器对象
ModelAndView modelAndView:控制器方法的返回值
特点:
1.在控制器方法之后执行的
2.能获取到控制器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图,
可以影响到最后的执行结果
3.主要是对原来的执行结果做二次修正
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("拦截器的postHandle方法");
//对原来的doSome执行结果需要调整
if (modelAndView!=null){
modelAndView.addObject("date",new Date());
modelAndView.setViewName("show03");
}
// HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
}
/*
afterCompletion:最后执行的方法
参数:
Object handler:被拦截的控制器对象
Exception ex:程序中发生的异常
特点:
1.请求处理完成后执行的,框架中规定当视图处理完成后,对视图执行了forward,就认为请求处理完成
2.一般做资源回收工作,程序请求过程中创建的对象可以删除,把占用的内存回收
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("拦截器的afterCompletion方法");
long etime = System.currentTimeMillis();
System.out.println("花费了");
System.out.println(etime-time);
// HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
}
}
注册拦截器
springmvc.jsp
<!--声明拦截器:拦截器可以有0或多个
在框架中保存多个拦截器是ArrayList,
按照声明的顺序储存到集合中
多个拦截器执行顺序为 "→回→"
-->
<mvc:interceptors>
<!--声明第一个拦截器-->
<mvc:interceptor>
<!--
指定拦截器的请求uri地址
path:就是uri地址,可以使用通配符 **
** : 表示文件或者多级目录和目录中的文件 例:
http://localhost:8080/myweb/user/listUser.do
后面带user/都会被拦截
-->
<mvc:mapping path="/test/**"/>
<!--声明拦截器对象-->
<bean class="handler.MyInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>使用拦截器
@RequestMapping(value = "/doInterceptor.do")
@ResponseBody
public ModelAndView doInterceptor(){
ModelAndView mv = new ModelAndView();
//数据放入到request作用域
mv.addObject("name","张三");
mv.addObject("age",20);
//重定向
mv.setViewName("show01");
return mv;
}拦截器执行顺序
多个拦截器中方法与处理器方法的执行顺序
从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开， 其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要 方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的 afterCompletion()方法。最终都会给出响应。
拦截器：看做是多个Controller中公用的功能，集中到拦截器统一处理。使用的aop的思想
=================================================================================
多个拦截器：
第一个拦截器preHandle=true , 第二个拦截器preHandle=true
111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
22222-拦截器的MyInterceptor的postHandle()
111111-拦截器的MyInterceptor的postHandle()
22222-拦截器的MyInterceptor的afterCompletion()
111111-拦截器的MyInterceptor的afterCompletion()
---------------------------------------------------
第一个拦截器preHandle=true , 第二个拦截器preHandle=false
111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
111111-拦截器的MyInterceptor的afterCompletion()
----------------------------------------------------------
第一个拦截器preHandle=false , 第二个拦截器preHandle=true|false
111111-拦截器的MyInterceptor的preHandle()
====================================================================
拦截器和过滤器的区别
1.过滤器是servlet中的对象， 拦截器是框架中的对象
2.过滤器实现Filter接口的对象， 拦截器是实现HandlerInterceptor
3.过滤器是用来设置request，response的参数，属性的，侧重对数据过滤的。
拦截器是用来验证请求的，能截断请求。
4.过滤器是在拦截器之前先执行的。
5.过滤器是tomcat服务器创建的对象
拦截器是springmvc容器中创建的对象
6.过滤器是一个执行时间点。
拦截器有三个执行时间点
7.过滤器可以处理jsp，js，html等等
拦截器是侧重拦截对Controller的对象。 如果你的请求不能被DispatcherServlet接收， 这个请求不会执行拦截器内容
8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应
3893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
