SpringMVC Reference

2023-01-03

SpringMVC简介

MVC模式

　MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的开发思想。

* M（model）模型：处理业务逻辑，封装实体
* V（view） 视图：展示内容
* C（controller）控制器：负责调度分发（1.接收请求、2.调用模型、3.转发到视图）

MVC

SpringMVC概述

　SpringMVC 是一种基于 Java 的实现 MVC 设计模式的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。

　SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

springmvc

　SpringMVC的框架就是封装了原来Servlet中的共有行为；例如：参数封装，视图转发等。

快速上手

　客户端发起请求，服务器接收请求，执行逻辑并进行视图跳转

创建web项目，导入SpringMVC相关坐标
配置SpringMVC前端控制器 DispathcerServlet
编写Controller类和视图页面
使用注解配置Controller类中业务方法的映射地址
配置SpringMVC核心文件 spring-mvc.xml
创建web项目，导入SpringMVC相关坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.soulboy</groupId>
    <artifactId>springmvc_quickstart</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--指定编码及版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.11</java.version>
        <maven.compiler.source>1.11</maven.compiler.source>
        <maven.compiler.target>1.11</maven.compiler.target>
    </properties>

    <!-- 打包方式 -->
    <packaging>war</packaging>

    <dependencies>
        <!--springMVC坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--servlet坐标-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--jsp坐标-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

1.1 创建webapp目录

配置SpringMVC前端控制器 DispathcerServlet

src/main/webapp/WEB-INF/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">

    <!--前端控制器-->
    <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>
        <!-- 在程序启动时候实例化servlet实例化初始化操作 -->
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!-- / 表示会匹配到所有的访问路径，但是不会匹配到像 *.jsp这样的方法url -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

编写Controller类和视图页面，使用注解配置Controller类中业务方法的映射地址

UserController

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {
    @RequestMapping("/quick")
    public String quick() {
        // 业务逻辑
        System.out.println("springmvc快速上手！");
        // 视图跳转 ： 请求转发
        return "success";
    }
}

src/main/webapp/WEB-INF/pages/success.jsp

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/26
  Time: 18:41
  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>
    <h3>springmvc快速上手!</h3>
</body>
</html>

配置SpringMVC核心文件 spring-mvc.xml

src/main/resources/spring-mvc.xml

<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.soulboy.controller"/>

    <!--处理器映射器和处理器适配器功能增强 :支持json的读写-->
    <mvc:annotation-driven/>

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

添加tomcat服务器启动并测试

http://localhost:8080/springmvc_quickstart/quick

web工程执行流程

SpringMVC是对MVC设计模式的一种实现，属于轻量级的WEB框架。
SpringMVC的开发步骤：
1.创建web项目，导入SpringMVC相关坐标
2.配置SpringMVC前端控制器 DispathcerServlet
3.编写Controller类和视图页面
4.使用注解配置Controller类中业务方法的映射地址
5.配置SpringMVC核心文件 spring-mvc.xml

工作流程

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将渲染后的视图响应响应用户。

SpringMVC组件解析

前端控制器：DispatcherServlet
用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。
处理器映射器：HandlerMapping
HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
处理器适配器：HandlerAdapter
通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
处理器：Handler【开发者编写】
它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到Handler。由Handler 对具体的用户请求进行处理。
视图解析器：ViewResolver
View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。
视图：View 【开发者编写】
SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

SpringMVC的三大组件
处理器映射器：HandlerMapping
处理器适配器：HandlerAdapter
视图解析器：View Resolver
开发者编写
处理器：Handler
视图：View

SpringMVC注解解析

@Controller
　SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用：

<!--配置注解扫描-->
    <context:component-scan base-package="com.soulboy.controller"/>

@RequestMapping

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

* 位置：
	1.类上：请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。
		它出现的目的是为了使我们的URL可以按照模块化管理:
		用户模块
			/user/add
			/user/update
			/user/delete
			...
		账户模块
			/account/add
			/account/update
			/account/delete
	2.方法上：请求URL的第二级访问目录，和一级目录组成一个完整的 URL 路径。

* 属性：
	1.value：用于指定请求的URL。它和path属性的作用是一样的
	2.method：用来限定请求的方式
	3.params：用来限定请求参数的条件
	    例如：params={"accountName"} 表示请求参数中必须有accountName
		      pramss={"money!100"} 表示请求参数中money不能是100

SpringMVC的请求

请求参数类型

　客户端请求参数的格式是： name=value&name=value……
　服务器要获取请求的参数的时候要进行类型转换，有时还需要进行数据的封装
　SpringMVC可以接收如下类型的参数：

基本类型参数
对象类型参数
数组类型参数
集合类型参数

获取基本类型参数

　Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。并且能自动做类型转换；自动的类型转换是指从String向其他类型的转换。

src/main/webapp/requestParam.jsp

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/27
  Time: 15:44
  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>
    <%-- 动态的获取项目路径：${pageContext.request.contextPath}  get请求方式--%>
    <a href="${pageContext.request.contextPath}/user/simpleParam?id=1&username=杰克">
        基本类型
    </a>
</body>
</html>

Controller：com/soulboy/controller/UserController.java

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick")
    public String quick() {
        // 业务逻辑
        System.out.println("springmvc快速上手！");
        // 视图跳转 : 请求转发
        return "success";
    }

    /**
     * 获取基本类型请求参数
     */
    @RequestMapping("simpleParam")
    public String simpleParam(Integer id,String username) {
        System.out.println(id);
        System.out.println(username);
        return "success";
    }
}

测试访问url： http://localhost:8080/springmvc_quickstart/requestParam.jsp

获取对象类型参数

　Controller中的业务方法参数的POJO属性名与请求参数的name一致，参数值会自动映射匹配

JSP页面：src/main/webapp/requestParam.jsp

<form action="${pageContext.request.contextPath}/user/pojoParam" method="post">
        编号：<input type="text" name="id"> <br>
        用户名：<input type="text" name="username"> <br>
        <input type="submit" value="对象类型">
    </form>

POJO

package com.soulboy.domain;

public class User {
    Integer id;
    String username;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                '}';
    }
}

Controller
com/soulboy/controller/UserController.java

/**
     * 获取对象类型请求参数
     */
    @RequestMapping("pojoParam")
    public String pojoParam(User user) {
        System.out.println(user);
        return "success";
    }

测试： http://localhost:8080/springmvc_quickstart/requestParam.jsp

User{id=1, username='é????????'}

中文乱码过滤器

　get方法tomcat8.5内部已经解决，但是post方法需要自己解决。
　当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。

src/main/webapp/WEB-INF/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">

    <!--配置全局过滤的filter-->
    <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>

    <!--前端控制器-->
    <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>
        <!-- 在程序启动时候实例化servlet实例化初始化操作 -->
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!-- / 表示会匹配到所有的访问路径，但是不会匹配到像 *.jsp这样的方法url -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

获取数组类型参数

　Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。

jsp

<form action="${pageContext.request.contextPath}/user/arrayParam">
        编号：<br>
        <input type="checkbox" name="ids" value="1">1<br>
        <input type="checkbox" name="ids" value="2">2<br>
        <input type="checkbox" name="ids" value="3">3<br>
        <input type="checkbox" name="ids" value="4">4<br>
        <input type="checkbox" name="ids" value="5">5<br>
        <input type="submit" value="数组类型">
    </form>

Controller

/**
     * 获取数组类型请求参数
     */
    @RequestMapping("/arrayParam")
    public String arrayParam(Integer[] ids) {
        System.out.println(Arrays.toString(ids));
        return "success";
    }

测试页面
http://localhost:8080/springmvc_quickstart/requestParam.jsp

获取数组类型参数

　获得集合参数时，要将集合参数包装到一个POJO中才可以。

JSP

搜索关键字：
        <input type="text" name="keyword"> <br>
        user对象：
        <input type="text" name="user.id" placeholder="编号">
        <input type="text" name="user.username" placeholder="姓名"><br>
        list集合<br>
        第一个元素：
        <input type="text" name="userList[0].id" placeholder="编号">
        <input type="text" name="userList[0].username" placeholder="姓名"><br>
        第二个元素：
        <input type="text" name="userList[1].id" placeholder="编号">
        <input type="text" name="userList[1].username" placeholder="姓名"><br>
        map集合<br>
        第一个元素：
        <input type="text" name="userMap['u1'].id" placeholder="编号">
        <input type="text" name="userMap['u1'].username" placeholder="姓名"><br>
        第二个元素：
        <input type="text" name="userMap['u2'].id" placeholder="编号">
        <input type="text" name="userMap['u2'].username" placeholder="姓名"><br>
        <input type="submit" value="复杂类型">
    </form>

QueryVo

package com.soulboy.domain;

import java.util.List;
import java.util.Map;

public class QueryVo {
    private String keyword;
    private User user;
    private List<User> userList;
    private Map<String, User> userMap;

    public String getKeyword() {
        return keyword;
    }

    public void setKeyword(String keyword) {
        this.keyword = keyword;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public List<User> getUserList() {
        return userList;
    }

    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    public Map<String, User> getUserMap() {
        return userMap;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    @Override
    public String toString() {
        return "QueryVo{" +
                "keyword='" + keyword + '\'' +
                ", user=" + user +
                ", userList=" + userList +
                ", userMap=" + userMap +
                '}';
    }
}

Controller

/**
     * 获取集合类型请求参数
     */
    @RequestMapping("/queryParam")
    public String queryParam(QueryVo queryVo) {
        System.out.println(queryVo);
        return "success";
    }

测试：http://localhost:8080/springmvc_quickstart/requestParam.jsp
QueryVo{keyword='语文', user=User{id=1, username='高晓松'}, userList=[User{id=1, username='秃秃'}, User{id=2, username='妞妞'}], userMap={u1=User{id=1, username='高中美'}, u2=User{id=2, username='高中直'}}}

自定义类型转换器

　SpringMVC 默认已经提供了一些常用的类型转换器；例如：客户端提交的字符串转换成int型进行参数设置，日期格式类型要求为：yyyy/MM/dd 不然的话会报错，对于特有的行为，SpringMVC提供了自定义类型转换器方便开发者自定义处理。

JSP页面

<form action="${pageContext.request.contextPath}/user/converterParam">
        生日：<input type="text" name="birthday">
        <input type="submit" value="自定义类型转换器">
    </form>

Controller

/**
     * 自定义类型转换器（自定义类型）
     */
    @RequestMapping("/converterParam")
    public String converterParam(Date birthday) {
        System.out.println(birthday);
        return "success";
    }

自定义类型转换器
com/soulboy/converter/DateConverter.java

package com.soulboy.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> {
    
    // s 就是表单传递过来的请求参数
    @Override
    public Date convert(String s) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

配置自定义转换器

spring-mvc.xml

<!--处理器映射器和处理器适配器功能增强 :支持json的读写-->
    <mvc:annotation-driven conversion-service="conversionService"/>

    <!--自定义转换器配置-->
    <bean id="conversionService"
          class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.soulboy.converter.DateConverter"></bean>
            </set>
        </property>
    </bean>

获取Servlet相关API

　SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，如果在controller的中需要使用原始的ServletAPI的话，常用的对象如下：

/**
     * 获取原始ServletAPI对象
     */
    @RequestMapping("/servletAPI")
    public String servletAPI(HttpServletRequest request, HttpServletResponse
            response, HttpSession session) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
        return "success";
    }

测试：http://localhost:8080/springmvc_quickstart/user/servletAPI

org.apache.catalina.connector.RequestFacade@50f4a1a3
org.apache.catalina.connector.ResponseFacade@34797d7c
org.apache.catalina.session.StandardSessionFacade@5ff70c1e

SpringMVC的响应

SpringMVC响应方式

页面跳转

1. 返回字符串逻辑视图（请求转发）
2. void原始ServletAPI
3. ModelAndView

返回数据

1. 直接返回字符串数据
```java
@RequestMapping("/returnVoid")
    public void returnVoid(HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        //三选一
        // 1.通过response直接响应数据
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("拉勾网");
        request.setAttribute("username", "拉勾教育");
    }

将对象或集合转为json返回

返回字符串逻辑视图（页面跳转）
　直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转到指定页面

@RequestMapping("/returnString")
    public String returnString() {
        return "success";
    }

void原始ServletAPI（页面跳转）
　通过request、response对象实现响应

@RequestMapping("/returnVoid")
    public void returnVoid(HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        //三选一
        // 1.通过response直接响应数据
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("拉勾网");
        request.setAttribute("username", "拉勾教育");

        // 2.通过request实现转发
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);

        // 3.通过response实现重定向：重定向地址栏会发生改变
        response.sendRedirect(request.getContextPath() + "/index.jsp");
    }

转发和重定向

forward转发

　企业开发我们一般使用返回字符串逻辑视图实现页面的跳转，这种方式其实就是请求转发。
　我们也可以写成：forward转发
　如果用了forward：则路径必须写成实际视图url，不能写逻辑视图。它相当于：
　request.getRequestDispatcher("url").forward(request,response)
　使用请求转发，既可以转发到jsp，也可以转发到其他的控制器方法。

@RequestMapping("/forward")
    public String forward(Model model) {
        // 还想在模型中设置一些值（Model相当于域）， 在JSP页面中使取值方法如下：${username}
        model.addAttribute("username", "soulboy");
        // 使用请求转发，既可以转发到jsp，也可以转发到其他的控制器方法。forward转发
	// return "forward:/product/findAll";
        return "forward:/WEB-INF/pages/success.jsp";
    }

Redirect重定向
　我们可以不写虚拟目录，springMVC框架会自动拼接，并且将Model中的数据拼接到url地址上

@RequestMapping("/redirect")
    public String redirect(Model model) {
        //底层使用的还是request.setAttribute("username","拉钩教育") 域范围：一次请求     重定向是两次请求，所以 ${username} 取不到，要使用转发才可以
        model.addAttribute("username", "拉勾教育");
        // 不能重定向到WEB-INF目录下的页面
        return "redirect:/index.jsp";
    }

ModelAndVie（页面跳转）
　既可以设置模型数据，又可以设置视图名称
方式一
　在Controller中方法创建并返回ModelAndView对象，并且设置视图名称

@RequestMapping("/returnModelAndView1")
    public ModelAndView returnModelAndView1() {
        /*
        Model:模型 作用封装数据
        View：视图 作用展示数据
        */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username", " lagou");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

方式二
　在Controller中方法形参上直接声明ModelAndView，无需在方法中自己创建，在方法中直接使用该对象设置视图，同样可以跳转页面

@RequestMapping("/returnModelAndView2")
    public ModelAndView returnModelAndView2(ModelAndView modelAndView) {
        //设置模型数据
        modelAndView.addObject("username", "itheima");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

@SessionAttributes
　如果在多个请求之间共用数据，则可以在控制器类上标注一个 @SessionAttributes,配置需要在session中存放的数据范围，Spring MVC将存放在model中对应的数据暂存到 HttpSession 中。

com.soulboy.controller.UserController

@Controller
@RequestMapping("/user")
@SessionAttributes("username") //向request域存入的key为username时，同步到session域中
public class UserController {

    @RequestMapping("/forward")
    public String forward(Model model) {
        model.addAttribute("username", "子慕");
        return "forward:/WEB-INF/pages/success.jsp";
    }

    @RequestMapping("/returnString")
    public String returnString() {
        return "success";
    }
}

src/main/webapp/WEB-INF/pages/success.jsp

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/26
  Time: 18:41
  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>
    <h3>springmvc快速上手!…… ${username}</h3>
</body>
</html>

测试

http://localhost:8080/springmvc_quickstart/user/forward
	springmvc快速上手!…… 子慕

http://localhost:8080/springmvc_quickstart/user/returnString
	springmvc快速上手!…… 子慕

知识小结

* 页面跳转采用返回字符串逻辑视图
  	1.forward转发
  		可以通过Model向request域中设置数据
  	2.redirect重定向
  		直接写资源路径即可，虚拟目录springMVC框架自动完成拼接

* 数据存储到request域中
  	Model model
  	model.addAttribute("username", "子慕");

静态资源访问的开启

　当有静态资源需要加载时，比如jquery文件，通过谷歌开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是 /（缺省）,代表对所有的静态资源都进行处理操作，这样就不会执行Tomcat内置的DefaultServlet处理，我们可以通过以下两种方式指定放行静态资源：

方式一(放行局部静态资源)
spring-mvc.xml

<!--在springmvc配置文件中指定放行资源  mapping:放行的映射路径  location:静态资源所在的目录（webapp下面的目录）-->
    <mvc:resources mapping="/js/**" location="/js/"/>
    <mvc:resources mapping="/css/**" location="/css/"/>
    <mvc:resources mapping="/img/**" location="/img/"/>

方式二(放行全部静态资源)
spring-mvc.xml

<!--在springmvc配置文件中开启DefaultServlet处理静态资源-->
    <mvc:default-servlet-handler/>

ajax异步交互

　Springmvc默认用MappingJackson2HttpMessageConverter对json数据进行转换，需要加入jackson的包；同时使用<mvc:annotation-driven />

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

@RequestBody

　该注解用于Controller的方法的形参声明，当使用ajax提交并指定contentType为json形式时，通过HttpMessageConverter接口转换为对应的POJO对象。

JSP

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/29
  Time: 14:42
  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>
<script src="${pageContext.request.contextPath}/js/jquery-3.5.1.js"></script>
    <%-- ajax异步交互 --%>
    <button id="btn1">ajax异步提交</button>
    <script>
        $("#btn1").click(function (){
            let url = '${pageContext.request.contextPath}/user/ajaxRequest';
            let data = '[{"id":1,"username":"高中美"},{"id":2,"username":"妞妞"}]';

            $.ajax({
                type: 'POST',
                url: url,
                data: data,
                contentType: 'application/json;charset=utf-8',
                success: function (resp) {
                    alert(resp);
                }
            })
        })

    </script>


</body>
</html>

UserController

/*
        ajax异步交互
        [{"id":1,"username":"高中美"},{"id":2,"username":"妞妞"}]
     */
    @RequestMapping("/ajaxRequest")
    public void ajaxRequest(@RequestBody List<User> list) {
        System.out.println(list);
    }

测试 http://localhost:8080/springmvc_quickstart/ajax.jsp
[User{id=1, username='高中美'}, User{id=2, username='妞妞'}]

@ResponseBody

　该注解用于将Controller的方法返回的对象，通过HttpMessageConverter接口转换为指定格式的数据如：json,xml等，通过Response响应给客户端。

JSP

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/29
  Time: 14:42
  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>
<script src="${pageContext.request.contextPath}/js/jquery-3.5.1.js"></script>
    <%-- ajax异步交互 --%>
    <button id="btn1">ajax异步提交</button>
    <script>
        $("#btn1").click(function (){
            let url = '${pageContext.request.contextPath}/user/ajaxRequest';
            let data = '[{"id":1,"username":"高中美"},{"id":2,"username":"妞妞"}]';

            $.ajax({
                type: 'POST',
                url: url,
                data: data,
                contentType: 'application/json;charset=utf-8',
                success: function (resp) {
                    alert(JSON.stringify(resp));
                }
            })
        })
    </script>


</body>
</html>

UserController

/*
        ajax异步交互
        [{"id":1,"username":"高中美"},{"id":2,"username":"妞妞"}]
     */
    @RequestMapping("/ajaxRequest")
    @ResponseBody //转换为json串返回
    public  List<User> ajaxRequest(@RequestBody List<User> list) {
        System.out.println(list);
        return list;
    }

RESTful

　Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。
　Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下：

GET：读取（Read）
POST：新建（Create）
PUT：更新（Update）
DELETE：删除（Delete）

restful

@PathVariable

　用来接收RESTful风格请求地址中占位符的值

@RestController

　RESTful风格多用于前后端分离项目开发，前端通过ajax与服务器进行异步交互，我们处理器通常返回的是json数据所以使用@RestController来替代@Controller和@ResponseBody两个注解。

restful示例

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

//@Controller
@RestController //组合主键: @Controller + @ResponseBody
@RequestMapping("/restful")
public class RestFulController {
    /*
        根据id进行查询
     */
    //@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
    @GetMapping(value = "/user/{id}")
    //@ResponseBody
    public String findById(@PathVariable Integer id) {
        //调用service层方法完成对id为2的这条记录的查询
        //http://localhost:8080/springmvc_quickstart/restful/user/2
        return "findById: " + id;
    }

    /*
        新增方法
     */
    @PostMapping(value = "/user")
    // @ResponseBody
    public String post() {
        return "post";
    }

    /*
        更新方法
     */
    @PutMapping(value = "/user")
    // @ResponseBody
    public String put() {
        return "put";
    }

    /*
        删除
     */
    @DeleteMapping(value = "/user/{id}")
    // @ResponseBody
    public String delete(@PathVariable Integer id) {
        return "delete:"+ id;
    }
}

文件上传

文件上传三要素

表单项 type="file"
表单的提交方式 method="POST"
表单的enctype属性是多部分表单形式 enctype=“multipart/form-data"

文件上传原理

当form表单修改为多部分表单时，request.getParameter()将失效。
当form表单的enctype取值为 application/x-www-form-urlencoded 时，

form表单的正文内容格式是： name=value&name=value
当form表单的enctype取值为 mutilpart/form-data 时，请求正文内容就变成多部分形式：

单文件上传

步骤分析

1. 导入fileupload和io坐标
2. 配置文件上传解析器
3. 编写文件上传代码

导入fileupload和io坐标

<dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

配置文件上传解析器

spring-mvc.xml

<!--文件上传解析器-->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设定文件上传的最大值为5MB，5*1024*1024 -->
        <property name="maxUploadSize" value="5242880"></property>
        <!-- 设定文件上传时写入内存的最大值，如果小于这个参数不会生成临时文件，默认为10240 -->
        <property name="maxInMemorySize" value="40960"></property>
    </bean>

编写文件上传代码

JSP页面
src/main/webapp/fileupload.jsp

<%--
  Created by IntelliJ IDEA.
  User: chao1
  Date: 2022/12/29
  Time: 17:51
  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>
    <%-- 编写一个满足文件上传三要素的表单
        1.表单的提交方式必须是post
        2.表单的enctype属性必须修改成multipart/form-data
        3.表单中必须要有文件上传项
    --%>
    <form action="${pageContext.request.contextPath}/fileUpload" method="post"
          enctype="multipart/form-data">
      名称：<input type="text" name="username"> <br>
      文件：<input type="file" name="filePic"> <br>
      <input type="submit" value="单文件上传">
    </form>
</body>
</html>

FileUploadController.java

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@Controller
public class FileUploadController {
    /*
        单文件上传
     */
    @RequestMapping("/fileUpload")
    public String fileUpload(String username, MultipartFile filePic) throws IOException {
        //打印名称
        System.out.println(username);
        // 获取原始的文件上传名   a.txt
        String originalFilename = filePic.getOriginalFilename();
        //保存文件
        filePic.transferTo(new File("D:/Project/Java/upload/" + originalFilename));
        return "success";
    }
}

测试页面
http://localhost:8080/springmvc_quickstart/fileupload.jsp

多文件上传

JSP页面

<%-- 编写一个满足文件上传三要素的表单
        1.表单的提交方式必须是post
        2.表单的enctype属性必须修改成multipart/form-data
        3.表单中必须要有文件上传项
    --%>
    <form action="${pageContext.request.contextPath}/filesUpload" method="post"
          enctype="multipart/form-data">
        名称：<input type="text" name="username"> <br>
        文件：<input type="file" name="filePic"> <br>
        文件：<input type="file" name="filePic"> <br>
        <input type="submit" value="多文件上传">
    </form>

FileUploadController.java

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@Controller
public class FileUploadController {
    /*
        多文件上传
     */
    @RequestMapping("/filesUpload")
    public String filesUpload(String username, MultipartFile[] filePic) throws IOException {
        //打印名称
        System.out.println(username);
        for (MultipartFile multipartFile : filePic) {
            // 获取原始的文件上传名
            String originalFilename = multipartFile.getOriginalFilename();
            //保存文件
            multipartFile.transferTo(new File("D:/Project/Java/upload/" + originalFilename));
        }
        return "success";
    }
}

测试页面
http://localhost:8080/springmvc_quickstart/fileupload.jsp

异常处理

异常处理的思路

　在Java中，对于异常的处理一般有两种方式：

一种是当前方法捕获处理（try-catch），这种处理方式会造成业务代码和异常处理代码的耦合。
另一种是自己不处理，而是抛给调用者处理（throws），调用者再抛给它的调用者，也就是一直向上抛。

　在这种方法的基础上，衍生出了SpringMVC的异常处理机制。
　系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

自定义异常处理器

步骤分析

1. 创建异常处理器类实现HandlerExceptionResolver
2. 配置异常处理器
3. 编写异常页面
4. 测试异常跳转

创建异常处理器类实现HandlerExceptionResolver、JSP页面、Controller

GlobalExceptionResolver.java

public class GlobalExceptionResolver implements HandlerExceptionResolver {
    /*
        Exception e : 实际抛出的异常对象

     */
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler, Exception e) {
        //具体的异常处理，产生异常后，跳转到一个最终的异常页面
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("error", e.getMessage());
        modelAndView.setViewName("error"); //src/main/webapp/WEB-INF/pages/error.jsp
        return modelAndView;
    }
}

**ExceptionController **

package com.soulboy.controller;

import org.springframework.web.bind.annotation.RequestMapping;

public class ExceptionController {
    @RequestMapping("/testException")
    public String testException() {
        int i = 1 / 0;
        return "success";
    }
}

配置异常处理器
spring-mvc.xml

<!--配置自定义的异常处理器-->
    <bean id="globalExceptionResolver" class="com.soulboy.exception.GlobalExceptionResolver"></bean>

编写异常页面
error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    这是一个最终异常的显示页面!!!
</body>
</html>

测试异常跳转
http://localhost:8080/springmvc_quickstart/testException

web的处理异常机制

测试
　测试URL并不存在
　http://localhost:8080/springmvc_quickstart/testException111

src/main/webapp/WEB-INF/web.xml

<!-- 处理404异常 -->
    <error-page>
        <error-code>404</error-code>
        <location>/404.jsp</location>
    </error-page>

    <!-- 处理500异常 -->
    <error-page>
        <error-code>500</error-code>
        <location>/500.jsp</location>
    </error-page>

拦截器

拦截器（interceptor）的作用

　Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器(Controller中的目标方法)进行预处理和后处理。
　将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（InterceptorChain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

拦截器和过滤器区别

　关于interceptor和filter的区别，如图所示：

快速入门

步骤分析

1. 创建拦截器类实现HandlerInterceptor接口
2. 配置拦截器
3. 测试拦截器的拦截效果

创建拦截器类实现HandlerInterceptor接口

MyInterceptor1

package com.soulboy.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 MyInterceptor1 implements HandlerInterceptor {
    /*
        preHandle: 在目标方法执行之前进行拦截
            return false代表不放行，后续的所有方法都不会执行
            return true代表放行,接着执行后续的所有方法
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }

    /*
        postHandle: 在目标方法执行之后，视图对象返回之前所执行的方法
            return false代表不放行，后续的所有方法都不会执行
            return true代表放行,接着执行后续的所有方法
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    /*
        afterCompletion: 在流程都执行完成后，执行的方法
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

配置拦截器

spring-mvc.xml

<!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.soulboy.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>

测试拦截器的拦截效果

TargetController

package com.soulboy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TargetController {
    @RequestMapping("/target")
    public String targetMethod() {
        System.out.println("目标方法执行了...");
        return "success";
    }
}

编写jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>springmvc快速上手!…… ${username}</h3>
    <% System.out.println("视图执行了....");%>
</body>
</html>

测试
http://localhost:8080/springmvc_quickstart/target

preHandle...
目标方法执行了...
postHandle...
视图执行了....
afterCompletion...

拦截器链

　开发中拦截器可以单独使用，也可以同时使用多个拦截器形成一条拦截器链。开发步骤和单个拦截器是一样的，只不过注册的时候注册多个，注意这里注册的顺序就代表拦截器执行的顺序。
　同上，再编写一个MyHandlerInterceptor2操作，测试执行顺序：
　需要注意拦截器链的执行顺序

方法名	说明	顺序
preHandle()	方法将在请求处理之前进行调用，该方法的返值是布尔值Boolean类型的当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行;当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法	串行
postHandle()	该方法是在当前请求进行处理之后被调用，前提是preHandle 方法的返回值为true 时才能被调用，且它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作	逆序
afterCompletion()	该方法将在整个请求结束之后，也就是在DispatcherServlet 染了对应的视图之后执行，前提是preHandle 方法的返回值为true 时才能被调用	逆序

MyInterceptor2

package com.soulboy.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 MyInterceptor2 implements HandlerInterceptor {
    /*
        preHandle: 在目标方法执行之前进行拦截
            return false代表不放行，后续的所有方法都不会执行
            return true代表放行,接着执行后续的所有方法
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle2...");
        return true;
    }

    /*
        postHandle: 在目标方法执行之后，视图对象返回之前所执行的方法
            return false代表不放行，后续的所有方法都不会执行
            return true代表放行,接着执行后续的所有方法
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle2...");
    }

    /*
        afterCompletion: 在流程都执行完成后，执行的方法
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion2...");
    }
}

spring-mvc.xml

<!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.soulboy.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.soulboy.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

测试
　http://localhost:8080/springmvc_quickstart/target

preHandle1...
preHandle2...
目标方法执行了...
postHandle2...
postHandle1...
视图执行了....
afterCompletion2...
afterCompletion1...

作者：Soulboy

SpringMVC简介

MVC模式

SpringMVC概述

快速上手

web工程执行流程

SpringMVC组件概述

SpringMVC的执行流程

SpringMVC组件解析

SpringMVC注解解析

SpringMVC的请求

请求参数类型

获取基本类型参数

获取对象类型参数

中文乱码过滤器

获取数组类型参数

获取数组类型参数

自定义类型转换器

相关注解

获取Servlet相关API

SpringMVC的响应

SpringMVC响应方式

转发和重定向

静态资源访问的开启

ajax异步交互

@RequestBody

@ResponseBody

RESTful

文件上传

文件上传三要素

文件上传原理

单文件上传

多文件上传

异常处理

异常处理的思路

自定义异常处理器

web的处理异常机制

拦截器

拦截器（interceptor）的作用

拦截器和过滤器区别

快速入门

拦截器链