Java EE——SpringMVC框架学习

文章目录

一、SpringMVC 概述：

1、简单说一下SpringMVC的概念：

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的轻量级 Web 框架，是 Spring 框架为表现层提供的的后续产品，是目前最主流的 MVC框架之一。

2、SpringMVC 的优势：

1、清晰的角色划分：

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

2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要。

3、由于命令对象就是一个 POJO，无需继承框架特定 API，可以使用命令对象直接作为业务对象。

4、和 Spring 其他框架无缝集成，是其它 Web 框架所不具备的。

5、可适配，通过 HandlerAdapter 可以支持任意的类作为处理器。

6、可定制性，HandlerMapping、ViewResolver 等能够非常简单的定制。

7、功能强大的数据验证、格式化、绑定机制。

扫描二维码关注公众号，回复： 12594752 查看本文章

8、利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试。

9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。

10、强大的 JSP 标签库，使 JSP 编写更容易。

3、SpringMVC在三层架构的位置：
在这里插入图片描述

二、SpringMVC 的入门：

1、使用Maven创建web工程，引入开发的jar包:

需要用的坐标如下：

	 <properties>
        <!-- 版本锁定 -->
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>
		
    <dependencies>
 	   <!-- 单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        
        <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.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

2、配置核心的控制器（配置DispatcherServlet）：

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

<!-- SpringMVC的核心控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
       <!-- 配置servlet的对象的创建时间点，取值只能是非 0 正整数，表示启动顺序。
		“1” 表示应用加载时创建。-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3、编写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">

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.smk"></context:component-scan>
    
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    
    <!-- 配置spring开启注解mvc的支持-->
    <mvc:annotation-driven/>
</beans>

4、编写index.jsp和HelloController控制器类：

index.jsp：

<body>
<h3>入门案例</h3>
<a href="hello">入门案例</a>
</body>

HelloController:

@Controller
public class HelloController {
    
    
    @RequestMapping("/hello")
    public String sayHello() {
    
    
        System.out.println("Hello SpringMVC");
        return "success";
    }
}

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

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

6、启动Tomcat服务器，进行测试：

因为之前一直用的Eclipse，所以这里细说一下IDEA下添加tomcat并发布项目的过程。

1、首先点击箭头所指处添加服务器：

在这里插入图片描述

2、点左上角的加号，找到并选择Tomcat Server下的 Local

在这里插入图片描述
3、在Deployment下点 “+” 号，选择第一个添加项目：

在这里插入图片描述
选择第一个

在这里插入图片描述
箭头处为项目的访问路径，完整路径要加上 localhost:8080

在这里插入图片描述

注：一定要点 Apply，不然无法完成添加。

4、添加完成后会出现Application Server 。

在这里插入图片描述
5、右键运行，IDEA会自动跳转到游览器打开：

在这里插入图片描述

测试成功！（￣︶￣）↗　

三、入门案例的执行过程分析：

1、入门案例的执行流程：

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

图解：

在这里插入图片描述
2、入门案例中的组件分析：

1、前端控制器（DispatcherServlet）

用户请求到达前端控制器，它就相当于 mvc 模式中的 c，dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性。

2、处理器映射器（HandlerMapping）

HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3、处理器适配器（HandlAdapter）

通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4、处理器（Handler）

它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。

5、视图解析器（View Resolver）

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

6、视图（View）

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是 jsp。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

3、<mvc:annotation-driven/>说明：

在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。
使用 <mvc:annotation-driven> 自动加载 RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（处理适配器），可用在SpringMVC.xml 配置文件中使用<mvc:annotation-driven/>替代注解处理器和适配器的配置。
一般开发中，我们都需要写上此标签（虽然从入门案例中看，我们不写也行，随着课程的深入，该标签还有具体的使用场景）。

四、RequestMapping 注解：

1、使用说明：

作用：

用于建立请求 URL 和处理请求方法之间的对应关系。

出现位置：

类上：

请求 URL 的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。

它出现的目的是为了使我们的 URL 可以按照模块化管理：

例如：

账户模块：
/account/add
/account/update
/account/delete
订单模块：
/order/add
/order/update
/order/delete

/accound，/order 就是把 RequsetMappding 写在类上，使我们的 URL 更加精细。

方法上：

属性：

value：用于指定请求的 URL。它和 path 属性的作用是一样的。

method：用于指定请求的方式。

params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样。

例如：
params = {“accountName”}，表示请求参数必须有 accountName
params = {“moeny!100”}，表示请求参数中 money 不能是 100。

headers：用于指定限制请求消息头的条件。

注意：以上四个属性只要出现 2 个或以上时，他们的关系是与的关系。

2、使用示例：

1、出现位置的示例：

控制器代码：

@Controller("accountController")
@RequestMapping("/account")
public class AccountController {
    
    
	@RequestMapping("/findAccount")
	public String findAccount() {
    
    
		System.out.println("查询了账户。。。。");
		return "success";
	}
}

jsp代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>requestmapping 的使用</title>
</head>
<body>
<!-- 第一种访问方式 -->
<a href="${pageContext.request.contextPath}/account/findAccount">
    查询账户
</a>
<br/>
<!-- 第二种访问方式 -->
<a href="account/findAccount">查询账户</a>
</body>
</html>

注意：当使用此种方式配置时，在 jsp 中第二种写法时，不要在访问 URL 前面加/，否则无法找到资源。

2、method 属性的示例：

控制器代码：

@RequestMapping(value="/saveAccount",method=RequestMethod.POST)
public String saveAccount() {
    
    
	System.out.println("保存了账户");
	return "success";
}

jsp 代码：

<!-- 请求方式的示例 -->
<a href="account/saveAccount">保存账户，get 请求</a>
<br/>

<form action="account/saveAccount" method="post">
	<input type="submit" value="保存账户，post 请求">
</form>

当使用 get 请求时，提示错误信息是 405，信息是方法不支持 get 方式请求

在这里插入图片描述
3、params 属性的示例：

控制器的代码：

@RequestMapping(value="/removeAccount",params= {
    
    "accountName","money>100"})
	public String removeAccount() {
    
    
	System.out.println("删除了账户");
	return "success";
	}

jsp 中的代码：

<!-- 请求参数的示例 -->
<a href="account/removeAccount?accountName=aaa&money>100">删除账户，金额 100</a>
<br/>
<a href="account/removeAccount?accountName=aaa&money>150">删除账户，金额 150</a>

当点击第一个超链接时,可以访问成功。
当点击第二个超链接时，无法访问。如下图：

在这里插入图片描述

五、请求参数的绑定：

1、什么是参数绑定？

就是将请求参数串中的value值获取到之后，在进行类型转换，然后将转换后的值赋值给Controller类中方法的形参，这个过程就是参数绑定。

2、绑定说明：

2.1、绑定的机制：

我们都知道，表单中请求参数都是基于 key=value 的。
SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑定的。

例：

jsp 代码：

<a href="account/findAccount?accountId=10">查询账户</a>

jsp中请求参数是：accountId=10

@RequestMapping("/findAccount")
public String findAccount(Integer accountId) {
    
    
	System.out.println("查询了账户。。。。"+accountId);
	return "success";
}

点击链接，会在控制台输出：
在这里插入图片描述
2.2、支持的数据类型：

基本数据类型和 String 类型
POJO 类型参数：包括实体类，以及关联的实体类
集合类型和数组：包括 List 结构和 Map 结构的集合（包括数组）

3、使用示例：

3.1、基本类型和 String 类型作为参数：

jsp 代码：

<!-- 基本类型示例 -->
<a href="account/findAccount?accountId=10&accountName=zhangsan">查询账户</a>

控制器代码：

@RequestMapping("/findAccount")
public String findAccount(Integer accountId,String accountName) {
    
    
	System.out.println("查询了账户。。。。"+accountId+","+accountName);
	return "success";
}

运行结果：

在这里插入图片描述
3.2、POJO 类型作为参数：

实体类代码：

/**
* 账户信息
*/
public class Account implements Serializable{
    
    
	private Integer id;
	private String name;
	private Float money;
	private Address address;
	
	//省略getters and setters 和 tostring方法
	
}

/**
* 地址的实体类
*/
public class Address implements Serializable {
    
    
	private String provinceName;
	private String cityName;
	//省略getters and setters 和 tostring方法	
}

jsp 代码：

<form action="account/saveAccount" method="post">
账户名称：<input type="text" name="name" ><br/>
账户金额：<input type="text" name="money" ><br/>
账户省份：<input type="text" name="address.provinceName" ><br/>
账户城市：<input type="text" name="address.cityName" ><br/>
<input type="submit" value="保存">
</form>

控制器代码：

@RequestMapping("/saveAccount")
public String saveAccount(Account account) {
    
    
	System.out.println("保存了账户。。。。"+account);
	return "success";
}

运行结果：

在这里插入图片描述
3.3、 POJO 类中包含集合类型参数：

实体类代码：

public class User implements Serializable {
    
    
    private String username;
    private String password;
    private Integer age;
    private List<Account> accounts;
    private Map<String, Account> accountMap;
	//省略getters and setters 和 tostring方法

jsp代码：

<form action="account/updateAccount" method="post">
    用户名称：<input type="text" name="username"><br/>
    用户密码：<input type="password" name="password"><br/>
    用户年龄：<input type="text" name="age"><br/>
    账户 1 名称：<input type="text" name="accounts[0].name"><br/>
    账户 1 金额：<input type="text" name="accounts[0].money"><br/>
    账户 2 名称：<input type="text" name="accounts[1].name"><br/>
    账户 2 金额：<input type="text" name="accounts[1].money"><br/>
    账户 3 名称：<input type="text" name="accountMap['one'].name"><br/>
    账户 3 金额：<input type="text" name="accountMap['one'].money"><br/>
    账户 4 名称：<input type="text" name="accountMap['two'].name"><br/>
    账户 4 金额：<input type="text" name="accountMap['two'].money"><br/>
    <input type="submit" value="保存">
</form>

控制器代码：

@RequestMapping("/updateAccount")
public String updateAccount(User user) {
    
    
	System.out.println("更新了账户。。。。"+user);
	return "success";
}

运行结果：
在这里插入图片描述

3.4、请求参数乱码问题：

在web请求中当出现中文时会有乱码。get请求是不会乱码的

当是post 请求方式时，可以在 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>

4、自定义类型转换器：

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

但当我们把控制器中方法参数的类型改为 Date 时：

jsp 代码：

<a href="account/deleteAccount?date=2018-01-01">根据日期删除账户</a>

控制器代码：

@RequestMapping("/deleteAccount")
public String deleteAccount(Date date) {
    
    
	System.out.println("删除了账户。。。。"+date);
	return "success";
}

运行结果：

在这里插入图片描述

会出现类型转化异常。

解决办法：自定义类型转换器

使用步骤：

1、定义一个类，实现 Converter 接口，该接口有两个泛型。

public class StringToDateConverter implements Converter<String, Date> {
    
    
    @Override
    public Date convert(String source) {
    
    
        DateFormat format = null;
        try {
    
    
            if (source == null) {
    
    
                throw new NullPointerException("请输入要转换的日期");
            }
            format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = format.parse(source);
            return date;
        } catch (Exception e) {
    
    
            throw new RuntimeException("输入日期有误");
        }
    }
}

2、第二步：在 spring 配置文件中配置类型转换器。

  <!-- 配置类型转换器工厂 -->
    <bean id="converterService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <!-- 给工厂注入一个新的类型转换器 -->
        <property name="converters">
            <array>
                <!-- 配置自定义类型转换器 -->
                <bean class="com.smk.util.StringToDateConverter"/>
            </array>
        </property>
    </bean>

3、第三步：在 annotation-driven 标签中引用配置的类型转换服务。

<!-- 引用自定义类型转换器 -->
<mvc:annotation-driven conversion-service="converterService"/>

运行结果：

在这里插入图片描述

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

SpringMVC 还支持使用原始 ServletAPI 对象作为控制器方法的参数。支持原始 ServletAPI 对象有：

HttpServletRequest、HttpServlet、ResponseHttpSession 等…

使用方法：

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

例：

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request,HttpServletResponse response,HttpSession session) {
    
    
	System.out.println(request);
	System.out.println(response);
	System.out.println(session);
	return "success";
}

六、常用注解：

1、RequestParam注解：

作用：把请求中指定名称的参数给控制器中的形参赋值。

属性：

value：请求参数中的名称
required：请求参数中是否必须提供此参数，默认值是true，表示必须提供，如果不提供将报错。

例：

jsp 中的代码：

<!-- requestParams 注解的使用 -->
<a href="springmvc/useRequestParam?name=test">requestParam 注解</a>

控制器中的代码：

@RequestMapping("/useRequestParam")
public String useRequestParam(@RequestParam("name")String username,@RequestParam(value="age",required=false)Integer age){
    
    
	System.out.println(username+","+age);
	return "success";
}

运行结果：

在这里插入图片描述

2、RequestBody注解：

作用：

用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。
get 请求方式不适用。（因为get没有请求体）

属性：

required：是否必须有请求体，默认值是true。当取值为 true 时，get 请求方式会报错。如果取值为 false，get 请求得到是 null。

例：

post 请求 jsp 代码：

<form action="useRequestBody" method="post">
用户名称：<input type="text" name="username" ><br/>
用户密码：<input type="password" name="password" ><br/>
用户年龄：<input type="text" name="age" ><br/>
<input type="submit" value="保存">
</form>

get 请求 jsp 代码：

<a href="springmvc/useRequestBody?body=test">requestBody 注解 get 请求</a>

控制器代码：

@RequestMapping("/useRequestBody")
public String useRequestBody(@RequestBody(required=false) String body){
    
    
	System.out.println(body);
	return "success";
}

post 请求运行结果：

在这里插入图片描述

get 请求运行结果：

在这里插入图片描述
3、PathVariable注解：

作用：

用于绑定 url 中的占位符赋值给形参。例如：请求 url 中 /delete/{id}，这个 {id} 就是 url 占位符。
url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志。

属性：

value：用于指定 url 中占位符名称。
required：是否必须提供占位符。

使用示例：

jsp 代码：

<a href="usePathVariable/100">pathVariable 注解</a>

控制器代码：

@RequestMapping("/usePathVariable/{id}")
public String usePathVariable(@PathVariable("id") Integer id){
    
    
	System.out.println(id);
	return "success";
}

运行结果：

在这里插入图片描述

Restful风格的URL：

请求路径一样，可以根据不同的请求方式去执行后台的不同方法。

在这里插入图片描述

restful风格的URL优点：

结构清晰
符合标准
易于理解
扩展方便

4、RequestHeader注解：

作用：

用于获取请求消息头。

属性：

value：提供消息头名称
required：是否必须有此消息头

注：在实际开发中一般不怎么用。

jsp 中代码：

<a href="useRequestHeader">获取请求消息头</a>

控制器中代码：

@RequestMapping("/useRequestHeader")
    public String useRequestHeader(@RequestHeader(value = "Accept-Language",
            required = false) String requestHeader) {
    
    
        System.out.println(requestHeader);
        return "success";
    }

运行结果：

在这里插入图片描述

6、ModelAttribute注解：

作用：

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

属性：

value：用于获取数据的 key。key 可以是 POJO 的属性名称，也可以是 map 结构的 key。

应用场景：

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

示例：

jps 代码：

<a href="testModelAttribute?username=test">测试 modelattribute</a>

控制器代码：

//接收请求的方法
@RequestMapping("/testModelAttribute")
public String testModelAttribute(User user) {
    
    
	System.out.println("执行了控制器的方法"+user.getUsername());
	return "success";
}

//被 ModelAttribute 修饰的方法
@ModelAttribute
public void showModel(User user) {
    
    
	System.out.println("执行了 showModel 方法"+user.getUsername());
}

运行结果：

在这里插入图片描述
ModelAttribute 修饰方法带返回值：

jsp 的代码：

<!-- 修改用户信息 -->
<form action="updateUser" method="post">
用户名称：<input type="text" name="username" ><br/>
用户年龄：<input type="text" name="age" ><br/>
<input type="submit" value="保存">
</form>

控制器中的代码：

	@RequestMapping("/testModelAttribute2")
	//获取 ModelAttribute修饰的方法中的 User对象
	  public String testModelAttribute2(User user) {
    
    
	      System.out.println(user);
	      return "success";
	  }

	@ModelAttribute
	private User showUser(String username) {
    
    
	    //模拟数据库查询，把查询到的数据传入 user 中
	    User user = new User();
	    user.setUsername(username);
	    user.setAge(19);
	    user.setBirthday(new Date());
	    return user;
	}

运行结果：

在这里插入图片描述
先执行ModelAttribute修饰的方法，然后在把jsp中的数据覆盖user 的值，所以这里的年龄和设置的不一样。

ModelAttribute 修饰方法不带返回值：

jsp 的代码：同上

控制器中的代码：

 @RequestMapping("/testModelAttribute2")
 	//把 ModelAttribute修饰的方法里的 map里 key的值赋给 user
    public String testModelAttribute2(@ModelAttribute("abc") User user) {
    
    
        System.out.println(user);
        return "success";
    }

 @ModelAttribute
  private void showUser(String username, Map<String, User> map) {
    
    
      //模拟数据库查询，把查询到的数据传入 user 中
      User user = new User();
      user.setUsername(username);
      user.setAge(19);
      user.setBirthday(new Date());
      map.put("abc", user);
  }

运行结果：

在这里插入图片描述

7、SessionAttribute：

作用：

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

属性：

value：用于指定存入的属性名称
type：用于指定存入的数据类型

使用示例：

jsp 中的代码：

<a href="testPut">存入 SessionAttribute</a>
<hr/>
<a href="testGet">取出 SessionAttribute</a>
<hr/>
<a href="testDel">清除 SessionAttribute</a>

控制器中的代码：

@Controller
@SessionAttributes(value = {
    
    "msg"})//把 msg = 张三 存入到session域中
public class HelloController {
    
    
       @RequestMapping("/testPut")
    public String testPut(Model model) {
    
    
        System.out.println(" testPut...");
        //底层会存储到request域对象中
        model.addAttribute("msg", "张三");
        return "success";
    }

    @RequestMapping("/testGet")
    public String testGet(ModelMap model) {
    
    
        System.out.println("testGet...");
        String msg = (String) model.get("msg");
        System.out.println(msg);
        return "success";
    }
    
	//完成会话，清除session域的值
    @RequestMapping("/testDel")
    public String testDel(SessionStatus status) {
    
    
        System.out.println("testDel...");
        status.setComplete();
        return "success";
    }

在success.jsp 中获取数据：

在这里插入图片描述
三个方法依次执行，结果如下：

游览器：

存入：
在这里插入图片描述
删除：

控制台：

在这里插入图片描述

七、响应数据和结果视图：

1、返回值分类：

1.1、返回字符串类：

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

@RequestMapping("/testReturnString")
public String testReturnString() {
    
    
	System.out.println("AccountController 的 testReturnString 方法执行了。。。。");
	return "success";
}

1.2、返回void：

如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到。

默认会跳转到当前 RequestMapping注解 value值同名的 jsp 页面。

例：

在这里插入图片描述
Controller页面：

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/testString")
    public void testString() {
    
    
        System.out.println("testString方法执行了...");
    }
}

这时可以新建 /WEB-INF/pages/user/testString.jsp 文件解决问题，或者可以使用请求转发或者重定向跳转到指定的页面。

例：

    @RequestMapping("/testReturnVoid")
    public void testReturnVoid(HttpServletRequest request, HttpServletResponse response)
            throws Exception {
    
    
        // 1、使用 request 转向页面，如下：
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);

        //2、也可以通过 response 页面重定向：
        response.sendRedirect( "index.jsp"); 

        //3、也可以通过 response 指定响应结果：
        response.setCharacterEncoding("utf-8");
        response.setContentType("application/json;charset=utf-8");
        
        response.getWriter().write("json 串");
    }

注意：

如果是重定向到 jsp 页面，则 jsp 页面必须在根目录下即 webapp目录下，不能写在 WEB-INF 目录中，否则无法找到。

1.3、返回值是ModelAndView对象：

ModelAndView 是 SpringMVC 为我们提供的一个对象，该对象也可以用作控制器方法的返回值。

示例代码：

 @RequestMapping("/testReturnModelAndView")
    public ModelAndView testReturnModelAndView() {
    
    
        ModelAndView mv = new ModelAndView();
        mv.addObject("username", "张三");
        mv.setViewName("success");// 设置要跳转到的jsp的页面，是经过视图解析器的。
        return mv;
    }

运行结果：

在这里插入图片描述

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

2.1、forward 转发：

controller 方法在提供了 String 类型的返回值之后，默认就是请求转发。也可以写成：

@RequestMapping("/testForward")
public String testForward() {
    
    
	System.out.println("AccountController 的 testForward 方法执行了。。。。");
	return "forward:/WEB-INF/pages/success.jsp";
}

它相当于 request.getRequestDispatcher("url").forward(request,response) 。使用请求转发，既可以转发到 jsp，也可以转发到其他的控制器方法。

2.2、Redirect 重定向：

contrller 方法提供了一个 String 类型返回值之后，它需要在返回值里使用：redirect

@RequestMapping("/testRedirect")
public String testRedirect() {
    
    
	System.out.println("AccountController 的 testRedirect 方法执行了。。。。");
	return "redirect:testReturnModelAndView";
}

它相当于 response.sendRedirect(url)，同样的：如果是重定向到 jsp 页面，则 jsp 页面必须在根目录下即 webapp目录下，不能写在 WEB-INF 目录中，否则无法找到。

八、SpringMVC 实现文件上传：

1. 文件上传的回顾:

1.1、文件上传的必要前提：

form 表单的 enctype 取值必须是：multipart/form-data(默认值是:application/x-www-form-urlencoded)
enctype 是表单请求正文的类型
method 属性取值必须是 Post

1.2、文件上传的原理分析：

当 form 表单的 enctype 取值不是默认值后，request.getParameter() 将失效。

当 enctype = “application/x-www-form-urlencoded” 时，form 表单的正文内容是：key=value&key=value&key=value

当 form 表单的 enctype 取值为 Mutilpart/form-data 时，请求正文内容就变成：

每一部分都是 MIME 类型描述的正文

-----------------------------7de1a433602ac  分界符
Content-Disposition: form-data; name="userName" 协议头
aaa   协议的正文（文件内容）
-----------------------------7de1a433602ac 
Content-Disposition: form-data; name=“file”;
filename=“C:\Users\zhy\Desktop\fileupload_demofile\b.txt”
Content-Type: text/plain	协议的类型（MIME 类型）
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
-----------------------------7de1a433602ac--

1.3、实现步骤:

导入文件上传需要的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 action="user/fileupload1" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload"/><br/>
    <input type="submit" value="上传文件"/>
</form>

编写文件上传的Controller控制器：

@RequestMapping(value = "/fileupload1")
    public String fileupload(HttpServletRequest request) throws Exception {
    
    
        // 先获取到要上传的文件目录
        String path = request.getSession().getServletContext().getRealPath("/uploads");
        System.out.println(path);
        // 创建File对象，一会向该路径下上传文件
        File file = new File(path);
        // 判断路径是否存在，如果不存在，创建该路径
        if (!file.exists()) {
    
    
            file.mkdirs();
        }
        // 创建磁盘文件项工厂
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload fileUpload = new ServletFileUpload(factory);
        // 解析request对象
        List<FileItem> list = fileUpload.parseRequest(request);
        // 遍历
        for (FileItem fileItem : list) {
    
    
            // 判断文件项是普通字段，还是上传的文件
            if (fileItem.isFormField()) {
    
    
            } else {
    
    
                // 上传文件项
                // 获取到上传文件的名称
                String filename = fileItem.getName();
                //生成唯一id，防止文件覆盖
                String uuid = UUID.randomUUID().toString().replace("-", "");//把uuid里的"-"替换成""
                filename = uuid + filename;
                // 上传文件
                fileItem.write(new File(file, filename));
                // 删除临时文件
                fileItem.delete();
            }
        }
        return "success";
    }

2、SpringMVC传统方式文件上传：

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

即：

在这里插入图片描述

jsp页面：

<h3>SpringMVC文件上传</h3>

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

控制器代码：

@RequestMapping(value = "/fileupload2")
    public String fileupload2(HttpServletRequest request, MultipartFile upload) throws Exception {
    
    
        System.out.println("SpringMVC方式的文件上传...");
        // 先获取到要上传的文件目录
        String path = request.getSession().getServletContext().getRealPath("/uploads");
        // 创建File对象，一会向该路径下上传文件
        File file = new File(path);
        // 判断路径是否存在，如果不存在，创建该路径
        if (!file.exists()) {
    
    
            file.mkdirs();
        }
        // 获取到上传文件的名称
        String filename = upload.getOriginalFilename();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        // 把文件的名称唯一化
        filename = uuid + "_" + filename;
        // 上传文件
        upload.transferTo(new File(file, filename));
        return "success";
    }

3、配置文件解析器对象：

    <!-- 配置文件解析器对象，要求id名称必须是multipartResolver -->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/>
    </bean>

注意：

一但采用 MultipartResolver 进行文件上传，MultipartResolver 根据请求头部的的 content-type 判断是否含有 ”multipart/form-data”。如果有，则把请求封装成 MultipartFile。

这时传统的上传方式就不能用了。

3、SpringMVC跨服务器方式文件上传：

1、分服务器的目的：

在实际开发中，会有很多处理不同功能的服务器。例如：

应用服务器：负责部署我们的应用
数据库服务器：运行我们的数据库
缓存和消息服务器：负责处理大并发访问的缓存和消息
文件服务器：负责存储用户上传文件的服务器。

分服务器处理的目的是让服务器各司其职，从而提高项目的运行效率。

在这里插入图片描述
实现步骤：

1、创建两个web项目，其中一个作为上传服务器使用，并都在tomcat 进行发布。

2、实现SpringMVC跨服务器方式文件上传：

导入开发需要的jar包：

<dependency>
	<groupId>com.sun.jersey</groupId>
	<artifactId>jersey-core</artifactId>
	<version>1.18.1</version>
</dependency>
<dependency>
	<groupId>com.sun.jersey</groupId>
	<artifactId>jersey-client</artifactId>
	<version>1.18.1</version>
</dependency>

编写文件上传的JSP页面：

<h3>跨服务器文件上传</h3>
<form action="fileupload3" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload"/><br/>
    <input type="submit" value="上传文件"/>
</form>

编写控制器：

  @RequestMapping(value = "/fileupload3")
    public String fileupload3(MultipartFile upload) throws Exception {
    
    
        System.out.println("SpringMVC跨服务器方式的文件上传...");
        // 定义图片服务器的请求路径
        String path = "http://localhost:9090/fileupload/uploads /";
        // 获取到上传文件的名称
        String filename = upload.getOriginalFilename();
        String uuid = UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();
        // 把文件的名称唯一化
        filename = uuid + "_" + filename;
        // 向图片服务器上传文件
        // 创建客户端对象
        Client client = Client.create();
        // 连接图片服务器
        WebResource webResource = client.resource(path + filename);
        // 上传文件
        webResource.put(upload.getBytes());
        return "success";
    }

需要注意的是：图片服务器里的 uploads 文件需要自己创建，在Tomcat 服务器的 webapps的根目录下创建。

在这里插入图片描述

上传成功。

9、SpringMVC 中的异常处理：

若遇到错误或者异常，返回给用户一个良好的错误信息比直接返回报错的游览器页面要好的多。

当系统的 dao、service、controller 出现异常时都是向上抛出的，最后由 springmvc 前端控制器交由异常处理器进行异常处理，如下图：

在这里插入图片描述

1、SpringMVC的异常处理：

模拟异常信息：

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/testException")
    public String testException() throws SysException {
    
    
        System.out.println("testException执行了...");
        try {
    
    
            //模拟异常
            int a = 10 / 0;
        } catch (Exception e) {
    
    
            //控制台打印异常信息
            e.printStackTrace();
            //抛出自定义异常类信息
            throw new SysException("查询所有用户出现了错误！");
        }
        return "success";
    }
}

自定义异常类：

public class SysException extends Exception {
    
    
    private String message;

    public String getMessage() {
    
    
        return message;
    }

    public SysException(String message) {
    
    
        this.message = message;
    }
}

自定义异常处理器：

public class SysExceptionResolver implements HandlerExceptionResolver {
    
    
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
    
    

        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;
    }
}

配置异常处理器

<!-- 配置异常处理器 -->
<bean id="sysExceptionResolver" class="cn.itcast.exception.SysExceptionResolver"/>

运行结果：

在这里插入图片描述

10、SpringMVC框架中的拦截器

1、拦截器的作用：

1、Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。

2、可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行。

3、拦截器和过滤器的功能比较类似，区别是：

过滤器是 servlet 规范中的一部分，任何 java web 工程都可以使用。
拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用。
过滤器在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截。
拦截器它是只会拦截访问的控制器方法，如果访问的是 jsp，html,css,image 或者 js 是不会进行拦截的。

想要自定义拦截器，要求必须实现：HandlerInterceptor 接口。

2、自定义拦截器的步骤：

2.1、创建类，实现HandlerInterceptor接口：

public class MyInterceptor1 implements HandlerInterceptor {
    
    


    /**
     * controller方法执行前，进行拦截的方法
     * return true放行
     * return false拦截
     * 可以使用转发或者重定向直接跳转到指定的页面。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        System.out.println("preHandle 方法执行了...");
        return true;

    }
    
    /**
     * controller方法执行后，进行拦截的方法
     * 可以使用转发或者重定向直接跳转到指定的页面。
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        System.out.println("postHandle 方法执行了");

    }
    
    /**
     * JSP执行后执行
     * 不可以使用转发或者重定向直接跳转到指定的页面。
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        System.out.println("afterCompletion 方法执行了");
    }

}

2.2、在springmvc.xml中配置拦截器类：

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

2.3、controller 类代码：

@Controller
public class UserController {
    
    
    @RequestMapping("/testInterceptor")
    public String testInterceptor() {
    
    
        System.out.println("testInterceptor执行了...");
        return "success";
    }
}

运行结果：

在这里插入图片描述
3、HandlerInterceptor接口中的方法：

1、preHandle方法是controller方法执行前拦截的方法

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

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

可以使用request或者response跳转到指定的页面
如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
如果controller 被拦截了则不会执行。

3、afterCompletion方法是在DispatcherServlet进行视图的渲染之后执行

request或者response不能再跳转页面了
如果controller方法被拦截了，也会执行！

4、配置多个拦截器：

配置第2个拦截器

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

运行结果：

在这里插入图片描述