Spring-MVC

目录

快速入门

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

步骤

①导入SpringMVC相关坐标:要是SpringMVC起作用要使用DispathcerServlet,而DispathcerServlet是在SpringMVC相关坐标中。
②配置SpringMVC核心控制器DispathcerServlet:DispathcerServlet的内部配置了一些共有的行为,配置使用。
③创建Controller类和视图页面
④使用注解配置Controller类中业务方法的映射地址。
⑤配置SpringMVC核心文件spring-mvc.xml:扫描Controller中配置的组件。
⑥客户端发起请求测试

导入SpringMVC相关坐标

在配置文件中新增一下代maven依赖

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

导入了该依赖就有了前端控制器DispathcerServlet,有了之后就要在web.xml中配置springMVC的前端控制器

配置SpringMVC核心控制器DispathcerServlet

在web.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>
<!--    配置映射地址-->
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern><!--这个/表示缺省的servlet,表示每次访问该请求时,任何请求都要走这个servlet-->
<!--        <url-pattern>*.xxx</url-pattern>--><!--意味着资源的扩展名是xxx时走这个servlet-->
    </servlet-mapping>

创建Controller类和视图页面

目录结构:
在webapp文件夹下新建一个success.jsp:
Spring-MVC

<%--
  Created by IntelliJ IDEA.
  User: Lcy
  Date: 2021/10/20
  Time: 9:46
  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>
    <h1>Success</h1>
</body>
</html>

Spring-MVC
创建controller文件夹。

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

新建类UserController.java:

package com.stu.controller;

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

/**
 * @version:
 * @author: 零乘一
 * @description: 类的简介
 * @date: 2021/10/20 9:45
 **/

@Controller//将这个类配置到spring容器中
public class UserController {
    @RequestMapping("/quick")//当你访问quick时就映射到save方法,执行其中的逻辑然后返回到success.jsp视图中
    public String save(){
        System.out.println("Control save running...");
        return "success.jsp";//return的是要跳转的视图
    }
}

已经写好了配置,但是需要让spring直到有这些东西的存在,因此需要进行组件的扫描操作。

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

Spring-MVC
在resources文件夹下新建一个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.stu.controller"/>
</beans>

为什么不能放在applicationContext.xml配置文件中,因为规范习惯将dao层与MVC层的组件分开扫描,放在一起扫描是没有问题的。
配置好了spring-mvc.xml文件,但此时它还没有被加载。
要在web.xml文件中进行配置,使该文件在servlet时被加载。
Spring-MVC
在param-name标签中的参数就是contextConfigLocation
在para-value标签中的参数为classpath:被加载的配置文件路径

运行

运行之后会自动打开该页面
Spring-MVC
在地址栏中输入quick后会打开以下页面:
Spring-MVC
在控制台中会打印以下文字:
Spring-MVC

运行解析

打开网页时找到Tomcat服务器
Spring-MVC
Tomcat服务器找到你内部工程的配置,由于在url-pattern中配置”/“缺省表示全局的,每次都会找到这个地方。
这个服务由框架提供,它会根据你的请求去解析找到对应的资源。因为我们在Controller配置了请求的映射,所以它就会找到方法save(),并且跳转到success.jsp页面。
web应用中包含如下:
Service表示前端控制器
Spring-MVC
由于配置的路径是缺省的,因此每一次请求都会经过前端控制器
Spring-MVC
前端根据你的请求解析你所需要的资源
Spring-MVC
controller会将视图返回回去
Spring-MVC
Tomcat会组装一个http响应。
Spring-MVC

组件解析

Spring-MVC
Spring-MVC

SpringMVC注解解析

@RequestMapping("")

作用:用于建立请求URL和处理请求方法之间的对应关系
可以写在类上或方法上
写在类上再在方法上写一个地址,访问时就要将写在类上的地址加上写在方法上的地址。
示例:
在类userController.java进行以下修改:

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick")
    public String save(){
        System.out.println("Control save running...");
        return "/success.jsp";
    }
}

Spring-MVC
在重新运行Tomcat服务器后,在浏览器中输入:http://localhost:8080/user/quick
运行的结果与之前一般,在此就不截图了。

参数

value:用于指定请求的URL(当参数中只有一个时可以省略不写,如果有多个参数就必须要写上)
method:指定请求方式。
params:限制请求参数。支持简单的表达式、设定要访问该页面时必须输入的参数。
参数填写格式

@RequestMapping(value = "/xxx", method = RequestMethod.方法, params = {"xxx"})

示例:
将UserController.java中的代码修改如下:

@RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"a","aa=123"})

Spring-MVC
在网页中的访问地址为:http://localhost:8080/user/quick?a=123&aa=123
结果与之前的一致。

注解扫描

这个了解就行
Spring-MVC

SpringMVC.xml配置文件

配置视图资源解析器

作用:配置好前缀和后缀,在转发时我们就只要写文件名,框架就会自动帮助我们加上前缀和后缀,连接成完整的路径。
以下是找到spring框架中定义的各个MVC的组件。
Spring-MVC
Spring-MVC

在spring-mvc.xml中新增如下配置:

    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        拼接时首先拿上前缀,加上你在方法中的return中的值,然后加上后缀
    {/jsp/}{success}{.jsp}:/jsp/success.jsp
-->
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

Spring-MVC
这两个属性是InternalResourceViewResolver继承的父类中的有的两个set方法。
Spring-MVC
Spring-MVC
示例:
在wepapp文件夹下新建一个jsp文件夹,将success.jsp文件放入jsp文件夹中
Spring-MVC
UserController.java中代码改动如下:

@RequestMapping(value = "/quick")

Spring-MVC
运行后在网页地址栏中输入:http://localhost:8080/user/quick
运行结果一样,这里就不截图了。

SpringMVC的相关组件

Spring-MVC
Spring-MVC
Spring-MVC

SpringMVC的数据响应

页面跳转

1、返回字符串形式:此种方式会将返回的字符串域视图解析器的前后缀拼接后跳转。
Spring-MVC

回写数据

ModelAndView

在UserController.java文件新增以下代码段:

    @RequestMapping(value = "/quick2")
    public ModelAndView save2(){
        /*
            model模型 作用封装数据
            View视图 作用展示数据
        */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","itcast");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

Spring-MVC
在success.jsp代码修改如下

<h1>Success ${username}</h1>

Spring-MVC
运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick2
会在页面中显示如下:
Spring-MVC
在UserController.java文件新增以下代码段:

    @RequestMapping(value = "/quick3")
    //springMVC会注入方法中的参数,然后就能够直接使用
    public ModelAndView save3(ModelAndView modelAndView){
        //设置模型数据
        modelAndView.addObject("username","112223334");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick3
会在页面中显示如下:
Spring-MVC
在UserController.java文件新增以下代码段:

    @RequestMapping(value = "/quick4")
    public String save4(Model model){
        model.addAttribute("username","yuiop");
        return "success";
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick4
会在页面中显示如下:
Spring-MVC
在UserController.java文件新增以下代码段(这种方式并不常用):

    @RequestMapping(value = "/quick5")
    public String save5(HttpServletRequest request){
        request.setAttribute("username","xodixjk");
        return "success";
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick5
会在页面中显示如下:
Spring-MVC
在UserController.java文件新增以下代码段(不推荐使用):

    @RequestMapping(value = "/quick6")
    public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().print("hello springMVC!!!");
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick6
会在页面中显示如下:
Spring-MVC

    @RequestMapping(value = "/quick7")
    @ResponseBody   //告知SpringMVC不进行页面跳转,直接进行数据响应
    public String save7(){
        return "hello springMVC!!!";
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick7
会在页面中显示如下:
Spring-MVC

解析jason数据

导入依赖坐标:

<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.java:

package com.stu.domain;

/**
 * @version:
 * @author: 零乘一
 * @description: 模仿用户类
 * @date: 2021/10/23 21:01
 **/
public class User {
    private String username;
    private int age;

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

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

    public String getUsername() {
        return username;
    }

    public int getAge() {
        return age;
    }
}

在UserController.java文件新增以下代码段(这段只是jason数据的测试,开发不会这么干的):

    @RequestMapping(value = "/quick8")
    @ResponseBody
    public String save8() throws JsonProcessingException {
        return "{\"username\":\"sdsd\",\"age\":30}";
    }

在UserController.java文件新增以下代码段:

    @RequestMapping(value = "/quick9")
    @ResponseBody
    public String save9() throws JsonProcessingException {
        User user = new User();
        user.setUsername("sdsd");
        user.setAge(30);
        //使用json的转换工具将对象转换成json格式字符串再返回
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);
        return json;
    }

运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick8或是http://localhost:8080/user/quick9
会在页面中显示如下:
Spring-MVC
解析jason数据改进
Spring-MVC
在xm文件中配置之后,就只需要返回需要返回的对象即可,springMVC会自动转成json字符串。
在spring-mvc.xml新增以下配置:

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

Spring-MVC
在UserController.java文件中新增以下代码段:

    @RequestMapping(value = "/quick10")
    @ResponseBody
    public User save10() throws JsonProcessingException {
        User user = new User();
        user.setUsername("lisi");
        user.setAge(30);
        return user;
    }

Spring-MVC
能够看出这边是直接返回想要在页面中显示的数据的对象。
运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick10
Spring-MVC
当然返回数组也是同样的操作
在UserController.java文件中新增以下代码段:

    @RequestMapping(value = "/quick11")
    @ResponseBody
    public User[] save11() throws JsonProcessingException {
        User[] users = new User[3];
        for (int i = 0; i < users.length; i++) {
            users[i] = new User();
            users[i].setUsername("测试"+i);
            users[i].setAge(10+i);
        }
        return users;
    }

能够看出这边是直接返回想要在页面中显示的数据的对象。
运行tomcat服务器后,在在网址栏中输入:http://localhost:8080/user/quick11
Spring-MVC

处理json数据只学这个!!!

前面两种还是太麻烦(直接白学,23333)这个方式的最重要的!!!
使用以下这个方法才是懒人的真谛,只需要写上一个注解,springMVC就以及帮你配置好处理器的映射器。使用注解mvc:annotation-driven替换注解处理器和适配器的配置,同时mvc:annotation-driven默认底层就集成jasckson进行对象或集合的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命名空间以及导入空间坐标-->
    <!--    使用注解配置处理器映射器-->
    <mvc:annotation-driven/>

Spring-MVC
Spring-MVC

SpringMVC获得请求数据

获得简单(基本)的参数

在UserController新增以下代码段:

    @RequestMapping(value = "/quick12")
    @ResponseBody
    //简单请求参数获取
    public void save12(String username,int age){
        System.out.println(username);
        System.out.println(age);
    }

运行tomcat服务器后,在网址栏中输入:http://localhost:8080/user/quick12?username=adb&age=19会在控制台区域打印如下:
Spring-MVC

自动封装为POJO对象

在UserController.java新增以下代码段:

    @RequestMapping(value = "/quick13")
    @ResponseBody
    //自动封装为POJO对象
    public void save13(User user){
        System.out.println(user);
    }

Spring-MVC
运行tomcat服务器后,在网址栏中输入:http://localhost:8080/user/quick13?username=adb&age=19会在控制台区域打印如下:
Spring-MVC

获得数组类型参数(不常用)

    @RequestMapping(value = "/quick14")
    @ResponseBody
    //自动封装为数组对象
    public void save14(String[] strs){
        System.out.println(Arrays.toString(strs));
    }

运行tomcat服务器后,在网址栏中输入:http://localhost:8080/user/quick14?strs=1&strs=2&strs=3会在控制台区域打印如下:
Spring-MVC

获得集合类型参数

新建类Vo.java:

package com.stu.domain;

import java.util.List;

/**
 * @version:
 * @author: 零乘一
 * @description: 用户列表类
 * @date: 2021/10/24 12:01
 **/
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 +
                '}';
    }
}

Spring-MVC

<%--
  Created by IntelliJ IDEA.
  User: Lcy
  Date: 2021/10/24
  Time: 12:03
  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>
    <form action="${pageContext.request.contextPath}/user/quick15">
<%--        表明第一个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>

Spring-MVC
运行tomcat服务器后,在网址栏中输入:http://localhost:8080/from.jsp显示如下:
Spring-MVC
随意输入几个数据然后提交:
ewq
123
qweq
123
ew
12
Spring-MVC
点击提交后会在idea控制台打印如下:
Spring-MVC
若打印的结果是null,那很有可能是Vo类中没有设置get方法。
Spring-MVC

ajax传输数据

将jquery-3.3.1.js放入文件夹中
Spring-MVC
新建ajax.jsp:

<%--
  Created by IntelliJ IDEA.
  User: Lcy
  Date: 2021/10/24
  Time: 16:48
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
    <script>//发送jason数据,并指定context为jason格式
        var userList = new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:28});

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

</body>
</html>

UserController.java文件新增以下代码段:

    @RequestMapping(value = "/quick16")
    @ResponseBody
    //@RequestBody要使数据能够成功被接收,在参数前要加上这个注解
    public void save16(@RequestBody List<User> userList) throws IOException {
        System.out.println(userList);
    }

在springMVC.xm新增如下代码段:这段配置是用于加载新增的静态资源js文件,如果不配置以下,在网页跳转时就会发现找不到我们放入的那个js文件。

<!--    开放资源的访问-->
    <mvc:resources mapping="/js/**" location="/js/"/>
    <!--    mapping:表示在服务器*问的地址,location:资源存储的地址-->

也可以替换为以下的配置:

    <!--    表示的是当前的资源无法找到对应的资源时,换回默认的资源选择器,交有tomcat去找资源-->
    <mvc:default-servlet-handler/>

运行tomcat服务器后,在网址栏中输入:http://localhost:8080/ajax.jsp控制台打印如下:
Spring-MVC
若已经配置,但还是找不到文件,则可以尝试一下以下操作,也许可以。
Spring-MVC
双击clean执行一下,再尝试一下执行。

请求数据中文乱码

之前写了一个form.jsp的页面文件,之前当我们输入中文提交后,在控制台中是无法识别中文的输出一堆的问号,做完以下配置就能够识别中文了。
在web.xml文件中新增以下配置:

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

运行tomcat服务器后,在网址栏中输入:http://localhost:8080/from.jsp输入如下数据并提交:
张三
20
李四
21
王五
22
在控制台中显示如下:
Spring-MVC

SpringMVC获得请求数据

@requestParam

它作用于当接收请求数据的方法的形参与传递的数据名不一样时,可以设置这个注解中的value属性指定请求的参数名称。
参数:
value:与请求参数名称。
required:此在指定的请求参数是否必须包括,默认是true,提交时如果没有此参数则报错。
defaultValue:当没有指定请求参数时,则使用指定的默认值赋值。
在UserController.java新增以下代码段:

    @RequestMapping(value = "/quick17")
    @ResponseBody
    //@RequestBody,意味着把请求体的内容直接封装到形参中(必须是context-jason格式),数据能够成功被接收,在参数前要加上这个注解
    public void save17(@RequestParam(value="name",required = false,defaultValue = "zhangsna") String username) throws IOException {
        System.out.println(username);
    }

运行tomcat服务器后,在网址栏中分别输入进行测试:
http://localhost:8080/user/quick17?name=123
http://localhost:8080/user/quick17
在控制台打印结果分别如下:
Spring-MVC
第二个请求方式之所以能够成功是因为我们在注解配置中有配置required = false,这个属性如果没有配置则默认为true,如果是true则在访问时则必须带上指定的参数。

Restful风格的参数(了解)

Restful风格的请求是使用“url+请求方式”
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

自定义类型转换器

自定义类型转换器的开发步骤:
①定义转换器类实现Converter接口
②在配置文件中声明转换器
③在annotation-driven中引用转换器
新建类DateConverter.java:实现Converter类,并实现convert方法。

package com.stu.controller;

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

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

/**
 * @version:
 * @author: 零乘一
 * @description: 日期对象转换器
 * @date: 2021/10/25 20:05
 **/
public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String dataStr) {
        //将日期字符串转换成日期对象,返回
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(dataStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

在UserController.java新增以下代码段:

    @RequestMapping(value = "/quick19")
    @ResponseBody
    public void save18(Date date) throws IOException {
        System.out.println(date);
    }

在spring-mvc.xml新增修改以下配置:

    <mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>
<!--    声明转换器-->
    <bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.stu.controller.DateConverter"/>
            </list>
        </property>
    </bean>

Spring-MVC
运行tomcat服务器后,在网址栏中分别输入进行测试:
http://localhost:8080/user/quick19?date=2019-01-01
在控制台打印结果如下:
Spring-MVC
这是因为在日期转换器中,我们配置了这样的日期格式,如果不配置,则它只能识别2019/'01/01的日期格式,设置了之后就只能识别2019-01-01格式i的日期了,在开发中,我们通常使用spring提供的转换为,不会自己写转换的类,但也不排除在开发时需要自己处理数据的转换,所以这个知识点要知道且记住。

获得Servlet相关API

在方法的形参中写上要获取的API类型的对象,Spring矿建就会自动的将对象注入。
在UserController.java新增以下代码段:

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

运行tomcat服务器后,在网址栏中分别输入进行测试:
http://localhost:8080/user/quick20
在控制台打印结果如下:
Spring-MVC
打印出的结果有地址说明Spring容器已经注入了对象。

获得请求头

运行tomcat服务器后,在网址栏中输入进行测试:
http://localhost:8080/user/quick21
在控制台打印结果如下:
Spring-MVC
在网页中点击F12打开控制台,打开网络之后再输入网址点击回车可以抓到如下包,然后可以找到请求头的User-Agent的信息。
Spring-MVC
能够看出在控制台打印的结果与网页上的数据是一致的,说明在Spring框架中已经成功获得请求头的数据。

获得CookieValue

在UserController.java新增以下代码段:

    @RequestMapping(value = "/quick22")
    @ResponseBody
    public void save22(@CookieValue(value = "JSESSIONID") String jsessionId) throws IOException {
        System.out.println(jsessionId);
    }

Spring-MVC
在网页中点击F12打开控制台,打开网络之后再输入网址点击回车可以抓到如下包,然后可以找到请求头的CookieValue的信息。
Spring-MVC
能够看出在控制台打印的结果与网页上的数据是一致的,说明在Spring框架中已经成功获得Cookie的数据。

文件上传

1、文件上传客户端三要素
表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部分表单形式,及enctype=“multipart/form-data”
Spring-MVC

单文件上传

新建upload.jsp文件:
Spring-MVC

<%--
  Created by IntelliJ IDEA.
  User: Lcy
  Date: 2021/10/28
  Time: 12:04
  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>
    <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="submit" name="提交">
    </form>
</body>
</html>

①在pom.xml文件中导入filerupload与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>

导入新的坐标后记得要刷新以下pom配置。
②配置文件上传解析器
在spring-mvc文件中新增以下配置:

<!--    配置文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--        配置文件上传的默认编码-->
        <property name="defaultEncoding" value="UTF-8"/>
        <property name="maxUploadSize" value="50000"/>
    </bean>

③编写文件上传代码
在UserController.java文件中新增以下代码段:

    @RequestMapping(value = "/quick23")
    @ResponseBody
    public void save23(String username, MultipartFile uploadFile) throws IOException {
        System.out.println(username);
        System.out.println(uploadFile);
    }

Spring-MVC
运行tomcat服务器后,在网址栏中输入进行测试:
http://localhost:8080/upload.jsp
名称随意,文件选择按照在配置文件中设置的要求来(大小限制之类的)
Spring-MVC
在控制台打印结果如下:
Spring-MVC
说明文件上传已经成功。
如果打印的结果是两个NULL,那可能是在配置文件中的东西写错了(例如id没写或写错,是谁我不说)。
在该方法中加入以下语句即能够实现文件的上传。

//获得上传文件的名称
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("E:\\a\\"+originalFilename));

Spring-MVC

多文件上传

在upload.jsp文件中新增以下代码段:

        名称<input type="text" name="username"><br>
		文件<input type="file" name="uploadFile"><br>

Spring-MVC
在UserController.java文件下新增以下代码段:两个input的name属性不同时

        //获得上传文件的名称
        originalFilename = uploadFile2.getOriginalFilename();
        uploadFile.transferTo(new File("E:\\a\\"+originalFilename));

Spring-MVC
然后在你指定的上传文件的文件夹中就能够看到上传的两个文件了。
在UserController.java文件下新增以下代码段:两个input的name属性相同时,使用数组的方式

    @RequestMapping(value = "/quick25")
    @ResponseBody
    public void save25(String username, MultipartFile[] uploadFile) throws IOException {
        System.out.println(username);
        System.out.println(uploadFile);
        for (MultipartFile multipartFile : uploadFile) {
            String originalFilename = multipartFile.getOriginalFilename();//获得上传文件的名称
            multipartFile.transferTo(new File("E:\\a\\"+originalFilename));//将该文件转移到某个文件夹中
        }
    }

并将jsp文件中的调用跳转的路径修改为方法25的。
Spring-MVC

上一篇:SprinMvc快速入门


下一篇:Spring Web MVC官方文档