SpringMVC学习笔记（二）

6、数据处理

6.1、处理提交数据

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

提交数据：http://localhost:8000/add?name=lsw

处理方法：

 @RequestMapping("/t1")
    public String test1(String name, Model model){
        //接收前端参数
        System.out.println("接收的参数为："+name);
        //将返回的结果传递给前端
        model.addAttribute("msg", name);
//        跳转视图
        return "test";
    }

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

提交数据：http://localhost:8000/add?username=lsw

处理方法：

 @RequestMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
        System.out.println("接收的参数为："+name);

        model.addAttribute("msg", name);

        return "test";
    }

3、提交一个对象

要求提交的表单域的name属性和属性保持一致，参数使用对象即可

• 1、接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
• 2、假设传递是一个对象类型User，匹配User对象中的字段名

实体类

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

    /**
     * 1、接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
     *2、假设传递是一个对象类型User，匹配User对象中的字段名
     */
    @RequestMapping("/t2")
    public String test2(User user){
        System.out.println(user);
        return "test";
    }

提交数据：http://localhost:8000/add?id=1&name=lsw&age=15

4、ModelMap

@GetMapping("/t3")
public String test3(ModelMap map){
    map.addAttribute("name","name");
    return "test";
}

对比

• Model ：只有寥寥的几个方法只适合用于存储数据，简化新手对于Model对象的操作和理解
• ModelMap：继承了LinkedMap，处理实现自身的一些方法，同样的继承了LinkedMap的方法和特性
• ModelAndView：可以存储数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

80%的时间打好基础，剩下的18%的时间研究框架，2%学好英文

6.2、处理乱码问题

自定义过滤器

过滤器

public class EncodingFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

    }
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest, servletResponse);
    }
    public void destroy() {

    }
}

配置

    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.lsw.filter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

SpringMVC过滤器

<!--    配置SpringMVC的乱码过滤器-->
<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>

7、JSON

前后端分离时代：

• 后端部署后端，提供接口数据；

• ==> JSON ==> javascript对象

• 前端独立部署，负责渲染后端提供的数据

Json 是一种JS对象标记，是一种轻量级的数据交互格式

• 采用完全独立于编程语言的文本格式来存储和表示数据
• 简介和清晰的层次结构使得JSON成为理想的数据交互语言
• 易于人阅读和编写，同时也易于机器的解析和生成，并有效的提升网络的传输效率。

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

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

JSON 键值对是用来保存JavaScript对象的一种方式，和JavaScript对象写法也大同小异，键值对组合中的键名写在前面并用双引号""包裹，使用冒号分割：

{"name":"键值对"}

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

var Obj = {a:'hello',b:'world'};//这是一个JavaScript对象
var json = {"a":"hello","b":"world"};//这是一个json对象
var str1 ='{ "name": "deyuyi", "sex": "man" }';//这是一个json字符串

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"}’

 				//javascript对象
        var user = {
            name:"时倾",
            age:22,
            sex:"男"};
        //将js对象转为json对象
        var json = JSON.stringify(user);
        //将json转换为js对象
        let parse = JSON.parse(json);
        console.log(user)
        console.log(json)
        console.log(parse)

Controller返回JSON数据

Jackson

Jackson——Json解析工具还有阿里巴巴的fastjson

导包

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

使用

@ResponseBody

配合@Controller让方法不会走视图解析器，直接返回一个字符串

@RestController

让整个类中的所有方法都不会走视图解析器

jackson中的ObjectMapper

@Controller
public class UserConcroller {

    @ResponseBody//不会走视图解析器，直接返回一个字符串
    @RequestMapping(value = "j1",produces = "application/json;charset=utf-8")
    public String json_1() throws JsonProcessingException {
        //jackson, ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("时倾",3,"男");

        String s = mapper.writeValueAsString(user);
        return s;
    }
}

解决乱码问题：

produces = "application/json;charset=utf-8"

Json乱码问题统一解决

springmvc-servlet.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>

List列表输出

  @ResponseBody//不会走视图解析器，直接返回一个字符串
    @RequestMapping("/j2")
    public String json_2() throws JsonProcessingException {
        //jackson, ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        List<User> userList = new ArrayList<User>();
        //创建一个对象
        User user1 = new User("时倾",43,"男");
        User user2 = new User("tom",32,"男");
        User user3 = new User("xiao",23,"男");
        User user4 = new User("阿秋",33,"男");
        User user5 = new User("小赖",23,"男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        userList.add(user5);

        String s = mapper.writeValueAsString(userList);
        return s;
    }

输出日期

Java方式

    @ResponseBody
    @RequestMapping("/j3")
    public String json_3() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        Date date = new Date();
//        自定义日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(date);
        String s = mapper.writeValueAsString(format);
        return s;
    }

ObjectMapper方式

    @ResponseBody
    @RequestMapping("/j4")
    public String json_4() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
//        关闭时间戳
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();
        mapper.setDateFormat(sdf);
        //ObjectMapper 时间戳解析后的默认格式为：Timestamp时间戳
        String s = mapper.writeValueAsString(date);
        return s;
    }

封装思想

我们可以将有关ObjectMapper的操作封装到工具类中

public class JsonUtils {

    //只传一个参数时，设置默认格式
    public static String getJson(Object object) throws JsonProcessingException {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String DateFormat) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
      mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        SimpleDateFormat sdf = new SimpleDateFormat(DateFormat);
        mapper.setDateFormat(sdf);
        return mapper.writeValueAsString(object);
    }
}

使用的时候就相对简洁—防止重复造轮子

  @ResponseBody
    @RequestMapping("/j5")
    public String json_5() throws JsonProcessingException {

        Date date = new Date();
        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }

    @ResponseBody//不会走视图解析器，直接返回一个字符串
    @RequestMapping("/j6")
    public String json_6() throws JsonProcessingException {

        List<User> userList = new ArrayList<User>();
        //创建一个对象
        User user1 = new User("时倾",43,"男");
        User user2 = new User("tom",32,"男");
        User user3 = new User("xiao",23,"男");
        User user4 = new User("阿秋",33,"男");
        User user5 = new User("小赖",23,"男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        userList.add(user5);

        return JsonUtils.getJson(userList);
    }

fastjson

导包

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</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字符串之间的相互转化。

        //java对象 转 Json 字符串
        String s1 = JSON.toJSONString(userList);

        //JSON 字符串转 Java对象
        User user = JSON.parseObject(s1, User.class);

        //java对象 转 JSON对象
        JSONObject jsObject = (JSONObject) JSON.toJSON(user);

        //JSON对象 转 Java对象
        User user6 = JSON.toJavaObject(jsObject, User.class);

8、整合SSM

Spring+SpringMVC+Mybatis

8.1、导包

<!--    Junit、数据库驱动、连接池、Servlet、jsp、mybatis、mybatis-spring、Lombok、spring-->
    <dependencies>
<!--        Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
<!--        MySQL驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
<!--        数据库连接池：druid-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>
<!--        Serclet、JSP-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
<!--        Mybatis、Mybatis-spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.5</version>
        </dependency>
<!--        SpringMVC、spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>
<!--        JSON -->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</version>
        </dependency>
    </dependencies>

<!--    静态资源导出问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

8.2、配置文件

database.properties外部连接内容

driver=com.mysql.jdbc.Driver
#mysql8.0需要加时区serverTimezone=Asia/Shanghai
url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=root

mybatis-config.xmlmybatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--mybatis 主配置文件 -->
<configuration>
<!--    配置数据源，交个Spring-->
    <typeAliases>
        <package name="com.lsw.pojo"/>
    </typeAliases>

<!--    注册接口-->
    <mappers>
        <mapper class="com.lsw.dao.BookMapper"/>
    </mappers>
</configuration>

spring配置文件

Dao 层-整合mybatisspring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

<!--    关联数据库配置文件-->
    <context:property-placeholder location="classpath:database.properties"/>
<!--    连接池
        dbcp：半自动化操作，不能自动连接
        c3p0：自动化操作，自动化的加载配置文件，并且可以自动设置到对象中
        druid：德鲁伊
        hikari
-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driver}"/>
        <property name="jdbcUrl" value="${url}"/>
        <property name="user" value="${username}"/>
        <property name="password" value="${password}"/>
<!--        c3p0连接池的私有属性配置-->
<!--        最大连接数，最小连接数-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
<!--        关闭连接后不自动连接commit-->
        <property name="autoCommitOnClose" value="false"/>
<!--        获取连接超时的时间-->
        <property name="checkoutTimeout" value="10000"/>
<!--        当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

<!--    SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        绑定mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

<!--   Spring 配置 Dao接口扫描包 动态的实现了Dao接口可以注入Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--        扫描的Dao包-->
        <property name="basePackage" value="com.lsw.dao"/>
    </bean>

</beans>

连接池
dbcp：半自动化操作，不能自动连接
c3p0：自动化操作，自动化的加载配置文件，并且可以自动设置到对象中
druid：德鲁伊
hikari

Service层整合spring-service.xml

<!--    1、扫描service下的包-->
    <context:component-scan base-package="com.lsw.service"/>

<!--    2、将我们的所有业务类注入到Spring ，可以通过配置或者注解实现-->
    <bean id="BookServiceImpl" class="com.lsw.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

<!--    3、声明式事务配置-->
    <bean id="TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--    4、AOP事务支持-->

mvc整合spring-mvc.xml

<!--    1、注解驱动-->
        <mvc:annotation-driven/>
<!--    2、静态资源驱动-->
        <mvc:default-servlet-handler/>
<!--    3、扫描包 Controller-->
        <context:component-scan base-package="com.lsw.controller"/>
<!--    4、视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB_INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

总文件 applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:spring-dao.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>
</beans>

9、AJAX

异步请求——无需刷新页面便可以请求数据

10、拦截器

SPringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。

过滤器与拦截器的区别：拦截器是AOP思想的具体应用。【面向切面编程】

过滤器

• Servlet规范中的一部分，任何 的Javaweb项目都可以使用。
• 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截。

拦截器

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

10.1、自定义拦截器

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

public class MyInterceptor implements HandlerInterceptor {
    //默认false——不放行，执行下一个拦截器
    //return true ，放行
    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("=========处理后========");
    }

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

拦截器配置

<!--    拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
<!--            /**  这个请求之后的所有请求都会被拦截-->
            <mvc:mapping path="/**"/>
<!--            哪个类过滤请求-->
            <bean class="com.lsw.config.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

10.2、登录拦截器

Controller

@Controller
@RequestMapping("/user")
public class LoginController {
    @RequestMapping("/goMain")
    public String main(){
        return "main";
    }
    @RequestMapping("/goLogin")
    public String login(){
        return "login";
    }
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String password, Model model){
        //把用户的信息存在session中
        session.setAttribute("userLoginInfo",username);
        model.addAttribute("username", username);
        return "main";
    }
    @RequestMapping("/goOut")
    public String goOut(HttpSession session){
        //销毁session
//        session.invalidate();
        //移除信息
        session.removeAttribute("userLoginInfo");
        return "main";
    }
}

拦截器

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        //放行的判断：判断什么情况下登录的
        //在登录页面时放行【跳转】
        if (request.getRequestURI().contains("goLogin")){
            return true;
        }
        //说明我在提交登录【第一次】
        if (request.getRequestURI().contains("login")){
            return true;
        }
        //已经登录了放行
        if (session.getAttribute("userLoginInfo")!=null){
            return true;
        }
        //判断什么情况下没有登录——重定向
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);

        return false;
    }
}

index

 <body>
  <a href="${pageContext.request.contextPath}/user/goLogin">登录</a>
  <a href="${pageContext.request.contextPath}/user/goMain">首页</a>
  </body>

登录界面

<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名：<input type="text" name="username">
    密码  ：<input type="text" name="password">
    <input type="submit" value="提交">
</form>

首页

<h1>首页</h1>
<p style="color: red;">欢迎你！${username}</p>
<a href="${pageContext.request.contextPath}/user/goOut">注销</a>
</body>

11、文件上传

SpringMVC可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认的情况下其不能处理文件的上传工作。

使用文件上传功能必须在上下文中配置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>

导包

  <dependencies>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
    </dependencies>

配置

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

文件上传实现

@RestController
public class FileController {

    @RequestMapping("/upload")
    public String upload(@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);

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

        InputStream is = file.getInputStream();
        FileOutputStream 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("/download")
    public String download(HttpServletResponse response, HttpServletRequest request) throws IOException {
        //要下载的图片地址
        String path = request.getServletContext().getRealPath("/upload");
        String fileName = "前后端分离.png";
        //设置response响应头
        response.reset();//设置页面不缓存，情看婆娘个buffer
        response.setCharacterEncoding("utf-8");//设置字符集
        response.setContentType("multipart/for-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;
        while ((index = input.read(buff))!=-1){
            out.write(buff,0,index);
            out.flush();
        }
        out.close();
        input.close();
        return "OK";
    }