JAVA框架04 -- SPringMVC-CSDN博客

本文链接：https://blog.csdn.net/qq_34536604/article/details/106997230

SpringMVC

三层架构和MVC

三层架构

开发服务器端程序，一般都基于两种形式，一种C/S架构程序，一种B/S架构程序
Java语言基本上都是开发B/S架构的程序，B/S架构又分成了三层架构

三层架构概念

表现层:WEB层，用来和客户端进行数据交互的。表现层一般会采用MVC的设计模型
业务层:处理公司具体的业务逻辑的
持久层:用来操作数据库的

表现层的设计模式–MVC模型

MVC全名是Model View Controller 模型视图控制器，每个部分各司其职。
Model:数据模型，JavaBean的类，用来进行数据封装。
View:指JSP、HTML用来展示数据给用户
Controller:用来接收用户的请求，整个流程的控制器。用来进行数据校验等。

SpringMVC

概念

是一种基于Java实现的MVC设计模型的请求驱动类型的轻量级WEB框架。
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的
SpringMVC框架或集成其他MVC开发框架，如Struts1(现在一般不用)，Struts2等。

优势

清晰的角色划分:

前端控制器(DispatcherServlet)
请求到处理器映射(HandlerMapping)
处理器适配器(HandlerAdapter)
视图解析器(ViewResolver)
处理器或页面控制器(Controller)
验证器( Validator)
命令对象(Command 请求参数绑定到的对象就叫命令对象)
表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。

SpringMVC 和 Struts2 的优略分析

共同点:

它们都是表现层框架，都是基于 MVC 模型编写的。

它们的底层都离不开原始 ServletAPI。

它们处理请求的机制都是一个核心控制器。

区别:

Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter

Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。

Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便(JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。)

Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提
升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

SpringMVC 的入门程序

创建WEB工程，引入开发的jar包

具体的坐标

 
<!-- 版本锁定 --> <properties>
	<spring.version>5.0.2.RELEASE</spring.version> </properties>
</properties>

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </dependency>

配置核心的控制器(配置DispatcherServlet)

在web.xml配置文件中核心控制器DispatcherServlet

<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>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

resource下编写springmvc.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描 -->
    <context:component-scan base-package="com.jwang"/>

    <!-- 视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--开启springMVC注解支持 -->
    <mvc:annotation-driven/>
</beans>

编写index.jsp和HelloController控制器类

1. index.jsp

<body>
    <h3>入门程序</h3>
    <a href="hello"> 入门</a>
</body>

2. HelloController

//控制器类
@Controller
public class HelloController {
    @RequestMapping(path = "/hello") //请求映射  路径为/hello
    public String sayHello(){
        System.out.println("hello StringMVC");
        return "success";
    }
}

在WEB-INF目录下创建pages文件夹，编写success.jsp的成功页面

<body> <h3>入门成功!!</h3>
</body>

入门案例的执行过程分析

入门案例的执行流程

当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件
开启了注解扫描，那么HelloController对象就会被创建
从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到执行的具体方法
根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
Tomcat服务器渲染页面，做出响应

RequestMapping注解

RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系

RequestMapping注解可以作用在方法和类上

作用在类上:第一级的访问目录
作用在方法上:第二级的访问目录
细节:路径可以不编写 / 表示应用的根目录开始
细节:${ pageContext.request.contextPath }也可以省略不写，但是路径上不能写 /

RequestMapping的属性

path：指定请求路径的url
value：与path属性一样
mthod：指定该方法的请求方式枚举类
params：指定限定请求参数的条件. 请求参数需要有该指定名称的属性 {“username”}
headers 发送的请求中必须包含的请求头 {“Accept”}

请求参数的绑定

请求参数的绑定说明

绑定机制

表单提交的数据都是k=v格式的 username=haha&password=123
SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
要求:提交表单的name和参数的名称是相同的

支持的数据类型

基本数据类型和字符串类型
实体类型(JavaBean)
集合数据类型(List、map集合等)

基本数据类型和字符串类型

提交表单的name和参数的名称是相同的
区分大小写

    @RequestMapping(path = "/testrequest")
    public String testRequest(String username){
        System.out.println("requestmapping。。。"+ username);
        return "success";
    }
    
    <a href="user/testrequest?username=aaa">requestmapping</a>
    
    
>>>http://localhost:8080/jwang/user/testrequest?username=aaa    
>>>requestmapping。。。aaa

实体类型(JavaBean)

提交表单的name和JavaBean中的属性名称需要一致
如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成:对象.属性例如:
address.name

## Domain
public class Account implements Serializable {
    private String username;
    private Integer id;
    private String password;
    private Double money;
    private User user;

## controller
    @RequestMapping(path = "/saveAccount")
    public String saveAccount(Account account){
        System.out.println(account);
        return "success";
    }
 
 ## index.jsp
     <form action="user/saveAccount" method="post">
        姓名：<input type="text" name="username"/><br/>
        密码：<input type="text" name="password"/><br/>
        金额：<input type="text" name="money"/><br/>
        用户姓名：<input type="text" name="user.username"/><br/>
        用户地址：<input type="text" name="user.address"/><br/>
        <input type="submit" name="提交">
    </form>

>>>Account{username='jwang', id=null, password='xxx', money=10.0, 
>>>			user=User{username='jkh', address='kjhhk'}}

给集合属性数据封装

JSP页面编写方式:list[0].属性

       用户姓名1：<input type="text" name="users[0].username"/><br/>
       用户地址1：<input type="text" name="users[0].address"/><br/>

       用户姓名2：<input type="text" name="map['one'].username"/><br/>
       用户地址2：<input type="text" name="map['one'].address"/><br/>
       <input type="submit" name="提交">
       
## domain    
   private List<User> users;
   private Map<String,User> map;

>>>Account{username='jwang', id=null, password='xxx', money=10.0, 
			user=User{username='娃说的是', address='阿萨'}, 
			users=[User{username='sad', address='asdas'}], 
			map={one=User{username='asdas', address='asdad'}}}

请求参数中文乱码的解决

在web.xml中配置Spring提供的过滤器类

<!-- 配置过滤器，解决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>
</filter>
<filter-mapping>
  <filter-name>characterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

在控制器中使用原生的ServletAPI对象

只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

@RequestMapping(path = "/hello") //请求映射  路径为/hello
public String sayHello(HttpServletResponse response, HttpServletRequest request){
    System.out.println("hello StringMVC");
    System.out.println(request);
    HttpSession session = request.getSession();
    System.out.println(session);

    ServletContext servletContext = session.getServletContext();
    System.out.println(servletContext);

    System.out.println(response);
    return "success";
}

自定义类型转换器

表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，说明
Spring框架内部会默认进行数据类型转换。
如果想自定义数据类型转换，可以实现Converter的接口

自定义类型转换器

自定义数据类型转换，可以实现Converter的接口


public class StringToDateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String s) {
        if(s == null){
            throw new RuntimeException("请传入一个数据");

        }
        DateFormat df = new SimpleDateFormat("YYYY-MM-dd");
        //字符串转换为日期
        try {
            return df.parse(s);
        } catch (ParseException e) {
            throw new RuntimeException("数据类型转换失败");
        }
    }
}

注册自定义类型转换器，在springmvc.xml配置文件中编写配置

<!--开启springMVC注解支持 默认配置了处理适配器，映射器，视图解析器 -->
    <mvc:annotation-driven conversion-service="conversionService2"/>

    <!-- 配置自定义类型转换器-->
    <bean id="conversionService2" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.jwang.utils.StringToDateConverter"></bean>
            </set>
        </property>
    </bean>

常用的注解

RequestParam注解

作用

把请求中的指定名称的参数传递给控制器中的形参赋值

属性

value:请求参数中的名称
required:请求参数中是否必须提供此参数，默认值是true，必须提供@RequestParam(value=”username”,required=false)
代码如下

<a href="anno/testRequestParam?name=haha">RequestParam</a>

@Controller
@RequestMapping("/anno")
public class AnnoController {

    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam(name = "name") String username){
        System.out.println("RequestParam...."+username);
        return "success";
    }
}

RequestBody注解

作用:

用于获取请求体的内容(注意:get方法不可以)

属性

required:是否必须有请求体，默认值是true

@RequestMapping("/saveUser")
public String saveUser(@RequestBody String body){
    System.out.println(body);
    return "success";
}

PathVariable注解

作用:

拥有绑定url中的占位符的。例如:url中有/delete/{id}，{id}就是占位符方法:findById

属性

value:指定url中的占位符名称

Restful风格的URL

请求路径一样，可以根据不同的请求方式去执行后台的不同方法
restful风格的URL优点
1. 结构清晰
2. 符合标准
3. 易于理解
4. 扩展方便

<form action="user/saveAccount/4" method="post">

@RequestMapping(path = "/saveAccount/{id}")
public String saveAccount(@PathVariable(name = "id") Integer id,Account account){
    account.setId(id);
    System.out.println(account);
    return "success";
}

RequestHeader注解

作用:获取指定请求头的值

属性

value:请求头的名称

public String sayHello(@RequestHeader(value="Accept") String header){}

CookieValue注解

作用:用于获取指定cookie的名称的值

属性

value:cookie的名称

public String sayHello(@CookieValue(value="JSESSIONID") String cookieValue) {}

ModelAttribute注解

作用

出现在方法上:表示当前方法会在控制器方法执行前先执行。
出现在参数上:获取指定的数据给参数赋值。

应用场景

当提交表单数据不是完整的实体数据时，保证没有提交的字段使用数据库原来的数据。

修饰的方法有返回值

 
/**
* 作用在方法，先执行 
* @param name
* @return
*/
@ModelAttribute
public User showUser(String name) {
	System.out.println("showUser执行了..."); 
	// 模拟从数据库中查询对象
	User user = new User(); 
	user.setName("哈哈"); 
	user.setPassword("123"); 
	user.setMoney(100d);
   return user;
}

/**
* 修改用户的方法
* @param cookieValue 
* @return
*/
@RequestMapping(path="/updateUser") 
public String updateUser(User user) {
	System.out.println(user);
	return "success"; 
}

修饰的方法没有返回值

/**
* 作用在方法，先执行 * @param name
* @return
*/
@ModelAttribute
public void showUser(String name,Map<String, User> map) {
	System.out.println("showUser执行了..."); 
	// 模拟从数据库中查询对象
	User user = new User(); 
	user.setName("哈哈"); 
	user.setPassword("123"); 
	user.setMoney(100d);
	map.put("abc", user); }
/**
* 修改用户的方法
* @param cookieValue * @return
*/
@RequestMapping(path="/updateUser")
public String updateUser(@ModelAttribute(value="abc") User user) {
	System.out.println(user);
	return "success"; 
}

SessionAttributes注解

作用

用于多次执行控制器方法间的参数共享

属性

value:指定存入属性的名称

@Controller
@RequestMapping(path="/user")
@SessionAttributes(value= {"username","password","age"},types={String.class,Integer.class}) 
public class HelloController {
	/**
	* 向session中存入值 
	* @return
	*/
	// 把数据存入到session域对象中

	@RequestMapping(path="/save") 
	public String save(Model model) {
		System.out.println("向session域中保存数据"); 
		model.addAttribute("username", "root"); 
		model.addAttribute("password", "123"); 
		model.addAttribute("age", 20);
		return "success"; 
	}
	/**
	* 从session中获取值 
	* @return
	*/
	@RequestMapping(path="/find")
	public String find(ModelMap modelMap) {
		String username = (String) modelMap.get("username"); 
		String password = (String) modelMap.get("password"); 
		Integer age = (Integer) modelMap.get("age"); 
		System.out.println(username + " : "+password +" : "+age); 
		return "success";
	}
	
	/**
	* 清除值
	* @return 
	*/
	@RequestMapping(path="/delete")
	public String delete(SessionStatus status) {
		status.setComplete();
		return "success"; 
	}
}

SpringMVC 响应数据和结果视图

返回值分类

返回字符串

Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址。

<!-- 视图解析器-->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/pages/"/>
    <property name="suffix" value=".jsp"/>
</bean>

 
@RequestMapping(value="/hello") 
public String sayHello() {
	System.out.println("Hello SpringMVC!!"); 
	// 跳转到XX页面
	return "success";
}

具体的应用场景

@Controller 
@RequestMapping("/user") 
public class UserController {
	/**
	* 请求参数的绑定 
	*/
	@RequestMapping(value="/initUpdate") 
	public String initUpdate(Model model) {
	// 模拟从数据库中查询的数据
	User user = new User(); 
	user.setUsername("张三"); 
	user.setPassword("123"); 
	user.setMoney(100d); 
	user.setBirthday(new Date()); 
	model.addAttribute("user", user); 
	return "update";
	} 
}

<h3>修改用户</h3>
${ requestScope }
<form action="user/update" method="post">
	姓名:<input type="text" name="username" value="${ user.username }"><br> 
	密码:<input type="text" name="password" value="${ user.password }"><br> 
	金额:<input type="text" name="money" value="${ user.money }"><br> 
<input type="submit" value="提交">
</form>

返回值是void

如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到。
- 默认会跳转到@RequestMapping(value=”/initUpdate”) initUpdate的页面。自动找视图解析器中配置的/WEB-INF/pages/initUpdate.jsp
可以使用请求转发或者重定向跳转到指定的页面

 
@RequestMapping(value="/initAdd")
public void initAdd(HttpServletRequest request,HttpServletResponse response) throws
Exception { 
	System.out.println("请求转发或者重定向");
	// 请求转发
	// request.getRequestDispatcher("/WEB-INF/pages/add.jsp").forward(request,response);
	// 重定向
	// response.sendRedirect(request.getContextPath()+"/add2.jsp");
	response.setCharacterEncoding("UTF-8"); 
	response.setContentType("text/html;charset=UTF-8");
	// 直接响应数据 
	response.getWriter().print("你好"); 
	return;
}

返回值是ModelAndView对象

ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图

/**
* 返回ModelAndView对象
* 可以传入视图的名称(即跳转的页面)，还可以传入对象。 
* @return
* @throws Exception
*/
@RequestMapping(value="/findAll")
public ModelAndView findAll() throws Exception {
	ModelAndView mv = new ModelAndView(); 
	// 跳转到list.jsp的页面 
	mv.setViewName("list");
	// 模拟从数据库中查询所有的用户信息 
	List<User> users = new ArrayList<>(); 
	User user1 = new User(); 
	user1.setUsername("张三"); 
	user1.setPassword("123");
	
	User user2 = new User(); 
	user2.setUsername("赵四");
	user2.setPassword("456");
	users.add(user1); 
	users.add(user2);
	// 添加对象 
	mv.addObject("users", users);
	return mv;
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
<title>Insert title here</title>
</head>
<body>
<h3>查询所有的数据</h3>
<c:forEach items="${ users }" var="user">
${ user.username } 
</c:forEach>
</body>
</html>

SpringMVC框架提供的转发和重定向

forward请求转发

controller方法返回String类型

想进行请求转发也可以编写

 
/**
* 使用forward关键字进行请求转发
* "forward:转发的JSP路径"，不走视图解析器了，所以需要编写完整的路径 
* @return
* @throws Exception
*/
@RequestMapping("/delete")
public String delete() throws Exception {
	System.out.println("delete方法执行了...");
	// return "forward:/WEB-INF/pages/success.jsp"; 
	return "forward:/user/findAll";
}

redirect重定向

controller方法返回String类型

进行重定向可以编写(项目名称框架默认加上的)

 
/**
* 重定向
* @return
* @throws Exception */
@RequestMapping("/count")
public String count() throws Exception {
	System.out.println("count方法执行了...");
	return "redirect:/add.jsp";
	// return "redirect:/user/findAll";
}

ResponseBody响应json数据

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源(img、css、js)也会被拦截到，从而
不能被使用。解决问题就是需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置

mvc:resources标签配置不过滤

location元素表示webapp目录下的包下的所有文件
mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b

 
<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 --> 
<mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 --> 
<mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->

使用@RequestBody获取请求体数据

// 页面加载
// 页面加载 
$(function(){
	// 绑定点击事件 
	$("#btn").click(function(){
		$.ajax({
			url:"user/testJson", 
			contentType:"application/json;charset=UTF-8", 			data:'{"addressName":"aa","addressNum":100}', 
			dataType:"json",
			type:"post",
			success:function(data){
                alert(data);
					alert(data.addressName); 
					}
				}); 
			});
	}); 
/**
* 获取请求体的数据 
* @param body
*/
@RequestMapping("/testJson")
public void testJson(@RequestBody String body) {
	System.out.println(body); 
}

使用@RequestBody注解把json的字符串转换成JavaBean的对象

 
// 页面加载
// 页面加载 
$(function(){
	// 绑定点击事件 
	$("#btn").click(function(){
		$.ajax({
			url:"user/testJson", 
			contentType:"application/json;charset=UTF-8", 			data:'{"addressName":"aa","addressNum":100}', 
			dataType:"json",
			type:"post",
			success:function(data){
                			alert(data);
					alert(data.addressName); 
					}
				}); 
			});
		});
/**
* 获取请求体的数据 
* @param body
*/
@RequestMapping("/testJson")
public void testJson(@RequestBody Address address) {
		System.out.println(address); 
}

使用@ResponseBody注解把JavaBean对象转换成json字符串，直接响应

要求方法需要返回JavaBean的对象

// 页面加载 
$(function(){
	// 绑定点击事件 
	$("#btn").click(function(){
	$.ajax({
		url:"user/testJson", 
		contentType:"application/json;charset=UTF-8",
		data:'{"addressName":"哈哈","addressNum":100}',
		dataType:"json", type:"post", 
		success:function(data){
               	alert(data);
			alert(data.addressName); 
		}
		}); 
	});
});


@RequestMapping("/testJson")
public @ResponseBody Address testJson(@RequestBody Address address) {
	System.out.println(address); 
	address.setAddressName("上海"); 
	return address;
}

json字符串和JavaBean对象互相转换的过程中，需要使用jackson的jar包

 
<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-core</artifactId> 
	<version>2.9.0</version>
</dependency>
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId> 
	<artifactId>jackson-annotations</artifactId> 
	<version>2.9.0</version>
</dependency>

SpringMVC实现文件上传

以前文件上传方式

导入文件上传的jar包

 
<dependency>
	<groupId>commons-fileupload</groupId> 
	<artifactId>commons-fileupload</artifactId> 
	<version>1.3.1</version>
</dependency>
<dependency>
	<groupId>commons-io</groupId> 
	<artifactId>commons-io</artifactId> 
	<version>2.4</version>
</dependency>

编写文件上传的JSP页面

form表单的 enctype值必须是：multipart/form-data
method属性必须是：post
需提供一个文件域：input type=”file”

<h3>文件上传</h3>
<form action="user/fileupload" method="post" enctype="multipart/form-data"> 
    选择文件:<input type="file" name="upload"/><br/>
    <input type="submit" value="上传文件"/>
</form>

<!--34-->

![](https://jwangblog.oss-cn-chengdu.aliyuncs.com/blog/java/SpringMVC/02/03-%E5%8E%9F%E7%90%86.bmp)

### SpringMVC传统方式文件上传

* SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的
name属性名称相同。

* MultipartFile upload 的upload这个名字与表单的name值需要一样，识别

<!--35-->

* 配置文件解析器对象

<!--36-->

### SpringMVC跨服务器方式文件上传

#### 搭建图片服务器

1. 根据文档配置tomcat9的服务器，现在是2个服务器
2. 导入资料中day02_springmvc5_02image项目，作为图片服务器使用

![](https://jwangblog.oss-cn-chengdu.aliyuncs.com/blog/java/SpringMVC/02/04.bmp)

#### 实现SpringMVC跨服务器方式文件上传

* 导入开发需要的jar包

<!--37-->

* 编写文件上传的JSP页面

<!--38-->

*  编写控制器


<!--39-->

## SpringMVC的异常处理

### 异常处理思路

* Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进 行异常的处理。

![](https://jwangblog.oss-cn-chengdu.aliyuncs.com/blog/java/SpringMVC/02/05.bmp)

### SpringMVC的异常处理

#### 自定义异常类

<!--40-->

#### 自定义异常处理器

```java 
package cn.itcast.exception;
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerExceptionResolver; 
import org.springframework.web.servlet.ModelAndView;
/**
* 异常处理器 * @author rt */
public class SysExceptionResolver implements HandlerExceptionResolver{
    /**
    * 跳转到具体的错误页面的方法 
    */
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse
response, Object handler,Exception ex) { 
    ex.printStackTrace(); 
    SysException e = null; 
    // 获取到异常对象
    if(ex instanceof SysException) { 
        e = (SysException) ex;
    }else {
        e = new SysException("请联系管理员");
    }
    ModelAndView mv = new ModelAndView(); 
    // 存入错误的提示信息 
    mv.addObject("message", e.getMessage()); 
    // 跳转的Jsp页面
    mv.setViewName("error");
    return mv;
    } 
}
<!--41-->

## SpringMVC框架中的拦截器

### 拦截器的概述

![](https://jwangblog.oss-cn-chengdu.aliyuncs.com/blog/java/SpringMVC/02/06.bmp)

1. SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
2. 可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链
中的拦截器会按着定义的顺序执行。
3. 拦截器和过滤器的功能比较类似，有区别
    1. 过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。 
    2. 拦截器是SpringMVC框架独有的。
    3. 过滤器配置了/*，可以拦截任何资源。
    4. 拦截器只会对控制器中的方法进行拦截。
4. 拦截器也是AOP思想的一种实现方式
5. 想要自定义拦截器，需要实现HandlerInterceptor接口。

### 自定义拦截器步骤

#### 创建拦截器类，实现HandlerInterceptor接口，重写需要的方法

package cn.itcast.demo1;
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
/**
* 自定义拦截器1 
* 
* @author rt 
*/
public class MyInterceptor1 implements HandlerInterceptor{
	/**
	* controller方法执行前，进行拦截的方法
	* return true放行, 执行下一个拦截器，没有就实现controller的方法
	* return false拦截
	* 可以使用转发或者重定向直接跳转到指定的页面。 
	*/
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
	Object handler)
		throws Exception { 
		System.out.println("拦截器执行了..."); 
		return true;
	} 
}


#### 在springmvc.xml中配置拦截器类

 
<!-- 配置拦截器 --> 
<mvc:interceptors>
	<mvc:interceptor>
		<!-- 哪些方法进行拦截 -->
		<mvc:mapping path="/user/*"/>
		<!-- 哪些方法不进行拦截
		<mvc:exclude-mapping path=""/>
		-->
		<!-- 注册拦截器对象 -->
		<bean class="cn.itcast.demo1.MyInterceptor1"/>
    	</mvc:interceptor>
</mvc:interceptors>


### HandlerInterceptor接口中的方法

####  preHandle方法是controller方法执行前拦截的方法

1. 可以使用request或者response跳转到指定的页面
2. return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。 
3. return false不放行，不会执行controller中的方法。

#### postHandle是controller方法执行后执行的方法，在JSP视图执行前。 

1. 可以使用request或者response跳转到指定的页面
2. 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。 

#### postHandle方法是在JSP执行后执行

1. request或者response不能再跳转页面了

### 配置多个拦截器

1. 再编写一个拦截器的类 
2. 配置2个拦截器


<!-- 配置拦截器 --> 
<mvc:interceptors>
	<mvc:interceptor>
	<!-- 哪些方法进行拦截 --> 
	<mvc:mapping path="/user/*"/> 
	<!-- 哪些方法不进行拦截 <mvc:exclude-mapping path=""/>-->
  	<!-- 注册拦截器对象 -->
	<bean class="cn.itcast.demo1.MyInterceptor1"/> 
	
	</mvc:interceptor>
	<mvc:interceptor>
	<!-- 哪些方法进行拦截 -->
	<mvc:mapping path="/**"/>
	<!-- 注册拦截器对象 -->
	<bean class="cn.itcast.demo1.MyInterceptor2"/>
    	</mvc:interceptor>
</mvc:interceptors>