访问 http://localhost:8080/test2.jsp，成功加载数据

成功实现了数据回显！可以体会一下Ajax的好处！

注册提示效果

我们再测试一个小Demo，思考一下我们平时注册时候，输入框后面的实时提示怎么做到的；如何优化

我们写一个Controller

@RequestMapping("/a3")
// 获取前端name，pwd
public String a3(String name,String pwd){
String msg="";
if (name != null) {
//获取数据库中用户列表比对name，现写死为admin
if ("admin".equals(name)){
msg="OK";
}else {
msg="用户名有误";
}
}
if (pwd != null) {
//获取数据库中用户列表比对pwd，现写死为123456
if ("123456".equals(pwd)){
msg="OK";
}else{
msg="密码错误";
}
}
return msg;
}

前端页面：web 目录下 login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>

<script>  
    function a1(){  
        //Ajax请求,简写和常规  
        <%--$.post("${pageContext.request.contextPath}/a3",function (data))--%>  
        $.post({  
            url:"${pageContext.request.contextPath}/a3",  
            <%--k:name后端  :v获取输出框中的值${"#id选择输入框"}.value--%>  
            data:{"name":$("#name").val()},  
            success:function (data){  
                // console.log(data); 测试成功  
                if (data.toString()==='ok'){  
                    $("#userInfo").css("color","green");  
                }else{  
                    $("#userInfo").css("color","red");  
                }  
                $("#userInfo").html(data);  
            }  
        })  
    }  
    function a2(){  
        /\*$.post("${pageContext.request.contextPath}/a3",function (data){  
            console.log(data);  
        })\*/  
        $.post({  
            url: "${pageContext.request.contextPath}/a3",  
            data: {"pwd":$("#pwd").val()},  
            success:function (data){  
                // console.log(data);  
                if (data.toString()==="ok"){  
                    $("#pwdInfo").css("color","green");  
                }else {  
                    $("#pwdInfo").css("color","red");  
                }  
                $("#pwdInfo").html(data);  
            }  
        })  
    }  
</script>  

用户名：

密码：

【记得处理json乱码问题】
appliacation.xml 中添加：

测试一下效果，动态请求响应，局部刷新，就是如此！

8. 拦截器

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

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

　　数据独立性：Servlet中的是过滤器，而拦截器是SpringMVC框架独有的，独享request和response
　　拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css等式不会拦截的
　　拦截器是基于AOP思想的，和AOP实现是一样的，在application.xml中配置

过滤器

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

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

• 拦截器

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

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

• 那如何实现拦截器呢？

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

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

  2、配置 web.xml 和 resources 目录下的 applicationContext.xml

• web.xml

• 
  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:applicationContext.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>  
      <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>  
      <!--这里必须是/\*，因为我们最开始访问的是 form.jsp-->  
      <url-pattern>/\*</url-pattern>  
  </filter-mapping>

  applicationContext.xml

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

  <context:component-scan base-package="com.kuang.controller"/>
  
  <mvc:default-servlet-handler />  
  <mvc:annotation-driven/>
  
  <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>
  
  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
        id="internalResourceViewResolver">  
      <property name="prefix" value="/WEB-INF/jsp/" />  
      <property name="suffix" value=".jsp" />  
  </bean>

  新建包 com.kuang.controller，配置 Tomcat，project structure —Artifacts 新建 lib 目录导入 jar 包，先确保项目能正确的启动起来！

  3、编写一个拦截器

• package com.kuang.interceptor;

  import org.springframework.web.servlet.HandlerInterceptor;
  import org.springframework.web.servlet.ModelAndView;

  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;

  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的配置文件 applicationContext.xml 中配置拦截器
  如果报了500错，就删掉中文注释

• 
  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.tongda.controller"/>  
  <!--SpringMvc 不处理静态资源，视图解析器不进行过滤，如  .css .js .html-->  
  <mvc:default-servlet-handler/>
  
  <!--  
  支持mvc注解驱动  
      在Spring中一般采用@RequestMapping注解来完成映射关系  
      要想是@RequestMapping注解生效  
      必须向上下文中注册DefaultAnnotationHandlerMapping  
      和一个AnnotationMethodHandlerAdapter实例  
      这两个实例分别在类级别和方法级别处理  
      而annotation-driven配置帮助我们自动完成上述两个实例的注入  
      -->  
  <!--//<mvc:annotation-driven/>-->  
  <!--json乱码配置问题，如果报了500错，就去掉这行中文注释-->  
  <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>
  
  <!--以上的是定死的代码，  
  以下是配置视图解析器，prefix前缀，suffix后缀-->  
  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">  
      <property name="prefix" value="/WEB-INF/jsp/" />  
      <property name="suffix" value=".jsp" />  
  </bean>
  
  <!--过滤静态资源:导入layui时-->  
  <mvc:resources mapping="/layui/\*\*" location="WEB-INF/layui/"/>
  
  <!--拦截器配置-->  
  <mvc:interceptors>  
      <mvc:interceptor>  
          <!--包括这个请求下面的所有的请求、/\*\*-->  
          <mvc:mapping path="/\*\*"/>  
          <!--从哪个类来请求-->  
          <bean class="com.tongda.config.MyInterceptor"/>  
      </mvc:interceptor>  
  </mvc:interceptors>    

  5、编写一个Controller，接收请求

• package com.kuang.controller;

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

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

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

  }

  package com.tongda.controller;

  @RestController
  public class TestController {

  @GetMapping("/t1")  
  public String test(){  
      System.out.println("TestController执行了");  
      return "OK";  
  }

  }

  6、前端 index.jsp

  拦截器测试

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  
  
  
  
  
  
  
  

  
  

  拦截器测试

  
  
  

  7、启动tomcat 测试一下！

  WEB-INF 目录下新建 jsp 目录

  实现思路

  1、有一个登陆页面，需要写一个 controller 访问页面。

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

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

  测试：

  1、编写一个登陆页面 jsp 目录下新建 login.jsp

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  

  登录页面

  ---

  用户名：
  密码：
  

  
  
  

  2、编写一个Controller 处理请求

• package com.kuang.controller;

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

  import javax.servlet.http.HttpSession;

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

  }

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

  @RequestMapping("/main")  
  public String main() {  
      //沒登陸就不等進入首頁  
      return "main";  
  }
  
  @RequestMapping("/goLogin")  
  public String goLogin() {  
      return "login";  
  }
  
  @RequestMapping("/login")  
  public String login(String username, String password, HttpSession session, Model model) {  
      session.setAttribute("username", username);  
      session.setAttribute("password", password);  
      model.addAttribute("username", username);  
      return "main";  
  }
  
  @RequestMapping("/outUser")  
  public String outUser(HttpSession session) {  
      session.removeAttribute("username");  
      session.removeAttribute("password");  
      return "main";  
  }  

  }

  3、编写一个登陆成功的页面，jsp目录下 success.jsp

• <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  
  

  登录成功页面

  ---

  ${user}
  注销
  
  

  4、在 index 页面上测试跳转！启动Tomcat 测试，未登录也可以进入 success 主页！

• <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  
  
  

  首页

  
  

  ---

  
  <%--登录--%>
  登录
  成功页面
  
  

  5、编写用户登录拦截器

• package com.kuang.interceptor;

  public class LoginInterceptor implements HandlerInterceptor {

  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {  
      // 如果是登陆页面则放行,return true;  
      System.out.println("uri: " + request.getRequestURI());  
      if (request.getRequestURI().contains("login")) {  
          return true;  
      }
  HttpSession session = request.getSession();
  
  // 如果用户已登陆也放行  
  if(session.getAttribute("user") != null) {  
      return true;  
  }
  
  // 用户没有登陆跳转到登陆页面,return false;  
  request.getRequestDispatcher("/WEB-INF/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 {
  
  }  

  }

  public class LoginInterceptor implements HandlerInterceptor {
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  HttpSession session = request.getSession();
  request.getRequestURL();
  //URL:http://localhost:8080/springmvc_07_interceptor/user//main
  System.out.println("URL:" + request.getRequestURL());
  //URI:/springmvc_07_interceptor/user//main
  System.out.println("URI:" + request.getRequestURI());

      if (session.getAttribute("username") == null || session.getAttribute("password") == null) {  
          request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);  
      } else if (session.getAttribute("username").equals("admin") && session.getAttribute("password").equals("123456")) {  
          return true;  
      }  
      if (request.getRequestURI().contains("ogin")) {  
          return true;  
      }  
      request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);  
      return false;  
  }  

  }

  6、在 Springmvc 的配置文件 applicationContext.xml 中注册拦截器
  （删掉前面注册的拦截器）

• 
  

  完整

• 
  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.tongda.controller"/>  
  <!--SpringMvc 不处理静态资源，视图解析器不进行过滤，如  .css .js .html-->  
  <mvc:default-servlet-handler/>
  
  <!--  
  支持mvc注解驱动  
      在Spring中一般采用@RequestMapping注解来完成映射关系  
      要想是@RequestMapping注解生效  
      必须向上下文中注册DefaultAnnotationHandlerMapping  
      和一个AnnotationMethodHandlerAdapter实例  
      这两个实例分别在类级别和方法级别处理  
      而annotation-driven配置帮助我们自动完成上述两个实例的注入  
      -->  
  <!--//<mvc:annotation-driven/>-->  
  <!--json乱码配置问题，如果报了500错，就去掉这行中文注释-->  
  <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>
  
  <!--以上的是定死的代码，  
  以下是配置视图解析器，prefix前缀，suffix后缀-->  
  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">  
      <property name="prefix" value="/WEB-INF/jsp/" />  
      <property name="suffix" value=".jsp" />  
  </bean>
  
  <!--过滤静态资源:导入layui时-->  
  <mvc:resources mapping="/layui/\*\*" location="WEB-INF/layui/"/>
  
  <!--拦截器配置-->  
  <mvc:interceptors>  
      <mvc:interceptor>  
          <!--包括这个请求下面的所有的请求、/\*\*-->  
          <!--/\*\*是拦截之后所有的请求，比如/admin/a1/2131-->  
          <mvc:mapping path="/\*\*"/>  
          <!--从哪个类来请求-->  
          <bean class="com.tongda.config.MyInterceptor"/>  
      </mvc:interceptor>  
      <mvc:interceptor>  
          <mvc:mapping path="/user/\*\*"/>  
          <bean class="com.tongda.config.LoginInterceptor"/>  
      </mvc:interceptor>  
  </mvc:interceptors>  

  7、再次重启Tomcat测试！若是没有登录，就无法进入 success 主页！

• 9. 文件上传与下载

• 新建 Module，普通 Maven 项目 ---- springmvc-08-file，添加 web 支持

• 配置 web.xml，配置 resources 目录下的 applicationContext.xml，建好包 com.kuang.controller

• 配置 Tomcat，project structure 的 Artifacts 新建 lib，导入 jar 包

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

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

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

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

• 1、导入文件上传的 jar 包，commons-fileupload ， Maven 会自动帮我们导入他的依赖包 commons-io 包；
  pom.xml

• 
  commons-fileupload commons-fileupload 1.3.3

  
  javax.servlet javax.servlet-api 4.0.1

  2、配置bean：multipartResolver

• 【注意！！！这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误！】

• 　　
  

  
  

  
  
  
  

  CommonsMultipartFile 的 常用方法：

  String getOriginalFilename()：获取上传文件的原名

  InputStream getInputStream()：获取文件流

  void transferTo(File dest)：将上传文件保存到一个目录文件中

• 我们去实际测试一下

  3、编写前端页面 index.jsp

• <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  

  4、Controller

• package com.kuang.controller;

  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.multipart.commons.CommonsMultipartFile;

  import javax.servlet.http.HttpServletRequest;
  import java.io.*;

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

  }

  5、测试上传文件，OK！

  如果报了500错误 class not found，那就把 project structure 的 Artifacts 的 lib 目录，重新导入 jar 包，错误原因是我们新下的 commons-fileupload 还没被发布出去

• * * *

• 第二种方式：更简单

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

  1、编写Controller

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

  //上传路径保存设置：当前绝对路径下的 upload 目录
  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、修改前端 index.jsp 表单提交地址

  3、访问提交测试，OK！

• 文件下载步骤：

  1、设置 response 响应头

  2、读取文件 – InputStream

  3、写出文件 – OutputStream

  4、执行操作

  5、关闭流 （先开后关）

  代码实现：

• @RequestMapping(value="/download")
  public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
  //要下载的文件地址
  String path = request.getServletContext().getRealPath("/upload");
  String fileName = "答辩.txt";

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

  前端 index.jsp