本文详细介绍了SpringMVC的三层架构（MVC模型、业务层与持久层），从基本概念出发，指导如何在SpringMVC中搭建项目，包括控制器设计、视图页面创建、注解配置和异常处理。涵盖了核心组件、请求处理流程和常见操作技巧。
SpringMVC基本概念
三层架构与MVC
三层架构
开发架构一般基于两种形式，一种是C/S架构(客户端/服务器)，另一种是B/S架构(浏览器/服务器)。JAVAEE开发中，大部分基于B/S架构开发，在B/S架构中，标准的三层架构包括：表现层，业务层，持久层。
-
表现层
也就是web层，负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求web层，web曾接收http请求，完成http响应。
表现层包括展示层和控制层，控制层接收请求，展示层展示结果。
表现层依赖业务层，收到请求调用业务层方法进行处理，处理结果响应给客户端。
表现层的设计一般使用MVC模型，（MVC是表现层设计模型，和其他层没有关系）。 -
业务层
也就是service层，负责业务逻辑处理，web层依赖业务层。
业务层处理业务时可能依赖持久层，如果需要对数据持久化(增删改)时，需要保证事务一致性，也就是常说的事务放到业务层来控制。 -
持久层
也就是dao层，负责数据持久化，与数据库进行交互，负责数据的增删改查。
MVC模型
MVC全称为 Model View Controller，即 Model(模型) View(视图) Controller(控制器)的缩写，是一种用于设计创建web应用程序表现层的模式。
| 简称 | 全称 | 含义 | 实现 | 功能 |
|---|---|---|---|---|
| M | Model | 模型 | JavaBean | 数据模型，用于封装数据 |
| V | View | 视图 | JSP,HTML | 展示数据，依据模型数据创建 |
| C | Controller | 控制器 | Servlet | 负责接收请求，进行响应等 |
SpringMVC概述
SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork的后续产品，已经融合在 Spring Web Flow 中。
SpringMVC已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。
SpringMVC快速入门
IDEA中使用maven骨架搭建web工程
选择webapp
解决maven创建web项目时构建过慢的问题，此处增加一个Properties参数
属性 archetypeCatalog
值 internal
此时项目下缺少java，resource文件夹
main右键 new directory
会自动提示，双击即可建上
若要自己建立目录，则建完后需右键 Mark Directort as，代码包选择 Sources Root，配置文件等选择Resources Root
导入坐标依赖
导入Spring和SpringMVC的坐标，Servlet和Jsp的坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
</dependency>
配置SpringMVC核心控制器DispathcerServlet
在web.xml配置SpringMVC的核心控制器
先在resources下新建空的spring配置文件spring-mvc.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
创建Controller类和视图页面
package com.jtyhnet.controller;
public class TestController {
public String test(){
System.out.println(" spring mvc test running");
return "success.jsp";
}
}
webapp下创建success.jsp
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/24
Time: 12:11
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>success</h2>
</body>
</html>
使用注解配置Controller类中业务方法的映射地址
package com.jtyhnet.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class TestController {
@RequestMapping("/test")
public String test(){
System.out.println(" spring mvc test running");
return "success.jsp";
}
}
配置SpringMVC核心文件 spring-mvc.xml
<?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 http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.jtyhnet"/>
</beans>
客户端发起请求测试
1.配置tomcat
Run - Edit Configurations
点 + ，选择 Tomcat Server下 Local
初次配置则在Configure选择tomcat安装位置
配置热更新
以下两处标记，任选一处即可启动项目
启动后自动弹出浏览器，默认加载index页面
地址栏加后缀test回车访问
成功跳转到success，并且控制台打印出日志
springMVC流程图
SpringMVC组件解析
组件解析
- springMVC执行流程
① 用户发送请求至前端控制器DispatcherServlet。
② DispatcherServlet收到请求调用HandlerMapping处理器映射器。
③ 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果
有则生成)一并返回给DispatcherServlet。
④ DispatcherServlet调用HandlerAdapter处理器适配器。
⑤ HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
⑥ Controller执行完成返回ModelAndView。
⑦ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
⑧ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
⑨ ViewReslover解析后返回具体View。
⑩ DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。
- 前端控制器：DispatcherServlet
用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。 - 处理器映射器：HandlerMapping
HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。 - 处理器适配器：HandlerAdapter
通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。 - 处理器：Handler
它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。 - 视图解析器：View Resolver
View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。 - 视图：View
SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面
注解解析
@RequestMapping
-
作用：用于建立请求 URL 和处理请求方法之间的对应关系
-
位置：
类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径 -
属性：
value：用于指定请求的URL。它和path属性的作用是一样的
method：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
例如：
params = {“accountName”}，表示请求参数必须有accountName
params = {“moeny!100”}，表示请求参数中money不能是100
- mvc命名空间引入
命名空间：
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
约束地址：
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
- 组件扫描
SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用<context:component-scan basepackage=“com.jtyhnet"/>进行组件扫描。
SpringMVC的XML配置解析
- 视图解析器
SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址
org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
翻看该解析器源码，可以看到该解析器的默认设置，如下：
REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀
- 视图解析器
我们可以通过属性注入的方式修改视图的的前后缀
<!--配置内部资源视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
SpringMVC的数据响应
SpringMVC的数据响应方式
- 页面跳转
直接返回字符串
通过ModelAndView对象返回 - 回写数据
直接返回字符串
返回对象或集合
页面跳转
返回字符串形式
直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。
@RequestMapping("/quick")
public String quickMethod(){
return "index";
}
<property name="prefix" value="/WEB-INF/views/" />
<property name=“suffix” value=".jsp" />
拼接后将会访问地址为/WEB-INF/views/index.jsp
返回带有前缀的字符串：
转发：forward:/WEB-INF/views/index.jsp
重定向：redirect:/index.jsp
返回ModelAndView对象
@RequestMapping("/test2")
public ModelAndView test2(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("test2");
return modelAndView;
}
@RequestMapping("/test3")
public ModelAndView test3(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("redirect:success.jsp");
return modelAndView;
}
@RequestMapping("/test4")
public ModelAndView test4(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("forward:/WEB-INF/pages/test3.jsp");
return modelAndView;
}
向request域存储数据
在进行转发时，往往要向request域中存储数据，在jsp页面中显示，那么Controller中怎样向request域中存储数据呢？
① 通过SpringMVC框架注入的request对象setAttribute()方法设置
@RequestMapping("/test5")
public String test5(HttpServletRequest request){
request.setAttribute("name","zhangsan");
return "test5";
}
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 11:47
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>${name}</h2>
</body>
</html>
② 通过ModelAndView的addObject()方法设置
@RequestMapping("/test6")
public ModelAndView test6(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("forward:/WEB-INF/pages/test6.jsp");
modelAndView.addObject("name","lisi");
return modelAndView;
}
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 11:54
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>${name}</h1>
</body>
</html>
回写数据
直接返回字符串
Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello world”) 即可，那么在Controller中想直接回写字符串该怎样呢？
① 通过SpringMVC框架注入的response对象，使用response.getWriter().print(“hello world”) 回写数据，此时不需要视图跳转，业务方法返回值为void。
@RequestMapping("/test7")
public void test7(HttpServletResponse response) throws IOException {
response.getWriter().print("hello world");
}
② 将需要回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回。
@RequestMapping("/test8")
@ResponseBody
public String test8(){
return "hello springMVC";
}
在异步项目中，客户端与服务器端往往要进行json格式字符串交互，此时我们可以手动拼接json字符串返回。
@RequestMapping("/test9")
@ResponseBody
public String test9(){
return "{\"name\":\"zhangsan\",\"age\":18}";
}
上述方式手动拼接json格式字符串的方式很麻烦，开发中往往要将复杂的java对象转换成json格式的字符串，我们可以使用web阶段学习过的json转换工具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>
通过jackson转换json格式字符串，回写字符串。
package com.jtyhnet.domain;
public class User {
private String username;
private int age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
}
@RequestMapping("/test10")
@ResponseBody
public String test10() throws JsonProcessingException {
User user = new User();
user.setUsername("zhangsan");
user.setAge(12);
ObjectMapper objectMapper = new ObjectMapper();
String s = objectMapper.writeValueAsString(user);
return s;
}
返回对象或集合
通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
@RequestMapping("/test11")
@ResponseBody
public User test11(){
User user = new User();
user.setUsername("lisi");
user.setAge(23);
return user;
}
在方法上添加@ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置。
<!--mvc的注解驱动-->
<mvc:annotation-driven/>
在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。
使用<mvc:annotation-driven>自动加载 RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（ 处 理 适 配 器 ），可用在Spring-xml.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。
同时使用<mvc:annotation-driven>默认底层就会集成jackson进行对象或集合的json格式字符串的转换。
将spring-mvc.xml中如下配置注释
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
再次测试发现
未找到类型为User的返回值的转换器
在spring-mvc.xml中打开注解驱动
<!--mvc的注解驱动-->
<mvc:annotation-driven/>
再次测试
可见mvc注解驱动默认底层就会集成jackson进行对象或集合的json格式字符串的转换。
SpringMVC获得请求数据
客户端请求参数的格式是：name=value&name=value… …
服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：
基本类型参数
POJO类型参数
数组类型参数
集合类型参数
获得基本类型数据
Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。
@RequestMapping("/test12")
@ResponseBody
public void test12 (String username,int age){
System.out.println(username);
System.out.println(age);
}
访问如下地址
控制台打印
获得POJO类型参数
Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配。
@RequestMapping("/test13")
@ResponseBody
public void test13(User user){
System.out.println(user);
}
浏览器访问 http://localhost:8080/day02_war_exploded/test13?username=zhangw&age=13
获得数组类型数据
Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。
@RequestMapping("/test14")
@ResponseBody
public void test14(String[] strs){
System.out.println(Arrays.asList(strs));
}
浏览器访问 http://localhost:8080/day02_war_exploded/test14?strs=111&strs=222&strs=333
获得集合类型参数
获得集合参数时，要将集合参数包装到一个POJO中才可以。
页面
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 18:36
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/test15" method="post">
<input type="text" name="userList[0].username"><br>
<input type="text" name="userList[0].age"><br>
<input type="text" name="userList[1].username"><br>
<input type="text" name="userList[1].age"><br>
<input type="submit" value="提交"><br>
</form>
</body>
</html>
POJO类
package com.jtyhnet.domain;
import java.util.List;
public class Vo {
private List<User> userList;
public List<User> getUserList() {
return userList;
}
public void setUserList(List<User> userList) {
this.userList = userList;
}
@Override
public String toString() {
return "Vo{" +
"userList=" + userList +
'}';
}
}
@RequestMapping("/test15")
@ResponseBody
public void test15(Vo vo){
System.out.println(vo.getUserList());
System.out.println(vo);
}
访问
控制台打印
当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装。
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 18:42
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
<script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
<script>
var userList = new Array();
userList.push({username:"zhangsan",age:12});
userList.push({username:"lisi",age:22});
$.ajax({
type:"POST",
url:"${pageContext.request.contextPath}/test16",
data:JSON.stringify(userList),
contentType:"application/json;charset=utf-8"
});
</script>
</head>
<body>
</body>
</html>
@RequestMapping("/test16")
public void test16(@RequestBody List<User> userList){
System.out.println("test16running");
System.out.println(userList);
}
浏览器访问 http://localhost:8080/day02_war_exploded/ajax.jsp
发现控制台无输出
网页F12发现没有加载jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作，我们可以通过以下两种
方式指定放行静态资源：
• 在spring-mvc.xml配置文件中指定放行的资源
<mvc:resources mapping="/js/**" location="/js/"/>
• 使用<mvc:default-servlet-handler/>标签
请求数据乱码问题
form表单提交数据为中文时
控制台打印
需设置过滤器进行编码过滤
web.xml中添加如下内容，如提示异常，调整标签位置
<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>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
设置过滤后不再乱码
参数绑定注解@requestParam
当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定。
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 20:48
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/test17" method="post">
<input type="text" name="name"><br>
<input type="submit" value="提交"><br>
</form>
</body>
</html>
@RequestMapping("/test17")
@ResponseBody
public void test17(@RequestParam("name") String username){
System.out.println(username);
}
注解@RequestParam还有如下参数可以使用：
value：与请求参数名称
required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
defaultValue：当没有指定请求参数时，则使用指定的默认值赋值
@RequestMapping("/test17")
@ResponseBody
public void test17(@RequestParam(value = "name",required = false,defaultValue = "dddd") String username){
System.out.println(username);
}
获得Restful风格的参数
Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务
器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。
Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：
GET：用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETE：用于删除资源
例如：
/user/1 GET ： 得到 id = 1 的 user
/user/1 DELETE： 删除 id = 1 的 user
/user/1 PUT： 更新 id = 1 的 user
/user POST： 新增 user
上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。
@RequestMapping("/test18/{testName}")
@ResponseBody
public void test18(@PathVariable(value = "testName",required = true) String name){
System.out.println(name);
}
自定义类型转换器
• SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。
• 但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。
自定义类型转换器的开发步骤：
① 定义转换器类实现Converter接口
② 在配置文件中声明转换器
③ 在<annotation-driven>中引用转换器
@RequestMapping("/test19")
@ResponseBody
public void test19(Date date){
System.out.println(date);
}
可以发现2021/12/27被自动转为Date类型，而2021-12-27无法自动转换，需定义转换器
package com.jtyhnet.converter;
import org.springframework.core.convert.converter.Converter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateConverter implements Converter<String, Date> {
@Override
public Date convert(String s) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
Date date = simpleDateFormat.parse(s);
return date;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
}
spring-mvc.xml中加入
<bean id="converterService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<list>
<bean class="com.jtyhnet.converter.DateConverter"/>
</list>
</property>
</bean>
<mvc:annotation-driven conversion-service="converterService"/>
再次访问
成功转换
获得Servlet相关API
SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：
HttpServletRequest
HttpServletResponse
HttpSession
@RequestMapping("/test20")
@ResponseBody
public void test20(HttpServletRequest request, HttpServletResponse response, HttpSession session){
System.out.println(request);
System.out.println(response);
System.out.println(session);
}
获得请求头
@RequestHeader
使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)
@RequestHeader注解的属性如下：
value：请求头的名称
required：是否必须携带此请求头
@RequestMapping("/test21")
@ResponseBody
public void test21(@RequestHeader(value = "User-Agent",required = false) String headValue){
System.out.println(headValue);
}
@CookieValue
使用@CookieValue可以获得指定Cookie的值
@CookieValue注解的属性如下：
value：指定cookie的名称
required：是否必须携带此cookie
@RequestMapping("/test22")
@ResponseBody
public void test22(@CookieValue(value = "JSESSIONID",required = false) String JSessionId){
System.out.println(JSessionId);
}
文件上传
文件上传客户端三要素
表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 21:40
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/test23" method="post" enctype="multipart/form-data">
名称：<input type="text" name="name"><br>
名称：<input type="file" name="file"><br>
<input type="submit" value="提交"><br>
</form>
</body>
</html>
单文件上传步骤
① 导入fileupload和io坐标
② 配置文件上传解析器
③ 编写文件上传代码
导入依赖
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.2.2</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
页面
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/12/27
Time: 21:40
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/test23" method="post" enctype="multipart/form-data">
名称：<input type="text" name="username"><br>
文件：<input type="file" name="uploadFile"><br>
<input type="submit" value="提交"><br>
</form>
</body>
</html>
配置解析器，此处id必须为multipartResolver
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--上传文件总大小-->
<property name="maxUploadSize" value="5242800"/>
<!--上传单个文件的大小-->
<property name="maxUploadSizePerFile" value="5242800"/>
<!--上传文件的编码类型-->
<property name="defaultEncoding" value="UTF-8"/>
</bean>
@RequestMapping("/test23")
@ResponseBody
public void test23(String username, MultipartFile uploadFile) throws IOException {
System.out.println(username);
System.out.println(uploadFile);
String originalFilename = uploadFile.getOriginalFilename();
uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
}
完成上传
多文件上传实现
多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可
<form action="${pageContext.request.contextPath}/test24" method="post" enctype="multipart/form-data">
名称：<input type="text" name="username"><br>
文件1：<input type="file" name="uploadFiles"><br>
文件2：<input type="file" name="uploadFiles"><br>
文件3：<input type="file" name="uploadFiles"><br>
<input type="submit" value="提交"><br>
</form>
@RequestMapping("/test24")
@ResponseBody
public void test24(String username,MultipartFile[] uploadFiles) throws IOException {
System.out.println(username);
System.out.println(uploadFiles);
for (MultipartFile uploadFile : uploadFiles) {
String originalFilename = uploadFile.getOriginalFilename();
uploadFile.transferTo(new File("C:\\upload1\\"+originalFilename));
}
}
SpringMVC拦截器
拦截器（interceptor）的作用
Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。
将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（Interceptor Chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。
拦截器和过滤器区别
| 区别 | 过滤器（Filter） | 拦截器（Interceptor） |
|---|---|---|
| 使用范围 | 是 servlet 规范中的一部分，任何Java Web 工程都可以使用 | 是 SpringMVC 框架自己的，只有使用了SpringMVC 框架的工程才能用 |
| 拦截范围 | 在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截 | 在<mvc:mapping path=“”/>中配置了/**之后，也可以多所有资源进行拦截，但是可以通过<mvc:exclude-mapping path=“”/>标签排除不需要拦截的资源 |
拦截器快速入门
自定义拦截器很简单，只有如下三步：
① 创建拦截器类实现HandlerInterceptor接口
② 配置拦截器
③ 测试拦截器的拦截效果
拦截器类
package com.jtyhnet.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyHandlerInterceptor1 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle running");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle running");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion running");
}
}
配置文件中配置
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.jtyhnet.interceptor.MyHandlerInterceptor1"/>
</mvc:interceptor>
</mvc:interceptors>
@RequestMapping("/test25")
public ModelAndView test25(){
System.out.println("目标方法执行");
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("name","zhangsan");
modelAndView.setViewName("index");
return modelAndView;
}
多拦截器操作
增加一个拦截器
package com.jtyhnet.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyHandlerInterceptor2 implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle running 222");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("postHandle running 222 ");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("afterCompletion running 222");
}
}
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.jtyhnet.interceptor.MyHandlerInterceptor1"/>
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="com.jtyhnet.interceptor.MyHandlerInterceptor2"/>
</mvc:interceptor>
</mvc:interceptors>
| 方法名 | 说明 |
|---|---|
| preHandle() | 方法将在请求处理之前进行调用，该方法的返回值是布尔值Boolean类型的，当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行；当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法 |
| postHandle() | 该方法是在当前请求进行处理之后被调用，前提是preHandle 方法的返回值为true 时才能被调用，且它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作 |
| afterCompletion() | 该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行，前提是preHandle 方法的返回值为true 时才能被调用 |
SpringMVC异常处理机制
异常处理的思路
系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。
系统的Dao、Service、Controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：
异常处理两种方式
- 使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver
- 实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器
简单异常处理器SimpleMappingExceptionResolver
SpringMVC已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置
<!--配置简单映射异常处理器-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="defaultErrorView" value="error"/>
<property name="exceptionMappings">
<map>
<entry key="com.jtyhnet.exception.MyException" value="error"/>
<entry key="java.lang.ClassCastException" value="error"/>
</map>
</property>
</bean>
@RequestMapping("/test26")
@ResponseBody
public void test26(){
int i = 1/0;
}
自定义异常处理
① 创建异常处理器类实现HandlerExceptionResolver
② 配置异常处理器
③ 编写异常页面
④ 测试异常跳转
package com.jtyhnet.exception;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyExceptionResolver implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
//处理异常的代码实现
//创建ModelAndView对象
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("exceptionPage");
return modelAndView;
}
}
<bean id="exceptionResolver" class="com.jtyhnet.exception.MyExceptionResolver"/>
@RequestMapping("/test27")
@ResponseBody
public void test27() throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
simpleDateFormat.parse("agdsa");
}
扫一扫
670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
