SpringMVC-day02

最新推荐文章于 2024-07-09 16:46:46 发布

sunnyboy

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量590

点赞数

分类专栏： SpringMVC 文章标签： mvc java

本文链接：https://blog.csdn.net/qq_43776195/article/details/124735865

版权

SpringMVC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

SpringMVC-day02

SpringMVC-day02

声明：本博客参考微信公众号：狂神说

1、控制器 Controller

相当于原理分析的执行流程图中的处理器（Handler）

在这里插入图片描述

1.1 概述

控制器负责提供访问应用程序的行为，通常有 接口定义或注解定义 两种方法。
控制器负责解析用户的请求并将其转换为一个模型。
在Spring MVC中一个控制器类可以包含多个方法。
在Spring MVC中，对于Controller的配置方式有很多种（有多种控制器【处理器】实现）

1.2 实现Controller接口

Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；

//实现该接口的类获得控制器功能
public interface Controller {
    //处理请求且返回一个模型与视图对象
    ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) throws Exception;
}

1.2.1 新建一个Moudle，编写SpringMVC配置文件

<!-- 处理器映射器 -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!-- 处理器适配器 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--视图解析器:解析 DispatcherServlet（返回）给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

1.2.2 编写Controller控制器类（处理器）

//定义控制器
//注意点：不要导错包，实现Controller接口，重写方法；
public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","Test1Controller");
        mv.setViewName("test");
        return mv;
    }
}

1.2.3 注册控制器Bean

编写完毕后，去SpringMVC配置文件（相当于Spring配置文件）中注册要处理请求的bean；
name对应请求路径，class对应处理请求的类

<bean name="/t1" class="com.kuang.controller.ControllerTest1"/>

1.2.4 编写前端 test.jsp

注意在WEB-INF/jsp目录下编写，对应我们的 视图解析器

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Kuangshen</title>
    </head>
    <body>
        ${msg}
    </body>
</html>

1.2.5 配置Tomcat运行测试

这里没有配置项目发布名的就是一个 / ，所以请求不用加项目名，OK！

在这里插入图片描述

说明：

实现接口Controller定义控制器是较老的办法
缺点
- 一个控制器中只有一个方法，
- 如果要多个方法则需要定义多个Controller

1.3 使用注解 @Controller

@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）；
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。

1.3.1 配置SpringMVC核心配置文件


<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 1、自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.kuang.controller"/>
    <!-- 2、让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    3、支持mvc注解驱动
       在spring中一般采用@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效
       必须向上下文中注册DefaultAnnotationHandlerMapping
       和一个AnnotationMethodHandlerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven />

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

</beans>

1.3.2 测试

//@Controller注解的类会自动添加到Spring上下文中
@Controller
public class ControllerTest2{

    //映射访问路径
    @RequestMapping("/t2")
    public String index(Model model){
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "ControllerTest2");
        //返回视图位置
        return "test";
    }
}

说明：

可以发现，我们的两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。

注解方式是平时使用的最多的方式！

1.3.3 @RequestMapping

@RequestMapping注解用于映射 url 到控制器类或一个特定的处理程序方法。
可用于类或方法上。
- 用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
@RequestMapping(“xxx”)
- 用于指定请求访问的映射路径
- 一般用 value 或者 path 来指定，不写默认是 value，有多个属性要写上 value 或者 path
  - @RequestMapping(value = “/hello”,method = {RequestMethod.POST})

1、作用于方法上

@Controller
public class TestController {
    @RequestMapping("/h1")
    public String test() {
        return "test";
    }
}

访问路径：http://localhost:端口号 / 项目名 / h1

2、同时作用于类上和方法上

@Controller
@RequestMapping("/admin")
public class TestController {
    @RequestMapping("/h1")
    public String test() {
        return "test";
    }
}

访问路径：http://localhost:端口号 / 项目名/ admin /h1
类上的相当于一层父路径，访问此类中的所有方法都要加上这层父路径

2、RestFul 风格

2.1 概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

2.2 功能

添加、删除、修改、查询。

2.2.1 资源

互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法（方式）对资源进行操作。

2.2.2 不同的操作方式

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询，GET

http://127.0.0.1/item/saveItem.action 新增，POST

http://127.0.0.1/item/updateItem.action 更新，POST

http://127.0.0.1/item/deleteItem.action?id=1 删除，GET 或 POST

使用RESTful操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询，GET

http://127.0.0.1/item 新增，POST

http://127.0.0.1/item 更新，PUT

http://127.0.0.1/item/1 删除，DELETE

URI格式：/资源名称/资源标识

	普通CRUD（uri来区分操作）	RestfulCRUD（HTTP请求方式：区分对资源CRUD操作）
查询	getEmp	emp—GET
添加	addEmp?xxx	emp—POST
修改	updateEmp?id=xxx&xxx=xx	emp/{id}—PUT
删除	deleteEmp?id=1	emp/{id}—DELETE

RestFul 风格实现如：

功能	请求URI	请求方式
查询所有员工	emps	GET
查询某个员工(来到修改页面)	emp/1	GET
来到添加页面	emp	GET
添加员工	emp	POST
来到修改页面（查出员工进行信息回显）	emp/1	GET
修改员工	emp	PUT
删除员工	emp/1	DELETE

2.3 使用步骤

在新建一个类 RestFulController

在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@Controller
public class RestFulController {
    //映射访问路径
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable int p2, Model model){

        int result = p1 + p2;
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "结果："+result);
        //返回视图位置
        return "test";
    }
}

访问路径为：http://localhost:端口号 / 项目名/commit/xxx/xxx

测试

在这里插入图片描述

说明：

思考：使用路径变量的好处？
- 使路径变得更加简洁；
- 获得参数更加方便，框架会自动进行类型转换。
- 通过路径变量的类型可以约束访问参数，如果路径中传入的参数和方法上的模板变量的类型不一样，则访问不到对应的请求方法，如下图所示：
  - 这里访问是的路径是/commit/1/a，则路径中传入的参数与方法上的模板变量类型不匹配，而不会是参数转换失败。
方法上的模板变量的名字，对应着前端（前台）的表单的name属性值

在这里插入图片描述

2.4 使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如：**GET，POST，**HEAD，OPTIONS，PUT，PATCH，DELETE，TRACE 等。

测试

增加一个方法

//映射访问路径，必须是POST请求
@RequestMapping(value="/hello",method={RequestMethod.POST})
public String index2(Model model) {
    model.addAttribute("msg", "hello!");
    return "test";
}

我们使用浏览器地址栏进行访问默认是 Get请求，会报 405 错误：请求方法不被允许！

在这里插入图片描述

将POST修改为GET则正常了

在这里插入图片描述

2.5 小结

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的地址栏请求默认都会是 HTTP GET 类型的。

2.5.1 组合注解

方法级别的注解变体有如下几个：

@GetMapping //查询
@PostMapping //新增
@PutMapping //修改
@DeleteMapping //删除
/****@PatchMapping不常用****/
@PatchMapping //Patch方式是对put方式的一种补充;put方式是可以更新.但是更新的是整体.patch是对局部更新;

说明：

@GetMapping 相当于@RequestMapping(method =RequestMethod.GET) 。
其余以此类推…

3、结果跳转方式

3.1 ServletAPI

通过设置ServletAPI , 不需要视图解析器

1、通过HttpServletResponse进行输出

2、通过HttpServletResponse实现重定向

3、通过HttpServletRequest实现转发

@Controller
public class ResultGo {

    @RequestMapping("/result/t1") //请求映射路径
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
    }

    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
    }

    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","ServletAPI转发"); //设置信息
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
    }
}

3.2 SpringMVC来实现转发和重定向

1、无需视图解析器

测试前，需要将视图解析器注释掉

@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1() {
        //不加 forward，默认就是 转发
        return "/index.jsp";
    }

    @RequestMapping("/rsm/t2")
    public String test2() {
        //转发二
        return "forward:/index.jsp";
    }

    @RequestMapping("/rsm/t3")
    public String test3() {
        //重定向
        return "redirect:/index.jsp";
    }
}

2、有视图解析器

重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方，所以注意路径问题

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1() {
        //转发
        return "test";
    }

    @RequestMapping("/rsm2/t2")
    public String test2() {
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do为另一个请求
    }

3.3 ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面
页面：{视图解析器前缀} + viewName +{视图解析器后缀}

<!-- 在SpringMVC配置文件中配置 -->
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
      id="internalResourceViewResolver">
    <!-- 前缀 -->
    <property name="prefix" value="/WEB-INF/jsp/" />
    <!-- 后缀 -->
    <property name="suffix" value=".jsp" />
</bean>

对应的controller类

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

4、数据处理

4.1 处理前端提交的数据

1、提交的域名称和处理方法的参数名一致

提交数据 : http://localhost:8080/hello?name=kuangshen

处理器（控制器）：

@RequestMapping("/hello")
public String hello(String name) {
    System.out.println(name); //后台打印
    return "hello";
}

后台打印 : kuangshen

2、提交的域名称和处理方法的参数名不一致

提交数据 : http://localhost:8080/hello?username=kuangshen

处理器（控制器） :

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

@RequestParam(“username”) : username提交的域的名称
后台输出 : kuangshen

3、提交的是一个对象

要求提交的【表单域和对象的属性名一致】 , 参数使用对象即可
提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

实体类

public class User {
    private int id;
    private String name;
    private int age;
    //构造
    //get/set
    //tostring()
}

处理器（控制器） :

@RequestMapping("/user")
public String user(User user) {
    System.out.println(user);
    return "hello";
}

后台输出 : User { id=1, name=‘kuangshen’, age=15 }
说明：
- 如果使用对象的话，【前端传递的参数名和对象属性名必须一致】，否则就是 null。

4.2 回显数据到前端

1、通过ModelAndView回显

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

2、通过ModelMap回显

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model) {
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

3、通过Model回显

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model) {
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

三种方式的对比

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。

5、乱码问题

5.1 问题演示

1、在首页（index.jsp）编写一个提交的表单

<form action="/e/t" method="post">
    <input type="text" name="name">
    <input type="submit">
</form>

2、后台编写对应的处理类（控制器）

@Controller
public class Encoding {
    @RequestMapping("/e/t") //请求映射路径
    public String test(Model model,String name) {
        model.addAttribute("msg",name); //获取表单提交的值
        return "test"; //跳转到test页面显示输入的值
    }
}

3、测试

在表单中输入中文，出现中文乱码问题

在这里插入图片描述

5.2 SpringMVC自带过滤器

org.springframework.web.filter.CharacterEncodingFilter

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

5.3 自定义过滤器

package com.wqy.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");

        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }

    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                                       .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }

    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }

    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

这个过滤器是网上的大神写的~

然后在web.xml中配置这个过滤器即可！

乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

6、JSON 交互处理

6.1 什么是JSON？

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

对象表示为键值对，数据由逗号分隔
花括号保存对象
方括号保存数组

JSON 键值对 是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

6.1.1 JSON 和 JavaScript 对象互转

要实现从 JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

要实现从 JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

6.1.2 代码测试

1、新建一个module ，springmvc-05-json ，添加web的支持

2、在web目录下新建一个 json-1.html ，编写测试内容

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>JSON_秦疆</title>
    </head>
    <body>
        <script type="text/javascript">
            //编写一个js的对象
            var user = {
                name:"秦疆",
                age:3,
                sex:"男"
            };
            //将js对象转换成json字符串
            var str = JSON.stringify(user);
            console.log(str);

            //将json字符串转换为js对象
            var user2 = JSON.parse(str);
            console.log(user2.age,user2.name,user2.sex);
        </script>
    </body>
</html>

6.2 JSON解析——Jackson

Controller返回JSON数据

6.2.1 Jackson 的初步使用

1、导入 Jackson 的 jar包

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

2、配置 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">

    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/</url-pattern>
    </filter-mapping>
</web-app>

3、配置 springmvc-servlet.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
    <context:component-scan base-package="com.kuang.controller"/>

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

</beans>

4、编写 User的实体类

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

5、编写 Controller类（控制器、处理器）

@Controller
public class UserController {

    @RequestMapping("/json1")
    @ResponseBody
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("秦疆1号", 3, "男");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
}

说明：

@ResponseBody的作用其实是将java对象转为json格式的数据。

@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。一个是ObjectMapper对象。

注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

@ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】。

注意：在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。比如异步获取 json 数据，加上 @ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。

6、测试

访问地址：http://localhost:8080/json1

在这里插入图片描述

发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；

通过@RequestMaping的produces属性来实现，修改下代码：

//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

说明：

produces：指定响应体返回类型和编码

注意：使用json记得处理乱码问题

6.2.2 Jackson 优化

1、统一解决乱码问题

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！
可以在 springmvc 的配置文件上添加一段消息 StringHttpMessageConverter 转换配置！

<mvc:annotation-driven>

    <mvc:message-converters register-defaults="true">
        
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>

    </mvc:message-converters>

</mvc:annotation-driven>

2、返回 JSON 字符串统一解决

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！在前后端分离开发中，一般都使用 @RestController ，十分便捷！

@RestController
public class UserController {

    //produces:指定响应体返回类型和编码
    @RequestMapping(value = "/json1")
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("秦疆1号", 3, "男");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
}

6.2.3 测试集合输出

增加一个新方法（控制器 / 处理器）

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {

    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    //创建一个对象
    User user1 = new User("秦疆1号", 3, "男");
    User user2 = new User("秦疆2号", 3, "男");
    User user3 = new User("秦疆3号", 3, "男");
    User user4 = new User("秦疆4号", 3, "男");
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);

    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(list);
    return str;
}

集合输出结果：

在这里插入图片描述

6.2.4 输出时间对象

增加一个新方法（控制器 / 处理器）

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();

    //创建时间一个对象，java.util.Date
    Date date = new Date();
    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    return str;
}

时间对象输出结果：

在这里插入图片描述

默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
Jackson 默认是会把时间转成 **timestamps（时间戳）**形式

解决方案：取消 timestamps（时间戳）形式，自定义时间格式

//方式 1：也可以使用Java原生态的时间格式化
@RequestMapping("/json4_1")
public String json4() throws Exception {
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = new Date();

    String str = sdf.format(date);
    return str;
}

//方式 2：Jackson自带的解决方式
@RequestMapping("/json4")
public String json4() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();

    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //指定日期格式
    mapper.setDateFormat(sdf);

    Date date = new Date();
    String str = mapper.writeValueAsString(date);
    return str;
}

格式化好的时间：

在这里插入图片描述

6.2.4.1 优化

1、抽取工具类

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

public class JsonUtils {

    //默认返回的时间格式："yyyy-MM-dd HH:mm:ss"
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat) {
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用工具类后：

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
    Date date = new Date();
    /*
    不指定时间格式就采用默认的时间格式
    默认返回的时间格式："yyyy-MM-dd HH:mm:ss"
    */
    String json = JsonUtils.getJson(date);
    return json;
}

6.3 JSON解析——FastJson（阿里）

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现 json 对象与 JavaBean 对象的转换，实现JavaBean对象与json字符串 的转换，实现 json对象与json字符串 的转换。实现json的转换方法很多，最后的实现结果都是一样的。

6.3.1 FastJson 三个主要的类

1、JSONObject 代表 json 对象

JSONObject 实现了 Map 接口, 猜想 JSONObject 底层操作是由 Map 实现的。
JSONObject 对应 json 对象，通过各种形式的 get() 方法可以获取 json 对象中的数据，也可利用诸如 size()，isEmpty() 等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现 Map 接口并调用接口中的方法完成的。

2、JSONArray 代表 json 对象数组

内部是有 List 接口中的方法来完成操作的。

3、JSON代表 JSONObject和JSONArray的转化

JSON 类源码分析与使用
仔细观察这些方法，主要是实现 json 对象，json 对象数组，javabean 对象，json 字符串之间的相互转化。

6.3.2 使用步骤

1、fastjson 的 pom依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

2、编写测试类

public class testFastJson {
    public static void main(String[] args) {
        //创建对象
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);

        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

这种工具包（类），我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。

7、Spring-MVC 拦截器

7.1 概述

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

preHandle:

在访问到达Controller之前执行，如果需要对请求做预处理,可以选择在该方法中完成，
返回值为 true：true表示继续执行后面的拦截器或者Controller
返回值为false：不再执行后面的拦截器和Controller,并调用返回true的拦截器的afterCompletion方法 ( 多个拦截器拦截时，先声明的先调用）

postHandle:

在执行完Controller方法之后,DispatcherServlet渲染视图之前执行，如果需要对响应相关的数据进行处理,可以选择在该方法中完成，(多个拦截器时)先声明的后调用。

afterCompletion:

调用完Controller接口，渲染View页面后调用。返回true的拦截器都会调用该拦截器的afterCompletion方法。 (多个拦截器时) 先声明的后调用。只要有一个拦截器的preHandle 为true，那么它的 afterCompletion 方法就一定会执行。

拦截器执行流程图：

在这里插入图片描述

7.1.1 过滤器与拦截器的区别：

拦截器是AOP思想的具体应用。

过滤器

servlet规范中的一部分，任何java web工程都可以使用
在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
拦截器只会拦截访问的控制器方法，如果访问的是 jsp/html/css/image/js 是不会进行拦截的

7.2 自定义拦截器

那如何实现拦截器呢？

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

7.2.1 步骤

1、新建一个Moudule ， springmvc-07-Interceptor ，添加web支持

2、配置web.xml 和 springmvc-servlet.xml 文件

3、编写一个拦截器

public class MyInterceptor implements HandlerInterceptor {

    //在请求处理的方法之前执行
    //如果返回true执行下一个拦截器
    //如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------");
        return true; //放行
    }

    //在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------");
    }

    //在dispatcherServlet处理后执行,做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------");
    }
}

4、在springmvc的配置文件中配置拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- /** 包括路径及其子路径-->
        <!-- /admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
        <!-- /admin/** 拦截的是/admin/下的所有-->
        <mvc:mapping path="/**"/>
        <!--bean配置的就是拦截器-->
        <bean class="com.kuang.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

5、编写一个Controller（控制器、处理器），接收请求

//测试拦截器的控制器
@Controller
public class InterceptorController {

    @RequestMapping("/interceptor")
    @ResponseBody
    public String testFunction() {
        System.out.println("控制器中的方法执行了");
        return "hello";
    }
}

6、前端 index.jsp

<a href="${pageContext.request.contextPath}/interceptor">拦截器测试</a>

7、配置Tomcat，测试

在这里插入图片描述

7.3 拦截器的具体应用

需求：验证用户是否登录 (认证用户)

实现思路：

1、有一个登陆页面，需要写一个 controller（控制器、处理器）访问页面。

2、登陆页面有一提交表单的动作。需要在 controller 中处理。判断用户名密码是否正确。如果正确，向 session中写入用户信息。返回登陆成功。

3、拦截用户请求，判断用户是否登陆。如果用户已经登陆。放行，如果用户未登陆，跳转到登陆页面，如果用户请求的是登录页面，则不拦截，放行即可。

步骤：

7.3.1 编写一个登陆页面 login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <h1>登录页面</h1>
    <hr>
    <body>
        <form action="${pageContext.request.contextPath}/user/login">
            用户名：<input type="text" name="username"> <br>
            密码：<input type="password" name="pwd"> <br>
            <input type="submit" value="提交">
        </form>
    </body>
</html>

7.3.2 编写一个登陆成功的页面 success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h1>登录成功页面</h1>
        <hr>
        ${user}
        <a href="${pageContext.request.contextPath}/user/logout">注销</a>
    </body>
</html>

2-1、在不配置拦截器的情况下，直接访问 index.jsp 页面，点击链接测试跳转！

启动Tomcat 测试，未登录也可以进入主页！

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>测试主页</title>
    </head>
    <body>
        <h1>首页</h1>
        <hr>
        <%--登录--%>
        <a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
        <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>
    </body>
</html>

7.3.3 编写用户登录拦截器

public class LoginInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        // 如果是登陆页面则放行
        System.out.println("uri: " + request.getRequestURI());
        if (request.getRequestURI().contains("login")) {
            return true; //放行
        }

        HttpSession session = request.getSession();

        // 如果用户已登陆也放行
        if(session.getAttribute("user") != null) {
            return true;
        }

        // 用户没有登陆跳转到登陆页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }

    //在请求处理方法(Controller)执行之后执行，也就是放行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    //在dispatcherServlet处理后执行,做清理工作
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

7.3.4 编写一个 Controller 处理请求

@Controller
@RequestMapping("/user")
public class UserController {

    //跳转到登陆页面
    @RequestMapping("/jumplogin")
    public String jumpLogin() throws Exception {
        return "login";
    }

    //跳转到成功页面
    @RequestMapping("/jumpSuccess")
    public String jumpSuccess() throws Exception {
        return "success";
    }

    //登陆提交
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String pwd) throws Exception {
        // 向session记录用户身份信息
        System.out.println("接收前端===" + username);
        session.setAttribute("user", username);
        return "success";
    }

    //退出登陆
    @RequestMapping("logout")
    public String logout(HttpSession session) throws Exception {
        // session 过期
        session.invalidate();
        return "login";
    }
}

7.3.5 在 Springmvc 的配置文件中注册拦截器

<!-- 前面还有：视图解析器等一些必要配置  -->

<!--关于拦截器的配置-->
<mvc:interceptors>
    <!--/** 包括路径及其子路径-->
    <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
    <!--/admin/** 拦截的是/admin/下的所有-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean id="loginInterceptor" class="com.kuang.interceptor.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

7.3.6 配置Tomcat，测试

OK，测试登录拦截功能无误！

8、文件上传与下载

8.1 准备工作

1、文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。

2、如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

3、前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器。

对表单中的 enctype 属性做个详细的说明：

application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码（文件上传会用到）。
text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

例如：文件上传案例

<form action="" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit">
</form>

一旦设置了enctype为 multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理，则涉及在服务器端解析原始的HTTP响应。

在2003年，Apache Software Foundation 发布了开源的 Commons FileUpload 组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

Servlet3.0 规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成。
而 Spring MVC 则提供了更简单的封装。
Spring MVC 为文件上传提供了直接的支持，这种支持是用即插即用的 MultipartResolver 实现的。
Spring MVC 使用 Apache Commons FileUpload 技术实现了一个 MultipartResolver 实现类：CommonsMultipartResolver。
因此，SpringMVC的文件上传还 需要依赖 Apache Commons FileUpload 的组件。

8.2 文件上传案例

8.2.1 新建项目，导包

导入文件上传的 jar 包，commons-fileupload，Maven会自动帮我们导入他的依赖包 commons-io包

<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

8.2.2 配置bean：multipartResolver

<!--文件上传配置-->
<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

说明：

1、这个bena的id必须为：multipartResolver ，否则上传文件会报400的错误！

2、CommonsMultipartFile 的常用方法：

String getOriginalFilename()：获取上传文件的原名
InputStream getInputStream()：获取文件流
void transferTo(File dest)：将上传文件保存到一个目录文件中

8.2.3 编写前端页面

<form action="/upload" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit" value="upload">
</form>

8.2.4 编写 Controller（控制器、处理器）

@Controller
public class FileController {
    //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
    //批量上传CommonsMultipartFile则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

        //获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();

        //如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)) {
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名 : "+uploadFileName);

        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()) {
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址："+realPath);

        //文件输入流
        InputStream is = file.getInputStream(); 
        //文件输出流
        OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); 

        //读取写出
        int len=0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1) {
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }
}

8.2.5 测试

测试上传文件，OK！

8.2.6 优化文件上传

采用file.Transto 来保存上传的文件。

1、编写Controller

/*
* 采用file.Transto 来保存上传的文件
*/
@RequestMapping("/upload2")
public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

    //上传路径保存设置
    String path = request.getServletContext().getRealPath("/upload");
    File realPath = new File(path);
    if (!realPath.exists()) {
        realPath.mkdir();
    }
    //上传文件地址
    System.out.println("上传文件保存地址：" + realPath);

    //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
    file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

    return "redirect:/index.jsp";
}

2、前端表单提交地址修改

3、访问提交测试，OK！

8.3 文件下载案例

8.3.1 文件下载步骤

1、设置 response 响应头

2、读取文件 – InputStream

3、写出文件 – OutputStream

4、执行操作

5、关闭流（先开后关）

8.3.2 编写前端页面

<a href="/download">点击下载</a>

8.3.3 编写 Controller

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception {
    //要下载的图片地址
    String  path = request.getServletContext().getRealPath("/upload");
    String  fileName = "基础语法.jpg";

    //1、设置response 响应头
    response.reset(); //设置页面不缓存,清空buffer
    response.setCharacterEncoding("UTF-8"); //字符编码
    response.setContentType("multipart/form-data"); //二进制传输数据
    //设置响应头
    response.setHeader("Content-Disposition",
                       "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));

    File file = new File(path,fileName);
    //2、 读取文件--输入流
    InputStream input=new FileInputStream(file);
    //3、 写出文件--输出流
    OutputStream out = response.getOutputStream();

    byte[] buff =new byte[1024];
    int index=0;
    //4、执行 写出操作
    while((index= input.read(buff))!= -1) {
        out.write(buff, 0, index);
        out.flush();
    }
    out.close();
    input.close();
    return null;
}

8.3.4 测试

测试，文件下载OK，和之前学习的JavaWeb原生的方式对比一下，就可以知道这个便捷多了!

小结：拦截器及文件操作在开发中十分重要，一定要学会使用！

拓展：ajax跨域请求被浏览器同源策略拦截的问题，解决方案：

在这里插入图片描述
声明：本博客参考微信公众号：狂神说。
不喜勿喷，谢谢，本博客只是希望给大家一个参考，希望能帮助到需要的人。

sunnyboy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringMVC-day02

文章目录SpringMVC-day02声明：本博客参考微信公众号：狂神说1、控制器 Controller1.1 概述1.2 实现Controller接口1.2.1 新建一个Moudle，编写SpringMVC配置文件1.2.2 编写Controller控制器类（处理器）1.2.3 注册控制器Bean1.2.4 编写前端 test.jsp1.2.5 配置Tomcat运行测试1.3 使用注解 @Controller1.3.1 配置SpringMVC核心配置文件1.3.2 测试1.3.3 @RequestMap
复制链接

扫一扫