SpringMVC学习笔记

最新推荐文章于 2024-01-14 10:07:19 发布

L_chengxin

最新推荐文章于 2024-01-14 10:07:19 发布

阅读量318

点赞数

CC 4.0 BY-SA版权

文章标签： java spring

本文链接：https://blog.youkuaiyun.com/L_chengxin/article/details/118369075

学习链接：https://www.bilibili.com/video/BV1WZ4y1P7Bp?p=42

1. Spring与Web环境集成

首先搭建一个Web项目
工程目录结构如下：
在这里插入图片描述
pom.xml文件：

<?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.abner</groupId>
    <artifactId>spring_mvc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.2.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>


</project>

dao层：

UserDao接口

package com.abner.dao;

public interface UserDao {

    public void save();

}

UserDaoImpl实现类

package com.abner.dao.impl;

import com.abner.dao.UserDao;

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDao save running..........");
    }
}

service层

UserService接口

package com.abner.service;

public interface UserService {

    public void save();

}

UserServiceImpl实现类

package com.abner.service.impl;

import com.abner.dao.UserDao;
import com.abner.service.UserService;

public class UserServiceImpl implements UserService {

    UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
        System.out.println("UserService save running........");
    }
}

applicationContext.xml文件

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

    <!--加载外部properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="dataSource1" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--配置Dao-->
    <bean id="userDao" class="com.abner.dao.impl.UserDaoImpl"></bean>

    <!--配置Service-->
    <bean id="userService" class="com.abner.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

</beans>

jdbc.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/yuanshen
jdbc.username=root
jdbc.password=root

web层

UserServlet类

package com.abner.web;

import com.abner.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = applicationContext.getBean(UserService.class);
        userService.save();
    }
}

web.xml文件：https://blog.youkuaiyun.com/Vermont_/article/details/109055686
web.xml的学名叫做部署描述文件（DD），它不是Spring所特有的，而是在Servlet规范中定义的，是web应用的配置文件。
在tomcat容器启动后，会寻找项目中的web.xml文件，加载其中的信息，并创建一个ServletContext上下文对象，以后再web应用中可以获得其中的值。

<?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>UserServlet</servlet-name>
        <servlet-class>com.abner.web.UserServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>

</web-app>

web.xml文件的作用是当我们把项目部署到tomcat上，我们可以通过localhost:8080/userServlet映射到名称为UserServlet所对应的的类，执行其doGet方法。

部署：
1、在idea右上角
在这里插入图片描述
2、点击+号

3、选择Tomcat Server—》Local

4、点击Deployment—》点击+号-----》点击Artifact…

5、选择xxx:war:exploded

6、点击ok部署完毕

7、点击运行

8、网页上输入http://localhost:8080/userServlet，在控制台可以看见doGet方法运行成功
在这里插入图片描述

1.1 ApplicationContext应用上下文获取方式

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

这句代码的作用是，加载xml配置文件来创建Spring容器
应用上下文对象是通过new ClassPathXmlApplicationContext(Spring配置文件) 方式获取的，但每次从容器中获得Bean时都要编写new ClassPathXmlApplicationContext(Spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

在Web项目中，可以使用ServletContextListener监听Web应用启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，再将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了

创建监听器加载ApplicationContext
在这里插入图片描述
ContextLoaderListener类：

package com.abner.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {//上下文初始化方法
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //将Spring的应用上下文对象存储到ServletContext域中
        ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute("app",applicationContext);
        System.out.println("Spring容器创建完毕......");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {//上下文销毁方法

    }
}

在web.xml文件中从配置这个监听器

<!--配置监听器-->
<listener>
    <listener-class>com.abner.listener.ContextLoaderListener</listener-class>
</listener>

UserServlet类就可以从servletContext域中获得ApplicationContext

package com.abner.web;

import com.abner.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = req.getServletContext();
        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

运行结果
在这里插入图片描述
优化：
web.xml配置全局初始化参数

    <!--web工程的全局初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>applicationContext.xml</param-value>
    </context-param>

ContextLoaderListener中通过servletContext.getInitParameter(“contextConfigLocation”);获取全局初始化参数值,也就是applicationContext.xml文件名，这样我们要改变applicationContext.xml的名字，只需要去修改web.xml，而不需要每个类去修改。

package com.abner.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {//上下文初始化方法
        
        ServletContext servletContext = servletContextEvent.getServletContext();
        
        //读取web.xml中的全局参数
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(contextConfigLocation);
        //将Spring的应用上下文对象存储到ServletContext域中
        servletContext.setAttribute("app",applicationContext);
        System.out.println("Spring容器创建完毕......");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {//上下文销毁方法

    }
}

创建WebApplicationContextUtils类获取应用上下文ApplicationContex

package com.abner.listener;

import org.springframework.context.ApplicationContext;

import javax.servlet.ServletContext;

public class WebApplicationContextUtils {

    public static ApplicationContext getApplicationContext(ServletContext servletContext){

        return (ApplicationContext) servletContext.getAttribute("app");
    }

}

UserServlet类就可以通过一下这种方法获取ApplicationContext，下次修改ServletContext域中Spring的应用上下文对象对应的key时，只需要修改监听器类ContextLoaderListener和WebApplicationContextUtils类，而不需要每个类都修改。

package com.abner.web;

import com.abner.listener.WebApplicationContextUtils;
import com.abner.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        ServletContext servletContext = req.getServletContext();
        ApplicationContext app = WebApplicationContextUtils.getApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

1.2 Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

所以我们需要做的事只有两件事：
1）在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）

<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-web</artifactId>
     <version>5.0.5.RELEASE</version>
</dependency>

web.xml配置监听器

<!--配置监听器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

    <!--web工程的全局初始化参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

2）使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

package com.abner.web;

import com.abner.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = req.getServletContext();

        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);

        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

在这里插入图片描述

1.3 知识要点

Spring集成web环境步骤
1）配置ContextLoaderListener监听器
2）使用WebApplicationContextUtils获得应用上下文

2. SpringMVC的简介

2.1 SpringMVC概述

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

M：Model（模型），主要用于数据封装和业务逻辑处理
V：View（视图），主要用于数据的展示
C：Controller（控制器），主要用于分发、指派等工作

SpringMVC已经成为目前最主流的MVC框架之一，它通过一套注解，让一个简单的Java类成为处理请求的控制器，而无需实现任何接口。同时，它还支持RESTful编程风格。

2.2 SpringMVC快速入门

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

SpringMVC开发步骤

1、导入SpringMVC相关坐标

2、配置SpringMVC核心控制器DispathcerServlet

3、编写POJO（Controller类）和视图页面

4、使用注解配置Controller类中业务方法的映射地址

5、配置SpringMVC核心文件spring-mvc.xml文件（配置组件扫描）

6、客户端发起请求执行访问测试

在这里插入图片描述
1、导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

2、配置Web.xml

 <!--配置SpringMVC的前端控制器-->
 <servlet>
     <servlet-name>DispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <load-on-startup>1</load-on-startup>
 </servlet>
 <!--配置映射地址-->
 <servlet-mapping>
     <servlet-name>DispatcherServlet</servlet-name>
     <url-pattern>/</url-pattern>
 </servlet-mapping>

3、创建Controller类和视图
UserController.class:

package com.abner.controller;

public class UserController {

    public String save(){
        System.out.println("Controller save running.....");

        return "success.jsp";
    }

}

success.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>Successs</h1>
</body>
</html>

4、用@Controller注解将UserController放到Spring容器中，并且将save方法映射到访问localhost:8080/quick的页面（请求的地址和方法做一个映射关系）

package com.abner.controller;

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

@Controller
public class UserController {

    @RequestMapping("/quick")
    public String save(){
        System.out.println("Controller save running.....");

        return "success.jsp";
    }

}

@RequestMapping("/quick")的注解的作用和在web.xml配置文件中一下方法配置映射作用一样，只不过用注解我们就可以不用继承HttpServlet让他自动执行doGet，而是会直接执行@RequestMapping下的方法，当他返回success.jsp时，就会跳到success.jsp页面

<servlet>
    <servlet-name>UserController</servlet-name>
    <servlet-class>com.abner.controller.UserController</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>UserController</servlet-name>
    <url-pattern>/quick</url-pattern>
</servlet-mapping>

5、创建spring-mvc.xml配置文件配置包扫描

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

    <!--Controller的组件扫描-->
    <context:component-scan base-package="com.abner.controller"></context:component-scan>

</beans>

修改web.xml文件告诉它spring-mvc.xml配置文件在哪（初始化）

<!--配置SpringMVC的前端控制器-->
 <servlet>
     <servlet-name>DispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:spring-mvc.xml</param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
 </servlet>

当启动一个WEB项目时，容器包括（JBoss、Tomcat等）首先会读取项目web.xml配置文件里的配置，当这一步骤没有出错并且完成之后，项目才能正常地被启动起来。所以
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
也会被加载，也就加载了spring-mvc.xml文件，所以用注解注入的Bean才能被注入到容器中。

3. SpringMVC的组件解析

3.1 SpringMVC的执行流程

在这里插入图片描述
1）用户发送请求至前端控制器DispatcherServlet。
2）DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3）处理器映射器找到具体的处理器（可以根据xml位置、注解进行查找），生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet。
4）DispatcherServlet调用HandlerAdapter处理器适配器。
5）HandlerAdapter经过适配调用具体的处理器（Controller，也叫后端控制器）。
6）Controller执行完成返回ModelAndView。
7）HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8）DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9）ViewReslover解析后返回具体View。
10）DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。

3.2 SpringMVC注解解析

@RequstMapping

作用：用于建立请求URL和处理请求方法之间的对应关系（对你请求的虚拟地址进行映射到某个方法上）

位置：

类上，请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求URL的第二级访问目录，与类上的使用@RequestMappping标注的一级目录一起组成访问虚拟路径
即当我只有方法上有@RequestMapping("/aaa")那么请求地址就是http://localhost:8080/aaa，如果类上也添加了@RequestMapping("/xxx")，那么请求地址就是：http://localhost:8080/xxx/aaa，且方法的返回值上原来是“xxx.jsp”，要改为“/xxx.jsp”
属性：
- value：用于指定请求的URL。它和path属性的作用是一样的
- method：用于指定请求的方式
- params：用于指定限定请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置一模一样
例如：
- params = {“accountName”}，表示请求参数中必须有accountName
- params = {“moeny!100”}，表示请求参数中money不能是100

示例：

    @RequestMapping(value = "/quick", method = RequestMethod.GET)
    public String save(){
        System.out.println("Controller save running.....");

        return "/success.jsp";
    }

那么在jsp文件中表单提交的方式为

    <form action="/user/quick" method="get">
        <input type="submit" value="success">
    </form>

反之一样
如果有params

    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})
    public String save(){
        System.out.println("Controller save running.....");

        return "/success.jsp";
    }

那么访问时
在这里插入图片描述
组件扫描：
SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用<context:component-scan base-package="com.abner.controller"></context:component-scan>进行主键扫描。
主键扫描的写法：

<!--Controller的组件扫描-->
<!--写法一：代表com.abner.controller这包下及其所有子包都被扫描-->
<context:component-scan base-package="com.abner.controller"></context:component-scan>

<!--写法二-->
<context:component-scan base-package="com.abner">
    <!--这样代表只扫描com.abner下的Controller注解-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:include-filter>
    <!--这样代表只扫描com.abner下的不包括Controller的注解-->
    <!--<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>-->
</context:component-scan>

在我们这个代码中

    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})
    public String save(){
        System.out.println("Controller save running.....");

        return "/success.jsp";
    }

return这里是省略的一个前缀，默认是forward，即return “forward:/success.jps”，默认是转发行为，即我们在访问的时候能看到转发的视图而浏览器的地址没有发生改变，这就是转发，即请求时我们表单的请求动作是/user/quick 在这里插入图片描述
浏览器里也是http://localhost:8080/user/quick?username=xxx

当我们前缀为redirect，我们访问时地址会发生改变，这是重定向
在这里插入图片描述

3.4 SpringMVC的XML配置解析（spring-mvc.xml）

在上述过程中我们只在spring-mvc.xml文件中配置了组件扫描，除了配置组件扫描外还可以指定一些另外的组件，例如：视图解析器
1、视图解析器
SpringMVC有默认组件配置，默认主键配置都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web.servlet/DispatcherServlet.properties，该文件中除了配置了默认的视图解析器，如下：

org.springframework.web.servlet.ViewResolver = org.springframework.web.servlet.view.InternalResourceViewResolver

翻看解析器源码，可以看到该解析器的默认配置，如下：

public static final String REDIRECT_URL_PREFIX = "redirect:"; //重定向前缀
public static final String FORWARD_URL_PREFIX = "forward:"; //转发前缀（默认值）

private String prefix = ""; --视图名称前缀
private String suffix = ""; --视图名称后缀

当我们在spring-mvc.xml配置了内部资源解析器（因为该解析器有set方法，所以我们可以把它注入到容器中）

<!--配置内部资源视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--先拿到前缀，在拿到你返回的名称，在拿到后缀，再拼接起来-->
    <property name="prefix" value="/jsp/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

那么我们在方法中的返回值，就可以写成success
前缀为/jsp是因为我把success.jsp放到了webapp下的jsp文件夹
在这里插入图片描述

@RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})
public String save(){
    System.out.println("Controller save running.....");

    return "success";
}

3.5 知识要点

SpringMVC的相关组件

前端控制器：DispatcherServlet
处理器映射器：HandlerMapping
处理器适配器：HandlerAdapter
处理器：Handler
视图解析器：ViewReslover
视图：View

SpringMVC的注解和配置

请求映射注解@RequestMapping
视图解析器配置
- REDIRECT_URL_PREFIX = “redirect:”;
- FORWARD_URL_PREFIX = “forward:”;
- prefix = “”;
- suffix = “”;

4. SpringMVC的数据响应

4.1 SpringMVC的数据响应方式

1）页面跳转

直接返回字符串
通过ModelAndView对象返回

2）回写数据

直接返回字符串
返回对象或集合

4.2 页面跳转

1. 返回字符串形式

直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转
在这里插入图片描述
返回带有前缀的字符串：
转发：forward:/WEB-INF/view/index.jsp
重定向:redirect:/index.jsp

那为什么重定向不写/WEB-INF/view/呢？那是因为重定向代表客户端再次访问，再次请求，而WEB-INF属于一个受保护的一个文件夹，外界不能直接访问，所以你想要重定向访问到，你的资源必须处在一个有权限被访问的位置。

2. 返回ModelAndView对象

在UserController中，我们写一个save2方法，用来返回ModelAndView对象

@RequestMapping(value = "/quick2")
public ModelAndView save2(){
    System.out.println("Controller save running.....");
    /*
        Model:模型，作用是封装数据
        View: 视图，作用是展示数据
     */
    ModelAndView modelAndView = new ModelAndView();

    //设置模型数据
    modelAndView.addObject("username","itcast");

    //设置视图名
    modelAndView.setViewName("success");


    return modelAndView;
}

modelAndView.setViewName(“success”)：该方法的参数就是你要返回的那个页面的名字（如果配置的内部资源解析器，那么就不用写前缀和后缀，否则要写）

modelAndView.addObject(“username”,“itcast”)：一个对象添加到模型addObject(String modelName,Object modelObject)
modelName -对象的名称（从不为null）
modelObject -添加到模型对象（可以为null）
那么我们就可以在jsp页面通过EL表达式${modelName}拿到modelObject
https://blog.youkuaiyun.com/qq_16071145/article/details/51341052

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>Successs! ${username}</h1>
</body>
</html>

在这里插入图片描述
ModelAndView也可以不在方法里面创建，可以作为参数放到方法里

@RequestMapping(value = "/quick3")
public ModelAndView save3( ModelAndView modelAndView){
    System.out.println("Controller save running.....");
    /*
        Model:模型，作用是封装数据
        View: 视图，作用是展示数据
     */

    //设置模型数据
    modelAndView.addObject("username","itAbner");

    //设置视图名
    modelAndView.setViewName("success");


    return modelAndView;
}

在这里插入图片描述
那为什么不用new一个ModelAndView对象就可以设置呢？
那是因为SpringMVC它对它对应的方法的参数，可以帮你相应的注入，它在解析这个方法的时候发现参数中有ModelAndView需要SpringMVC框架提供，那么SpringMVC就会为你提供一个ModelAndView对象

除了使用ModelAndView外，我们还可以只使用Model

@RequestMapping(value = "/quick4")
public String save4(Model model){
    System.out.println("Controller save running.....");

    model.addAttribute("username","岭南师范学院");

    return "success";
}

在这里插入图片描述
用原始的方式往域中存数据，在web阶段往域中存数据需要request对象调用方法request.setAttribute把数据存到request域中

@RequestMapping(value = "/quick5")
public String save5(HttpServletRequest request){
    System.out.println("Controller save running.....");

    request.setAttribute("username","猫头鹰");

    return "success";
}

这方法是Spring框架帮你调用，你常用的一些对象，框架的编写者都帮你想到了，想用时，只需要往方法里加参数就行。
在这里插入图片描述

4.3 回写数据

1. 直接返回字符串

Web阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWrite.print(“hello world”)即可，那么在Controller中想直接回写字符串该怎么样呢？
1）通过SpringMVC框架注入的response对象，使用response.getWrite().print(“hello world”)回写数据，此时不需要视图跳转，业务方法返回值为void。

@RequestMapping(value = "/quick6")
public void save6(HttpServletResponse response) throws IOException {
    System.out.println("Controller save running.....");

    response.getWriter().print("hellw world");

}

在这里插入图片描述
2）如果需要将回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回。

@RequestMapping(value = "/quick7")
@ResponseBody//告知Spring框架不要进行页面跳转，而是直接回写数据
public String save7() {
    System.out.println("Controller save running.....");

    return "hello world";

}

在这里插入图片描述

使用json转换工具将对象转换成json格式字符串
导入依赖

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

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

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

创建一个User类测试

package com.abner.domain;

public class User {

    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

@RequestMapping(value = "/quick9")
@ResponseBody//告知Spring框架不要进行页面跳转，而是直接回写数据
public String save9() throws JsonProcessingException {
    System.out.println("Controller save running.....");

    User user = new User();
    user.setUsername("lisi");
    user.setAge(30);

    //使用json转换工具将对象转换成json格式字符串
    ObjectMapper objectMapper = new ObjectMapper();
    String s = objectMapper.writeValueAsString(user);

    return s;

}

在这里插入图片描述

2. 返回对象或集合

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并写回，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在Spring-mvc.xml中进行如下配置：

<!--配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"></bean>
        </list>
    </property>
</bean>

配置好后，我们在方法中直接返回对象集合

@RequestMapping(value = "/quick10")
@ResponseBody//告知Spring框架不要进行页面跳转，而是直接回写数据
public User save10() {//期望SpringMVC自动将User对象转换成json格式字符串
    System.out.println("Controller save running.....");

    User user = new User();
    user.setUsername("lisi2");
    user.setAge(32);

    return user;

}

在这里插入图片描述
在方法上添加@ResponseBody就可以返回json格式字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动替代上述配置。

<mvc:annotation-driver>

在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件，使用<mvc:annotation-driver>自动加载RequestMappingHandlerMapping（处理器映射器）和RequestMappingHandlerAdapter（处理器适配器），可在spring-mvc.xml配置文件中使用<mvc:annotation-driver>替代注解处理器和适配器的配置。
同时使用<mvc:annotation-driver>默认低层就会集成jackson进行对象或集合的json格式字符串的转换。

配置步骤：
在spring-mvc.xml头部添加以下两行
在这里插入图片描述

xmlns:mvc="http://www.springframework.org/schema/mvc"

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd

我们就可以直接注释掉原来配置的处理器映射器，添加<mvc:annotation-driven/>即可

<!--配置处理器映射器-->
<!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">-->
    <!--<property name="messageConverters">-->
        <!--<list>-->
            <!--<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"></bean>-->
        <!--</list>-->
    <!--</property>-->
<!--</bean>-->
<!--配置mvc注解驱动-->
<mvc:annotation-driven/>

4.4 知识要点

SpringMVC的数据响应方式
1）页面跳转

直接返回字符串
通过ModelAndView对象返回

2）回写数据

直接返回字符串
返回对象集合

5. SpringMVC获得请求数据

5.1 获得请求参数

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

基本类型参数
POJO类型参数（简单的Java Bean）
数组类型参数
集合类型参数

5.2. 获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。
http://localhost:8080/user/quick12?username=lisi&age=28
比如客户端提交一个参数是username，name在Controller的方法中提供一个形参也叫username即可

@RequestMapping(value = "/quick11")
    @ResponseBody
    public void save11(String username, int age) {

        System.out.println(username);
        System.out.println(age);

    }

<form action="/user/quick11" method="get">
        <input name="username" value="zhangsan">
        <input name="age" value="18">
        <input type="submit">
    </form>

可以看到控制台输出，说明已经接收到
在这里插入图片描述

5.3 获得POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配。
例如http://localhost:8080/user/quick12?username=lisi&age=28，那么Controller中的业务方法POJO参数如User类型的，只要User类型里有名为username和age的属性即可

package com.abner.domain;

public class User {

    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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


@RequestMapping(value = "/quick12")
@ResponseBody
public void save12(User user) {

    System.out.println(user);

}

<form action="/user/quick12" method="get">
    <input name="username" value="lisi">
    <input name="age" value="28">
    <input type="submit">
</form>

在这里插入图片描述

5.4 获得数组类型参数

Controller的业务方法中数组名称与请求参数的name一致，参数会自动映射匹配。
http://localhost:8080/user/quick13?strs=aaa&strs=bbb

@RequestMapping(value = "/quick13")
@ResponseBody
public void save13(String[] strs) {

    for (String str:strs){
        System.out.println(str);
    }

}

<form action="/user/quick13" method="get">
    <input name="strs" value="aaa">
    <input name="strs" value="bbb">
    <input type="submit">
</form>

在这里插入图片描述

5.5 获得集合类型的参数

获得集合参数时，要将集合参数包装到一个POJO中才可以
比如我们有一个VO类如下，有属性userList，是个泛型是User类型的List集类型

package com.abner.domain;

import java.util.List;

public class VO {

    private List<User> userList;

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

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

    @Override
    public String toString() {
        return "VO{" +
                "userList=" + userList +
                '}';
    }
}

我们另外建一个form.jsp文件用来提交请求

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/quick14" method="post">
        <%--表明是第几个User对象的username、age--%>
        <input type="text" name="userList[0].username"><br>
        <input type="text" name="userList[0].age"><br>
        <input type="text" name="userList[1].username"><br>
        <input type="text" name="userList[1].age"><br>
        <input type="text" name="userList[2].username"><br>
        <input type="text" name="userList[2].age"><br>
        <input type="submit" value="提交">
    </form>
</body>
</html>

因为VO是一个POJO类型，所以我们的请求参数名称是和它里面的属性名称一样，而VO类型里userList是个List的集合类型，<input type="text" name="userList[n].username">这里的请求参数意思是userList的第n个元素中的什么属性的值

@RequestMapping(value = "/quick14")
@ResponseBody
public void save14(VO vo) {

    System.out.println(vo);

}

在这里插入图片描述
当使用ajax提交时，可以指定contentType为json形式，那么在方法参数使用@RequestBody可以直接接收数据而无需使用POJO进行包装。
1）为了方便我们发送ajax请求，我们使用jQuery，在webapp下建一个目录js放jQuery文件jquery-3.6.0.js
在这里插入图片描述
下载地址：https://jquery.com/

2）编写测试方法

@RequestMapping(value = "/quick15")
    @ResponseBody
    public void save15(@RequestBody List<User> usersList) {

        System.out.println(usersList);

    }

3）在webapp目录下建一个页面示例（ajax.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.6.0.js"></script>
    <script>
        var userList = new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:28});

        $.ajax({
           type:"POST",
           url:"${pageContext.request.contextPath}/user/quick15",
            data:JSON.stringify(userList),
            contentType:"application/json;charset=utf-8"
        });
    </script>
</head>
<body>

</body>
</html>

4）在spring-mvc.xml文件中配置静态资源访问权限

<!--开放静态资源访问-->
<!--方式一：mapping是指映射地址，即在请求时的地址，location代表具体资源所在目录-->
<mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
<mvc:resources mapping="/img/**" location="/img/"></mvc:resources>
<!--方式二：在访问资源时spring-mvc会帮我们找对应的地址（RequestMapping），如果找不到，那就交由
原始的容器（tomcat）的内部机制帮我们找对应的资源-->
<mvc:default-servlet-handler/>

如果没有配，我们在请求的时候会找不到jQuery文件，这是因为在前端控制器DispatcherServlet配置中
在这里插入图片描述
<url-pattern>写的是’’/’’，这是代表缺省的Servlet，缺省的意思是客户端在发送请求到服务端时都会找对应的servlet，如果找不到，最终资源都归缺省的servlet处理，也就是DispatcherServlet处理，但DispatcherServlet内部要帮你进行一个虚拟路径的匹配，匹配我们Controller中的@RequestMapping，所以你发送一个请求时要找一个jQuery文件，DispatcherServlet也会把jQuery文件当成是一个RequestMapping进行匹配，但Controller中并没有jQuery的RequestMapping，，所以我们要开放资源的访问，不需要通过spring-mvc框架帮我们去找对应的资源，即不需要匹配对应的RequestMapping，只需要找到对应的资源进行返回。
在这里插入图片描述

5.6 请求数据乱码问题

当post请求时，数据会出现乱码（中文乱码），我么可以设置一个过滤器来进行编码的过滤。
在web.xml文件中配置过滤器

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

在这里插入图片描述

5.7 参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显式绑定
我们在网页中修改参数名
在这里插入图片描述

在后台就位null了

示例：
我们在页面中添加一个表单，请求参数名为name

<form action="/user/quick17" method="post">
    <input name="name" value="张三"><br>
    <input type="submit">
</form>

在Controller中添加方法，方法参数名为username

@RequestMapping(value = "/quick17")
@ResponseBody
public void save17(@RequestParam(value = "name") String username) {

    System.out.println(username);

}

@RequestParam(value = “name”)的作用是把请求的name参数映射到username中
现在我们测试
在这里插入图片描述

注解@RequestParam还有如下参数可以使用：

value：与请求参数名称匹配
required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
defaultValue：当没有指定请求参数时，则使用指定的默认赋值

例如在上面的例子中我们的请求参数要有name（value=“name”,这与jsp页面中form表单里的参数名是否一致无关，只要你用了这个注解，value=’’‘xxx’，那么你请求时就必须要有xxx），如果我们不写或者写成其他，就会报错
在这里插入图片描述
那如果我们把required设为false

那么即使我么没有对应的参数或者写成其他也不会报错（我的页面没有任何东西）

只不过服务器Controller方法中没有获取到值

那么defaultValue的作用就是当我们有指定参数时，就会映射到方法参数上，如果没有或者请求的参数名是其他，方法参数就映射为defaultValue的值
在这里插入图片描述

在这里插入图片描述

5.8 获取Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，知识提供了一组设计原则和约束条件。主要用于客户端和服务器交互类软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP协议里面四个表示操作方式的动词如下：

GET：用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETE：用于删除资源

例如：

/user/1 GET：得到id=1的user
/user/1 DELETE：删除id=1的user
/user/1 PUT：更新id=1的user
/user POST：新增user

上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们使用@PathVariable注解进行占位符的匹配获取工作

http://localhost:8080/user/quick18/zhansan

在这里插入图片描述
把请求地址中的zhansan用占位符{name}匹配，，匹配之后@PathVariable把value与占位符中name匹配，然后把值赋给方法参数中的username，占位符中的值必须和value的值一致

5.9 自定义类型转换器

SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int类型进行参数设置。
但是不是所有的数据类型都提供了类型转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。

自定义类型转换器的开发步骤：
1）定义转换器类实现Converter接口
2）在配置文件中声明转换器(spring-mvc.xml)
3）在<annotation-driver>中引用转换器

让我们看一下没有自定义类型转换器时封装日期类型时报错

@RequestMapping(value = "/quick19")
@ResponseBody
public void save19(Date date) {

    System.out.println(date);

}

在这里插入图片描述
下面开始自定义类型转换器
1、创建自定义日期类型转换器类

package com.abner.converter;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String dateStr) {
        //将日期字符串转换成日期对象 返回
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

Converter<S, T>，S为你要转日期的字符串，T为你要转成的格式

2、在spring-mvc.xml文件中声明转换器

<!--声明转换器-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.abner.converter.DateConverter"></bean>
        </list>
    </property>
</bean>

3、在mvc注解驱动中引用转换器

<!--配置mvc注解驱动-->
<mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>

测试
在这里插入图片描述

5.10 获得Servlet相关API

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

HTTPServletRequest
HTTPServletResponse
HttpSession

由于方法是SpringMVC框架调用的（使用@RequestMapping注解，所以在客户端发送请求的时候，会找到该映射，执行该注解下的方法），所以方法里的形参也是框架传递进来的，谁调用谁传递

@RequestMapping(value = "/quick20")
public void save20(HttpServletResponse response, HttpServletRequest request, HttpSession session) throws IOException {
    System.out.println("Controller save running.....");

    System.out.println(response);
    System.out.println(request);
    System.out.println(session);

}

在这里插入图片描述

5.11 获得请求头

1.@RequestHeader
使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)

@RequestHeader注解属性如下：

value：请求头名称
required：是否必须携带此头

 @RequestMapping(value = "/quick21")
@ResponseBody
public void save21(@RequestHeader(value = "User-Agent",required = false) String headerValue) throws IOException {
    System.out.println("Controller save running.....");

    System.out.println(headerValue);

}

@RequestHeader(value = “User-Agent”,required = false)的作用就是获得请求头中的User-Agent信息并赋给方法中的参数headerValue，required = false的作用就是请求时无论你是否携带该信息请求都可以访问该资源（方法）
在这里插入图片描述
请求头的信息有如下：

Accept
Accept-Language
Cache-Control
Connection
Cookie
Host
Referer
sec-ch-ua
sec-ch-ua-mobile
Sec-Fetch-Dest
Sec-Fetch-Mode
Sec-Fetch-Site
Sec-Fetch-User
Upgrade-Insecure-Requests
User-Agent

2.@CookieValue
使用@CookieValue可以获得指定Cookie的值
@CookieValue注解的属性如下：

value：指定cookie的名称
required：是否必须携带此cookie

我们在浏览器中F12，查看请求头信息中的Cookie信息
在这里插入图片描述

可以看到Cookie信息中有JSESSIONID信息（是个键值对）下面演示获取Cookie信息中的JSESSIONID

@RequestMapping(value = "/quick22")
@ResponseBody
public void save22(@CookieValue(value = "JSESSIONID", required = false) String jsessionid) throws IOException {
    System.out.println("Controller save running.....");

    System.out.println(jsessionid);

}

在这里插入图片描述

5.12 文件上传

1、文件上传客户端三要素

表单项type=“file”
表单提交方式是post
表单enctype属性是多部分表单形式，及enctype=“multipart/form-data”

例如：

<form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="username"><br>
    文件：<input type="file" name="upload"><br>
    <input type="submit" value="提交">
</form>

2、文件上传原理

当form表单修改为多部分表单时（enctype=“Mutilpart/form-data”），request.getParameter()将失效。
enctype=“application/x-www-form-urlencoded”（url编码方式）时，form表单的正文内容格式是：key=value&key=value&key=value
当form表单enctype取值为Mutilpart/form-data时，请求正文内容就变成多部分形式：

5.13 单文件上传步骤

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

1、导入fileupload和io坐标

<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.3</version>
</dependency>

2、配置文件上传解析器（spring-mvc.xml）

<!--配置文件上传解析器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--文件上传总大小-->
    <property name="maxUploadSize" value="5242800"/>
    <!--单个文件上传大小-->
    <property name="maxUploadSizePerFile" value="5242800"/>
    <!--上传文件的编码类型-->
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

id要指定为multipartResolver

3、编写文件上传代码

@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile upload) throws IOException {
	//获取文件名称
    String originalFilename = uploadFile.getOriginalFilename();
    //保存文件
    uploadFile.transferTo(new File("D:\\upload\\"+originalFilename));
}

在我们之前的学习中我们知道，只要方法的参数名称和请求的参数名称一致就能自动帮你匹配，文件上传也一样，只不过上传的文件会帮你封装为一个MultipartFile 对象。

启动测试：在这里插入图片描述
上传成功

5.14 多文件上传实现

多文件上传和单文件上传一样，只不过你表单中加多几个表单项，方法参数中对应加上相应的参数就行

<form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="username"><br>
    文件：<input type="file" name="uploadFile"><br>
    文件：<input type="file" name="uploadFile2"><br>
    <input type="submit" value="提交">
</form>

@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile uploadFile,MultipartFile uploadFile2) throws IOException {
    System.out.println("Controller save running.....");
    System.out.println(username);
    System.out.println(uploadFile.getOriginalFilename());
    //获得上传文件的名称
    String originalFilename = uploadFile.getOriginalFilename();
    //保存文件
    uploadFile.transferTo(new File("D:\\upload\\"+originalFilename));

    //获得上传文件的名称
    String originalFilename2 = uploadFile2.getOriginalFilename();
    //保存文件
    uploadFile2.transferTo(new File("D:\\upload\\"+originalFilename2));
}

启动测试
在这里插入图片描述
上传成功

多文件上传还有第二种方法，即表单中上传文件的表单项的name一样，那么在Controller方法中只要用MultipartFile 数组对象接收就行

<form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
   名称：<input type="text" name="username"><br>
   文件：<input type="file" name="uploadFiles"><br>
   文件：<input type="file" name="uploadFiles"><br>
   <input type="submit" value="提交">
</form>

@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile[] uploadFiles) throws IOException {
    System.out.println("Controller save running.....");
    System.out.println(username);
    for(MultipartFile uploadFile:uploadFiles){
        String originalFilename = uploadFile.getOriginalFilename();
        System.out.println(originalFilename);
        uploadFile.transferTo(new File("D:\\upload\\"+originalFilename));
    }
}