SpringMVC

SpringMVC

01、SpringMVC简介

是什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。

MVC以业务逻辑、数据、显示分离的方法来组织代码。

MVC主要作用是降低了视图与业务逻辑间的双向偶合。

MVC不是一种设计模式，MVC是一种架构模式

• Model：数据模型，提供要展示的数据，因此包含数据和行为，现在一般都分为：Value Object（数据Dao） 和 服务层（行为Service），也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

• View：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

• Controller：接收用户请求，委托给模型进行处理，处理完毕后把返回的模型数据返回给视图，由视图负责展示，也就是说控制器做了个调度员的工作。

---

最典型的MVC就是JSP + servlet + javabean的模式

Model1

在web早期的开发中，通常采用的都是Model1。

Model1中，主要分为两层，视图层和模型层。

Model1优点：架构简单，比较适合小型项目开发；

Model1缺点：JSP职责不单一，耦合性高，职责过重，不便于维护；

Model2

Model2把一个项目分成三部分，包括视图、控制、模型。

• Controller：控制器

  1. 取得表单数据
  2. 调用业务逻辑
  3. 转向指定的页面

• Model：模型

  1. 处理业务逻辑
  2. 保存数据的状态

• View：视图

  1. 显示页面

Model2提高了代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。

回顾Servlet

1. 导入相关jar包：servlet-api，jsp-api
2. 编写Servlet类（继承HttpServlet），重写doGet（doPost）方法
3. 在web.xml中注册Servlet类
4. 配置Tomcat，进行测试

什么是SpringMVC

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

官方文档：Spring Framework

---

Spring MVC的特点：

1. 轻量级，简单易学
2. 高效 , 基于请求响应的MVC框架
3. 与Spring兼容性好，无缝结合
4. 约定优于配置
5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
6. 简洁灵活

中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
SpringMVC的原理如下图所示：

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

其中ModelAndView是可以设置属性（数据）和视图跳转的，Model只能设置数据。

SpringMVC执行原理

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程：

1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

   我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

   如上url拆分成三部分：

   http://localhost:8080服务器域名

   SpringMVC部署在服务器上的web站点

   hello表示控制器映射请求

   通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

6. Handler让具体的Controller执行。

7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView（或者Model，其中View的工作直接返回，交给视图解析器完成）。

8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12. 最终视图呈现给用户。

02、SpringMVC入门

基本用法

首先创建一个Maven项目，为其添加web框架支持，配置相应的Tomcat。***（别忘了把包放到target里新建的lib里，被坑好多次了）***

• 配置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">
    <!--
    注册DispatcherServlet
    springMVC是由请求驱动的，所有的请求都会经过DispatcherServlet这个集中处理层
    DispatcherServlet本质上也是一个servlet
    -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springMVC（DispatcherServlet）的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <!--数字越小，启动级别越高-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--
        /   匹配所有请求（不包括.jsp）
        /*  匹配所有请求（包括.jsp）
        这里使用    /
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

• 配置applicationContext.xml

这里需要注意：不要导错头文件约束，正确格式是springframework.org/schema/XXX

<?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">

    <!--扫描包，讲controller类注入到spring容器中-->
    <context:component-scan base-package="com.sinan.controller"/>
    <!--
    mvc注解驱动，完成mapping和adapter两个bean的注入
    这两个bean分别对应原理图中的HandlerMapping和HandlerAdapter
    -->
    <mvc:annotation-driven/>
    <!--让mvc不处理静态资源，例如css，html等-->
    <mvc:default-servlet-handler/>

    <!--
    配置视图解析器
    比如视图请求hello，经过视图解析器后就会找到/WEB-INF/jsp/hello.jsp这个文件
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    
</beans>

• 创建HelloController类

package com.sinan.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller//标记这个类是一个bean
@RequestMapping("/hello")//映射请求路径，加在该类下的所有映射请求路径前（可以不写，也可以不加前面那个斜杠）
//@RestController //该注解生效后，该类下所有方法返回字符串将不走视图解析器，而是返回字符串
public class HelloController {

    @RequestMapping("/trace")//映射路径，和类上注解结合就是完整的映射请求路径/hello/trace
    //@ResponseBody //同上面的@ResponseBody
    public String test(Model model){

        //ModelAndView里的Model（实际上他们并没有关系），负责向前端传递数据（记住，这玩意不是session，生命周期就是传一次数据就没了）
        model.addAttribute("msg","Hello Spring MVC");
        /*
        * 返回的字符串将被视图解析器解析，前往目标页面/WEB-INF/jsp/target.jsp，相当于ModelAndView里的View
        * 默认是转发形式访问目标页面
        * "redirect:/index.jsp"这种返回为重定向
        * */
        return "target";
    }
}

RESTful风格

概念

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

功能

传统方式操作资源 ：通过不同的请求来实现不同的效果！方法单一，post 和 get，不同的操作需要不同的访问请求

localhost:8080/queryItem?id=1 查询,GET

localhost:8080/insertItem?id=1&name=sinan&age=20 新增,GET

localhost:8080/updateItem 更新,POST

localhost:8080/deleteItem?id=1 删除,GET或POST

---

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

localhost:8080/item/1 查询,GET

localhost:8080/item 新增,POST

localhost:8080/item 更新,PUT

localhost:8080/item/1 删除,DELETE

核心原理就是根据请求的方式来判断这个请求是干什么的

• RestfulController类

package com.sinan.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestfulController {

    @RequestMapping("/t1/{a}/{b}")
    public String test1(Model model,@PathVariable int a, @PathVariable int b){
        model.addAttribute("msg","msg==>"+a+b);
        return "test";
    }

    @GetMapping("/t2/{a}/{b}")//是RequestMapping的扩展，用于处理以get方式提交的请求
    //等价于@RequestMapping(value = "t2/{a}/{b}",method = RequestMethod.GET)
    public String test2(Model model,@PathVariable int a, @PathVariable int b){
        model.addAttribute("msg","msg==>"+(a+b));
        return "test";
    }

    @PostMapping("/t2/{a}/{b}")//是RequestMapping的扩展，用于处理以get方式提交的请求
    public String test3(Model model,@PathVariable int a, @PathVariable int b){
        model.addAttribute("msg","msg==>"+(a-b));
        return "test";
    }
}

• index.xml配置

<form action="/t2/2/4" method="get">
  <input type="submit" value="get提交"></input>
</form>
<form action="/t2/2/4" method="post">
  <input type="submit" value="post提交"></input>
</form>

测试结果：

可以看出，RESTful风格是根据请求方式来进行请求判断，相同的请求实现不同的效果

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

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

接收前端数据

• ReceiveDataController类

package com.sinan.controller;

import com.sinan.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class ReceiveDataController {

    @RequestMapping("/receive")
    public String receive(@RequestParam("username") String name, @RequestParam("password") String pwd){
        //前端那个参数叫什么名字，@RequestParam括号里就是一样的名字
        return "test";
    }

    @RequestMapping("/receive2")
    public String receive2(User user){
        //如果前端传入的是一个类的属性例如name和age，这里直接接收这个对象，如果前端传入的参数不够，则接受的对象对应属性为空
        return "test";
    }
}

前端传入中文乱码问题

以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 。

固定写法哦

配置web.xml文件

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

03、Json交互处理

什么是json

• json(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。

• 采用完全独立于编程语言的文本格式来存储和表示数据。

• 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

• 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

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

一句话总结：json 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

json转换会有乱码问题，在applicationContext.xml中配置

<!--统一解决json乱码问题-->
<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>

Jackson

使用Jackson来对一般对象进行格式转换

• 先导个包

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

• JsonController类

package com.sinan.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.sinan.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

@RestController
public class JsonController {

    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();        //jackson主要是这个ObjectMapper对象
        return objectMapper.writeValueAsString(new User("司南杓",20,"男"));
    }

    @RequestMapping("/j2")
    public String json2() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        ArrayList<User> users = new ArrayList<>();
        users.add(new User("司南杓1",21,"男"));
        users.add(new User("司南杓2",22,"女"));
        users.add(new User("司南杓3",23,"男"));
        users.add(new User("司南杓4",24,"女"));

        return objectMapper.writeValueAsString(users);
    }

    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();//默认Date转化为json是时间戳的形式
        //定义不使用时时间戳
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //设置日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        objectMapper.setDateFormat(simpleDateFormat);
        return objectMapper.writeValueAsString(new Date());
    }
}

测试结果：

Fastjson

使用阿里的fastjson来对一般对象进行格式转换

• 先导个包

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79</version>
</dependency>

阿里的这个就简单粗暴多了

@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
    User user = new User("司南杓", 21, "男");

    //将java对象转化为json对象
    JSONObject jsonObject = (JSONObject) JSON.toJSON(user);

    //将java对象转化为json字符串
    String jsonString = JSON.toJSONString(user);

    //将json字符串转为java对象
    User user2 = JSON.parseObject(jsonString, User.class);

    return "";
}

04、Ajax

什么是Ajax

• AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

• AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

• Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

• 在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。

• Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。

• 传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。

• 使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。

• 使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。

jQuery.ajax

• jQuery 提供多个与 AJAX 有关的方法。

• 通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。

• jQuery 不是生产者，而是大自然搬运工。

• jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery.ajax(...)
    部分参数：
    url：请求地址
    type：请求方式，GET、POST（1.9.0之后用method）
    headers：请求头
    data：要发送的数据
    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
    async：是否异步
    timeout：设置请求超时时间（毫秒）
    beforeSend：发送请求前执行的函数(全局)
    complete：完成之后执行的回调函数(全局)
    success：成功之后执行的回调函数(全局)
    error：失败之后执行的回调函数(全局)
    accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
    dataType：将服务器端返回的数据转换成指定类型
    "xml": 将服务器端返回的内容转换成xml格式
    "text": 将服务器端返回的内容转换成普通文本格式
    "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
    "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
    "json": 将服务器端返回的内容转换成相应的JavaScript对象
    "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

---

测试钱先导入jquery-3.6.0.js，路径为/statics/js/jquery-3.6.0.js

使用测试

• AjaxController类

package com.sinan.controller;

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

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestController
public class AjaxController {

    @RequestMapping("/a1")
    public String a1(String name){
        if ("司南杓".equals(name)){
            return "true";
        }else {
            return "false";
        }
    }
}

• ajax.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="/statics/js/jquery-3.6.0.js"></script>
    <script>
        function a() {
            $.post({
                url : "/a1",
                data : {"name" : $("#username").val()},
                success : function (data, status) {
                    console.log(data);
                    console.log(status);
                }
            })
        }
    </script>
</head>
<body>

<%--失去焦点时，发起一个请求（含信息）到后台--%>
用户名：<input type="text" id="username" οnblur="a()">

</body>
</html>

测试结果：

---

密码验证测试

• AjaxController类

@RequestMapping("/a2")
public String a2(String pwd){
    if ("123456".equals(pwd)){
        return "OK";
    }else {
        return "密码错误";
    }
}

• ajax.jsp

function a2() {
    $.post({
        url: "/a2",
        data: {"pwd": $("#password").val()},
        success: function (data) {
            //注意是三等于号
            if (data.toString() === "OK"){
                $("#pwdInfo").css("color","green")
            }else {
                $("#pwdInfo").css("color","red")
            }
            $("#pwdInfo").html(data)
        }
    })
}
<%--密码错误则报红提示，正确显示绿色OK--%>
<p>
    密码：<input type="text" id="password" οnblur="a2()">
    <span id="pwdInfo"></span>
</p>

测试结果

---

加载后端数据类测试

• AjaxController类

@RequestMapping("/a3")
public List<User> a3(){
    ArrayList<User> users = new ArrayList<>();
    users.add(new User("司南杓1",10,"男"));
    users.add(new User("司南杓2",30,"女"));
    return users;
}

• ajax.jsp

function a3() {
    $.post({
        url: "/a3",
        success: function (data) {
            var html="";
            for (let i = 0; i < data.length;i++){
                html+="<tr>" +
                    "<td>" + data[i].name + "<td>" +
                    "<td>" + data[i].age + "<td>" +
                    "<td>" + data[i].sex + "<td>" +
                    "<tr>";
            }
            $("#content").html(html);
        }
    })

}
<input type="button" value="加载数据" οnclick="a3()">
<table>
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id = "content">
    <%--数据：后台--%>
    </tbody>
</table>                                                 

测试结果：

05、拦截器，文件上传下载

拦截器

什么是拦截器

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

过滤器与拦截器的主要区别：拦截器是AOP思想的具体应用。

过滤器：

• servlet规范中的一部分，任何java web工程都可以使用

• 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器：

• 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

• 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

注意啊，拦截器拦的是请求，重定向，不是转发和静态资源

---

• MyInterceptor类

package com.sinan.config;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("===============拦截前=========");
        
        //根据uri来选择放行一些请求（uri和url是不一样的）
        if(request.getRequestURI().contains("login") || request.getRequestURI().contains("submitLogin")){
            return true;
        }
        
        HttpSession session = request.getSession();
        if (session.getAttribute("username") != null){
            //如果session中没有登录，则重定向到首页
            response.sendRedirect("/index.jsp");
            return false;
        }

        //return true,放行，执行下一个拦截器
        //return false，不执行下一个拦截器
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("===============拦截后=========");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("===========清理===============");
    }
}

• applicationContext.xml

<!--拦截器配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--包括这个请求下的所有请求
        /* 表示只拦一层
        /** 表示拦截所有层
        -->
        <mvc:mapping path="/**"/>
        <bean class="com.sinan.config.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

文件上传下载

这玩意给个固定写法，需要的时候直接CTRL+C/V

上传

• index.jsp

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

• 导包

<!--文件上传-->
<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>

• 配置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>

• java类

/*
 * 采用file.Transto 来保存上传的文件
 */
@RequestMapping("/upload")
public String  fileUpload(@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";
}

下载

• 前端

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

• java类

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