SpringMVC（JSON、Ajax、拦截器、文件上传和下载）

本文链接：https://blog.youkuaiyun.com/weixin_46744534/article/details/112623686

SpringMVC

JSON

回顾以往的文章JSON

@Controller和@RestController

@Controller 返回⼀个页面

单独使⽤ @Controller 不加 @ResponseBody 的话⼀般使⽤在要返回⼀个视图的情况，这种情况属于⽐᫾传统的Spring MVC 的应⽤，对应于前后端不分离的情况。

@RestController 返回JSON 或 XML 形式数据

但 @RestController 只返回对象，对象数据直接以 JSON 或 XML 形式写⼊ HTTP 响应 (Response)中，这种情况属于 RESTful Web服务，这也是⽬前⽇常开发所接触的最常⽤的情况（前后端分离）。

@Controller +@ResponseBody 返回JSON 或 XML 形式数据

如果你需要在Spring4之前开发 RESTful Web服务的话，你需要使⽤ @Controller 并结合 @ResponseBody 注解，也就是说 @Controller + @ResponseBody = @RestController （Spring 4 之后新加的注解）。

@ResponseBody 注解的作⽤是将 Controller 的⽅法返回的对象通过适当的转换器转换为指定的格式之后，写⼊到HTTP 响应(Response)对象的 body 中，通常⽤来返回 JSON 或者 XML 数据，返回 JSON 数据的情况⽐᫾多。

jackson在controller中的运用

导入依赖

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

编写controller层

返回对象字符串：

@Controller
public class JsonTest {
    @RequestMapping(value = "/h2",produces = "application/json;charset=utf-8")
    @ResponseBody
    public String test2() throws JsonProcessingException {
        ObjectMapper mapper=new ObjectMapper();
        User user=new User("yzl是人",15,"xml是猪");
        String s = mapper.writeValueAsString(user);
        return s;
    }
}

返回集合字符串：

    @RequestMapping("/t2")
    public String test2() throws JsonProcessingException {
        ObjectMapper mapper=new ObjectMapper();
        List<User> userList=new ArrayList<User>();
        User user=new User("yzl是人",15,"xml是猪");
        User user1=new User("yzl是人",16,"xml是猪");
        User user2=new User("yzl是人",17,"xml是猪");
        User user3=new User("yzl是人",18,"xml是猪");
        userList.add(user);
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        String s = mapper.writeValueAsString(userList);
        return s;
    }

返回时间字符串：

默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
Jackson 默认是会把时间转成timestamps形式，所以我们需要自定义时间格式SimpleDateFormat

    //返回的是秒数，理由如上
	@RequestMapping("/t3")
    public String test3() throws JsonProcessingException {
        ObjectMapper mapper=new ObjectMapper();
        Date date=new Date();
        String s = mapper.writeValueAsString(date);
        return s;
    }
	//返回的是时间
    @RequestMapping("/t4")
    public String test4() throws JsonProcessingException {
        ObjectMapper mapper=new ObjectMapper();
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        mapper.setDateFormat(simpleDateFormat);
        Date date=new Date();
        String s = mapper.writeValueAsString(date);
        return s;
    }

乱码问题

上述代码如果不加上produces = "application/json;charset=utf-8"会出现乱码。

解决办法：（二通用）

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

@RequestMapping(value = "/h2",produces = "application/json;charset=utf-8")

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

fastjson的如下配置：

<!--  替代处理器映射器和处理器适配器-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>

            <!-- 配置fastjson中实现HttpMessageConverter接口的转换器 -->
            <!-- FastJsonHttpMessageConverter是fastjson中实现了HttpMessageConverter接口的转换器 -->
            <bean id="fastJsonHttpMessageConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <!-- 加入支持的媒体类型：返回contentType -->
                <property name="supportedMediaTypes">
                    <list>
                        <!-- 这里顺序不能写反，一定要先写text/html，否则IE下会出现下载提示 -->
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

fastjson在controller中的运用

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

导入依赖

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

fastjson 三个主要的类：

【JSONObject 代表 json 对象】
- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map 接口并调用接口中的方法完成的。
【JSONArray 代表 json 对象数组】
- 内部是有List接口中的方法来完成操作的。
【JSON 代表 JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

编写controller层

    @RequestMapping("/t5")
    public String test5(){
        List<User> userList=new ArrayList<User>();
        User user=new User("yzl是人",15,"xml是猪");
        User user1=new User("yzl是人",16,"xml是猪");
        User user2=new User("yzl是人",17,"xml是猪");
        User user3=new User("yzl是人",18,"xml是猪");
        userList.add(user);
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(userList);
        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);
        return str1;
    }

Ajax

历史的学习Ajax

ajax是实现前后端分离，最基本的途径和手段。从后端获取数据，渲染此数据下的前端视图。

简介

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。
AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。
就和百度的搜索框一样，不要刷新页面自动能够提示信息

利用AJAX可以做

注册时，输入用户名自动检测用户是否已经存在。
登陆时，提示用户名密码错误
删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除
…等等

入门

纯js原生的ajax可以看这个Ajax
Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。
通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、 XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。
jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery.ajax(...)
	部分参数：	
		url：请求地址
		type：请求方式，GET、POST（1.9.0之后用method）
        headers：请求头
        data：要发送的数据
        contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-wwwform-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 将自动替换 ? 为正确的函数名，以执行回调函数

以上的参数，最常用到的是url、type、data、success、error

简单测试

导入jquery

可以从cdn导入网络链接，或者导入本地的文件

<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
<script src="${pageContext.request.contextPath}/js/jquery-3.1.1.min.js"></script>

编写页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
  <script>
    function a1(){
      $.post({
        url:"${pageContext.request.contextPath}/ajax2",
        data:{'name':$("#txtName").val()},
        success:function (data,status) {
          alert(data);
          alert(status);
        }
      });
    }
  </script>
</head>
<body>
<%--onblur：失去焦点触发事件--%>
用户名:<input type="text" id="txtName" onblur="a1()"/>
</body>
</html>

编写controller验证

@Controller
public class AjaxController {

    @RequestMapping("/ajax1")
    public void test1(String name, HttpServletResponse resp) throws IOException {
        if (name.equals("xxml")){
            resp.getWriter().println("true");
        }else {
            resp.getWriter().println("false");
        }
    }

    @RequestMapping("/ajax2")
    @ResponseBody
    public String test2(String name){
        if (name.equals("xxml")){
            return "true";
        }else {
            return "false";
        }
    }
}

通过f12的Network观察请求

根据集合动态打印数据（demo）

生成实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

编写controller

@RequestMapping("/ajax3")
    @ResponseBody
    public List<User> test3(){
        List<User> list = new ArrayList<User>();
        list.add(new User("yzl1",3,"男"));
        list.add(new User("yzl2",3,"男"));
        list.add(new User("yzl3",3,"男"));
        return list;
    }

编写前端界面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
    <script>
        $(function () {
            $("#btn").click(function () {
                $.post("${pageContext.request.contextPath}/ajax3",function (data) {
                    console.log(data)
                    var html="";
                    for (var 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);
                });
            })
        })
    </script>

</head>
<body>
<input type="button" id="btn" value="获取数据"/>
<table width="80%" align="center">
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
    </tbody>
</table>

注册提示效果(demo)

编写controller

    @RequestMapping("/ajax4")
    @ResponseBody
    public String test4(String name,String pwd){
        String msg = "";
//模拟数据库中存在数据
        if (name!=null){
            if ("admin".equals(name)){
                msg = "OK";
            }else {
                msg = "用户名输入错误";
            }
        }
        if (pwd!=null){
            if ("123456".equals(pwd)){
                msg = "OK";
            }else {
                msg = "密码输入有误";
            }
        }
        return msg;
    }

编写前端界面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ajax</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
    <script>
        function a1() {
            $.post({
                url: "${pageContext.request.contextPath}/ajax4",
                data: {'name': $("#name").val()},
                success: function (data) {
                    if (data.toString() == 'OK') {
                        $("#userInfo").css("color", "green");
                    } else {
                        $("#userInfo").css("color", "red");
                    }
                    $("#userInfo").html(data);
                }
            });
        }

        function a2() {
            $.post({
                url: "${pageContext.request.contextPath}/ajax4",
                data: {'pwd': $("#pwd").val()},
                success: function (data) {
                    if (data.toString() == 'OK') {
                        $("#pwdInfo").css("color", "green");
                    } else {
                        $("#pwdInfo").css("color", "red");
                    }
                    $("#pwdInfo").html(data);
                }
            });
        }
    </script>
</head>
<body>
<p>
    用户名:<input type="text" id="name" onblur="a1()"/>
    <span id="userInfo"></span>
</p>
<p>
    密码:<input type="text" id="pwd" onblur="a2()"/>
    <span id="pwdInfo"></span>
</p>
</body>
</html>

记得处理json乱码问题！

拦截器

概述

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

过滤器和拦截器的区别

①拦截器是基于java的反射机制的，而过滤器是基于函数回调。
　　②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
　　③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
　　④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
　　⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

自定义拦截器

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

编写Interceptor类

public class MyInterceptor implements HandlerInterceptor {
    //在请求处理的方法之前执行
	//如果返回true执行下一个拦截器
	//如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("-----处理前----");
        return true;
    }
	//在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("-----处理后----");
    }
	//在dispatcherServlet处理后执行,做清理工作
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("----清理----");
    }
}

在spring配置文件中配置拦截器

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

编写controller

@RestController
public class InterceptorController {
    @RequestMapping("/int1")
    public String test1(){
        System.out.println("控制器被执行啦");
        return "hello";
    }
}

前端

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

可以观察到preHandle为false时，请求被拦截。为true时一切正常。

验证用户是否登录（demo）

实现思路

有一个登陆页面，需要写一个controller访问页面。
登陆页面有一提交表单的动作。需要在controller中处理。判断用户名密码是否正确。如果正确，向session中写入用户信息。返回登陆成功。
拦截用户请求，判断用户是否登陆。如果用户已经登陆。放行，如果用户未登陆，跳转到登陆页面

代码

编写登录页面index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$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>

编写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";
    }
}

编写一个登录成功的网页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>

编写一个登录页面

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

编写拦截器

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("/jsp/login.jsp").forward(request, response);
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest,
                           HttpServletResponse httpServletResponse, Object o, ModelAndView
                                   modelAndView) throws Exception {
    }

    public void afterCompletion(HttpServletRequest httpServletRequest,
                                HttpServletResponse httpServletResponse, Object o, Exception e) throws
            Exception {
    }
}

在spring配置文件中注册拦截器

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.nanda.interceptor.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

文件的上传和下载

准备工作

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的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自带的文件上传下载，详情请见servlet3.0文件上传下载

文件上传

导入依赖(servlet-api要导入3.0以上的)

<!--文件上传-->
<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>3.1.0</version>
</dependency>

spring文件配置bean

id必须为multipartResolver，不然会报400错误

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

CommonsMultipartFile 的常用方法：

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

编写前端页面

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

编写controller

复杂版：

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

简单板：

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

文件下载

文件下载步骤：

设置 response 响应头
读取文件 – InputStream
写出文件 – OutputStream
执行操作
关闭流（先开后关）

代码：

controller

path和fileName是我们需要设置的

    @RequestMapping(value = "/download")
    public String downloads(HttpServletResponse response, HttpServletRequest
            request) throws Exception {
//要下载的图片地址
        String path = request.getServletContext().getRealPath("/upload");
        String fileName = "狂神说SpringMVC.pdf";
//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;
    }