Spring MVC详解-Plus（IDEA版学习笔记）

朱雀 2023-01-04 14:51 141阅读 0赞

> “在人生中只有曲线前进的快乐，没有直线上升的成功。只有珍惜今天，才会有美好的明天；只有把握住今天，才会有更辉煌的明天。”  
> 你好，我是梦阳辰！期待与你相遇！

### 文章目录 ###

*  01.整合SSM
 *   *  mybatis整合
     *  整合spring
     *  整合Spring MVC
     *  编写代码和测试
 *  02.Spring MVC 拦截器
 *  03.Spring MVC的上传与下载
 *   *  文件上传
     *  文件下载
 *  04.文件传输原理（扩展）
 *  05.javaWeb实现文件上传（扩展）

# 01.整合SSM #

创建数据库ssmhello

DROP TABLE IF EXISTS `books`;
    
    CREATE TABLE `books` (
    `bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
    `bookName` VARCHAR(100) NOT NULL COMMENT '书名',
    `bookCounts` INT(11) NOT NULL COMMENT '数量',
    `detail` VARCHAR(200) NOT NULL COMMENT '描述',
    KEY `bookID` (`bookID`)
    ) ENGINE=INNODB DEFAULT CHARSET=utf8
    
    INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
    (1,'Java',80,'Java核心技术卷'),
    (2,'MySQL',30,'必知必会'),
    (3,'Linux',98,'鸟哥的linux私房菜');

**搭建环境**  
1、新建一Maven项目

2.导入依赖

<dependencies>
       
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.11</version>
       </dependency>
       
     <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.48</version>
        </dependency>
       
       <dependency>
           <groupId>com.mchange</groupId>
           <artifactId>c3p0</artifactId>
           <version>0.9.5.2</version>
       </dependency>
    
       
       <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>4.0.1</version>
        </dependency>
       <dependency>
           <groupId>javax.servlet.jsp</groupId>
           <artifactId>jsp-api</artifactId>
           <version>2.2</version>
       </dependency>
       <dependency>
           <groupId>javax.servlet</groupId>
           <artifactId>jstl</artifactId>
           <version>1.2</version>
       </dependency>
    
       
       <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.6</version>
        </dependency>
        
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    
    
       
     
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.3.2</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.3.2</version>
        </dependency>
    
      
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.6</version>
        </dependency>
    </dependencies>

资源过滤设置：

<build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include> <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include> <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
       </resources>
    </build>

**配置lib.**

## mybatis整合 ##

**1.数据库配置文件**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/ssmhello?useSSL=false&useUnicode=true&characterEncoding=utf8
    jdbc.username=root
    jdbc.password=123456

**2.Mybatis核心配置文件**

<?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">
    <configuration>
    
        <typeAliases>
            <package name="com.mengyangchen.pojo"/>
        </typeAliases>
        <mappers>
            <mapper resource="com/mengyangchen/dao/BookMapper.xml"/>
        </mappers>
    
    
    </configuration>

**3.编写pojo的实体类**

package com.mengyangchen.pojo;
    
    public class Books { 
        private int bookID;
        private String bookName;
        private int bookCounts;
        private String detail;
    
        public Books() { 
        }
    
        public Books(int bookID, String bookName, int bookCounts, String detail) { 
            this.bookID = bookID;
            this.bookName = bookName;
            this.bookCounts = bookCounts;
            this.detail = detail;
        }
    
        public int getBookID() { 
            return bookID;
        }
    
        public void setBookID(int bookID) { 
            this.bookID = bookID;
        }
    
        public String getBookName() { 
            return bookName;
        }
    
        public void setBookName(String bookName) { 
            this.bookName = bookName;
        }
    
        public int getBookCounts() { 
            return bookCounts;
        }
    
        public void setBookCounts(int bookCounts) { 
            this.bookCounts = bookCounts;
        }
    
        public String getDetail() { 
            return detail;
        }
    
        public void setDetail(String detail) { 
            this.detail = detail;
        }
    
        @Override
        public String toString() { 
            return "Books{" +
                    "bookID=" + bookID +
                    ", bookName='" + bookName + '\'' +
                    ", bookCounts=" + bookCounts +
                    ", detail='" + detail + '\'' +
                    '}';
        }
    }

**4.编写dao层的Mapper接口**

package com.mengyangchen.dao;
    
    import com.mengyangchen.pojo.Books;
    
    import java.util.List;
    
    public interface BookMapper { 
    
        //增加一个Book
        int addBook(Books book);
    
        //根据id删除一个Book
        int deleteBookById(int id);
    
        //更新Book
        int updateBook(Books books);
    
        //根据id查询,返回一个Book
        Books queryBookById(int id);
    
        //查询全部Book,返回list集合
        List<Books> queryAllBook();
    }

**5.编写dao层接口对应的Mapper.xml文件**

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="com.mengyangchen.dao.BookMapper">
    
        
        <insert id="addBook" parameterType="Books">
          insert into ssmhello.books(bookName,bookCounts,detail)
          values (#{ bookName}, #{ bookCounts}, #{ detail})
       </insert>
    
        
        <delete id="deleteBookById" parameterType="int">
          delete from ssmhello.books where bookID=#{ bookID}
       </delete>
    
        
        <update id="updateBook" parameterType="Books">
          update ssmhello.books
          set bookName = #{ bookName},bookCounts = #{ bookCounts},detail = #{ detail}
          where bookID = #{ bookID}
       </update>
    
        
        <select id="queryBookById" resultType="Books">
          select * from ssmhello.books
          where bookID = #{ bookID}
       </select>
    
        
        <select id="queryAllBook" resultType="Books">
          SELECT * from ssmhello.books
       </select>
    
    </mapper>

**6.编写Service层的接口**

package com.mengyangchen.service;
    
    import com.mengyangchen.pojo.Books;
    
    import java.util.List;
    
    /** * BookService:底下需要去实现,调用dao层 */
    public interface BookService { 
        //增加一个Book
        int addBook(Books book);
        //根据id删除一个Book
        int deleteBookById(int id);
        //更新Book
        int updateBook(Books books);
        //根据id查询,返回一个Book
        Books queryBookById(int id);
        //查询全部Book,返回list集合
        List<Books> queryAllBook();
    }

**7.编写Service层的实现类**

package com.mengyangchen.service;
    
    import com.mengyangchen.dao.BookMapper;
    import com.mengyangchen.pojo.Books;
    
    import java.util.List;
    
    public class BookServiceImpl implements BookService{ 
    
        //调用dao层的操作，设置一个set接口，方便Spring管理
        private BookMapper bookMapper;
    
        public void setBookMapper(BookMapper bookMapper) { 
            this.bookMapper = bookMapper;
        }
        @Override
        public int addBook(Books book) { 
            return bookMapper.addBook(book);
        }
    
        @Override
        public int deleteBookById(int id) { 
            return bookMapper.deleteBookById(id);
        }
    
        @Override
        public int updateBook(Books books) { 
            return bookMapper.updateBook(books);
        }
    
        @Override
        public Books queryBookById(int id) { 
            return bookMapper.queryBookById(id);
        }
    
        @Override
        public List<Books> queryAllBook() { 
            return bookMapper.queryAllBook();
        }
    }

## 整合spring ##

**1.整合mybatis的相关配置文件（spring-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
           http://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"/>
    
        
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            
            <property name="driverClass" value="${jdbc.driver}"/>
            <property name="jdbcUrl" value="${jdbc.url}"/>
            <property name="user" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
    
            
            <property name="maxPoolSize" value="30"/>
            <property name="minPoolSize" value="10"/>
            
            <property name="autoCommitOnClose" value="false"/>
            
            <property name="checkoutTimeout" value="10000"/>
            
            <property name="acquireRetryAttempts" value="2"/>
        </bean>
    
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            <property name="dataSource" ref="dataSource"/>
            
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
        </bean>
    
        
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            
            <property name="basePackage" value="com.mengyangchen.dao"/>
        </bean>
    
    </beans>

**2.spring整合service层（spring-service.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:tx="http://www.springframework.org/schema/tx"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <context:component-scan base-package="com.mengyangchen.service" />
    
        
        <bean id="BookServiceImpl" class="com.mengyangchen.service.BookServiceImpl">
            <property name="bookMapper" ref="bookMapper"/>
        </bean>
    
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
        
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            
            
            <tx:attributes>
                <tx:method name="*"/>
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            <aop:pointcut id="txPointCut" expression="execution(* com.mengyangchen.dao.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>
    
    
    
    </beans>

## 整合Spring MVC ##

**1.配置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">
    
        
        <servlet>
            <servlet-name>DispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                <param-name>contextConfigLocation</param-name>
                
                <param-value>classpath:applicationContext.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>DispatcherServlet</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    
        
        <filter>
            <filter-name>encodingFilter</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>encodingFilter</filter-name>
            <url-pattern>/*</url-pattern> </filter-mapping>  <session-config> <session-timeout>15</session-timeout> </session-config> </web-app>

**2.配置spring-mvc.xml**

**3.spring整合配置文件（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
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <import resource="spring-dao.xml"/>
        <import resource="spring-service.xml"/>
        <import resource="spring-mvc.xml"/>
    </beans>

## 编写代码和测试 ##

**1.编写controller层**

package com.mengyangchen.controller;
    
    import com.mengyangchen.pojo.Books;
    import com.mengyangchen.service.BookService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import java.util.List;
    
    @Controller
    @RequestMapping("/book")
    public class BookController { 
        @Autowired
        @Qualifier("BookServiceImpl")
        private BookService bookService;
    
        /*查询书籍*/
        @RequestMapping("/allBook")
        public String list(Model model) { 
            List<Books> list = bookService.queryAllBook();
            model.addAttribute("list", list);
            return "allBook";
        }
    
        /*跳转到添加书籍页面*/
        @RequestMapping("/toAddBook")
        public String toAddPaper() { 
            return "addBook";
        }
    
        /*添加书籍*/
        @RequestMapping("/addBook")
        public String addPaper(Books books) { 
            System.out.println(books);
            bookService.addBook(books);
            return "redirect:/book/allBook";
        }
    
       /*跳转到更新书籍页面*/
        @RequestMapping("/toUpdateBook")
        public String toUpdateBook(Model model, int id) { 
            Books books = bookService.queryBookById(id);
            System.out.println(books);
            model.addAttribute("book",books );
            return "updateBook";
        }
    
        /*修改书籍*/
        @RequestMapping("/updateBook")
        public String updateBook(Model model, Books book) { 
            System.out.println(book);
            bookService.updateBook(book);
            Books books = bookService.queryBookById(book.getBookID());
            model.addAttribute("books", books);
            return "redirect:/book/allBook";
        }
    
        /*删除书籍*/
        @RequestMapping("/del/{bookId}")
        public String deleteBook(@PathVariable("bookId") int id) { 
            bookService.deleteBookById(id);
            return "redirect:/book/allBook";
        }
    }

**2.编写首页index.jsp**

<%--
      Created by IntelliJ IDEA.
      User: MengYangChen
      Date: 2021/1/11
      Time: 20:26
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>$Title$</title>
        <style type="text/css">
          a { 
            text-decoration: none;
            color: black;
            font-size: 18px;
          }
          h3 { 
            width: 180px;
            height: 38px;
            margin: 100px auto;
            text-align: center;
            line-height: 38px;
            background: deepskyblue;
            border-radius: 4px;
          }
        </style>
      </head>
      <body>
      <h3>
        <a href="${pageContext.request.contextPath}/book/allBook">点击进入列表页</a>
      </h3>
      </body>
    </html>

**3.编写allBooke页面**

<%--
      Created by IntelliJ IDEA.
      User: MengYangChen
      Date: 2021/1/11
      Time: 21:18
      To change this template use File | Settings | File Templates.
    --%>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>书籍列表</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        
        <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    
    <div class="container">
    
        <div class="row clearfix">
            <div class="col-md-12 column">
                <div class="page-header">
                    <h1>
                        <small>书籍列表 —— 显示所有书籍</small>
                    </h1>
                </div>
            </div>
        </div>
    
        <div class="row">
            <div class="col-md-4 column">
                <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增</a>
            </div>
        </div>
    
        <div class="row clearfix">
            <div class="col-md-12 column">
                <table class="table table-hover table-striped">
                    <thead>
                    <tr>
                        <th>书籍编号</th>
                        <th>书籍名字</th>
                        <th>书籍数量</th>
                        <th>书籍详情</th>
                        <th>操作</th>
                    </tr>
                    </thead>
    
                    <tbody>
                    <c:forEach var="book" items="${requestScope.get('list')}">
                        <tr>
                            <td>${ book.getBookID()}</td>
                            <td>${ book.getBookName()}</td>
                            <td>${ book.getBookCounts()}</td>
                            <td>${ book.getDetail()}</td>
                            <td>
                                <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">更改</a> |
                                <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                            </td>
                        </tr>
                    </c:forEach>
                    </tbody>
                </table>
            </div>
        </div>
    </div>
    
    </body>
    </html>

**4.编写addBook.jsp页面**

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    
    <html>
    <head>
        <title>新增书籍</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        
        <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    <div class="container">
    
        <div class="row clearfix">
            <div class="col-md-12 column">
                <div class="page-header">
                    <h1>
                        <small>新增书籍</small>
                    </h1>
                </div>
            </div>
        </div>
        <form action="${pageContext.request.contextPath}/book/addBook" method="post">
            书籍名称：<input type="text" name="bookName"><br><br><br>
            书籍数量：<input type="text" name="bookCounts"><br><br><br>
            书籍详情：<input type="text" name="detail"><br><br><br>
            <input type="submit" value="添加">
        </form>
    
    </div>

**5.编写updateBook.jsp页面**

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>修改信息</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        
        <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    <div class="container">
    
        <div class="row clearfix">
            <div class="col-md-12 column">
                <div class="page-header">
                    <h1>
                        <small>修改信息</small>
                    </h1>
                </div>
            </div>
        </div>
    
        <form action="${pageContext.request.contextPath}/book/updateBook" method="post">
            <input type="hidden" name="bookID" value="${book.getBookID()}"/>
            书籍名称：<input type="text" name="bookName" value="${book.getBookName()}"/>
            书籍数量：<input type="text" name="bookCounts" value="${book.getBookCounts()}"/>
            书籍详情：<input type="text" name="detail" value="${book.getDetail() }"/>
            <input type="submit" value="提交"/>
        </form>
    
    </div>
    
    </body>
    </html>

**项目目录：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70]  
**结果：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 1]

# 02.Spring MVC 拦截器 #

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

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

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

**过滤器**

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

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

**拦截器**

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

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

**在上面ssm架构练习的基础上编写一个拦截器**

**1.编写一个拦截器：**

package com.mengyangchen.config;
    
    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("------------清理------------");
        }
    
    }

**2.在spring-mvc.xml文件中配置拦截器**

<mvc:interceptors>
            <mvc:interceptor>
                   <mvc:mapping path="/**"/>  <bean class="com.mengyangchen.config.MyInterceptor"/> </mvc:interceptor> </mvc:interceptors>

**3.编写一个Controller，接收请求**

package com.mengyangchen.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";//返回的是字符串
        }
    }

**4.在首页中添加测试**

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20210112202151266.png]  
**扩展（登录验证）**

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.xml中注册拦截器

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

# 03.Spring MVC的上传与下载 #

## 文件上传 ##

文件上传是项目开发中最常见的功能之一 ,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包**  
导入文件上传的jar包，commons-fileupload ， Maven会自动帮我们导入他的依赖包 commons-io包；

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

2.配置lib  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 3]  
**3.配置bean：multipartResolver（spring-mvc.xml)**

<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
       
       <property name="defaultEncoding" value="utf-8"/>
       
       <property name="maxUploadSize" value="10485760"/>
       <property name="maxInMemorySize" value="40960"/>
    </bean>

**CommonsMultipartFile的常用方法：**

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

InputStream getInputStream()：获取文件流

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

**4.编写前端页面代码**

**5.新建控制类**

package com.mengyangchen.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";
        }
    }

**使用第二种方式：**  
采用file.Transto 来保存上传的文件  
修改表单地址即可

/* * 采用file.Transto 来保存上传的文件 */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException { 
    
       //上传路径保存设置
       String path = request.getServletContext().getRealPath("/upload");
       File realPath = new File(path);
       if (!realPath.exists()){ 
           realPath.mkdir();
      }
       //上传文件地址
       System.out.println("上传文件保存地址："+realPath);
    
       //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
       file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));
    
       return "redirect:/index.jsp";
    }

上传成功！  
![在这里插入图片描述][20210112211300329.png]

## 文件下载 ##

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 = "1.png";
    
            //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;
        }

前端：

成功！

# 04.文件传输原理（扩展） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 4]  
一般选择采用apache的开源工具common-fileupload这个文件上传组件。

common-fileupload是依赖于comon-io这个包的，所以还需要下载这个包。

1.为保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF目录下。

2.为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名

3.要限制上传文件的最大值。

4.可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法。

**需要用到的类详解**  
ServletFileUpload负责处理上传的文件数据,并将表单中每个输入项封装成一个Fileltem对象，在使用ServletFileUpload对象解析请求时需要DiskFiletemFactory对象。所以，我们需要在进行解析工作前构造好DiskFileltemFactory对象，通过ServletFileUJpload对象的构造方法或setFileltemFactory()方法设置ServletFileUpload对象的fileltemFactory属性。

get:上传文件大小有限制。

post:上传文件大小没有限制。

# 05.javaWeb实现文件上传（扩展） #

**FileSerlvet类**

import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    import java.util.UUID;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.commons.fileupload.FileItem;
    import org.apache.commons.fileupload.FileUploadException;
    import org.apache.commons.fileupload.ProgressListener;
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;
    
    /** * Servlet implementation class FileSerlvet */
    public class FileSerlvet extends HttpServlet { 
    	private static final long serialVersionUID = 1L;
    
    	/** * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse * response) */
    	protected void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException { 
    		// TODO Auto-generated method stub
    		// response.getWriter().append("Served at: ").append(request.getContextPath());
    		
    		// 判断上传的文件普通表单还是带文件的表单
    		if (!ServletFileUpload.isMultipartContent(request)) { 
    			return;//终止方法运行,说明这是一个普通的表单,直接返回
    		}
    	    //创建上传文件的保存路径,建议在WEB-INF路径下,安全,用户无法直接访间上传的文件;
    	    String uploadPath =this.getServletContext().getRealPath("/WEB-INF/upload");
    	    File uploadFile = new File(uploadPath);
    	    if (!uploadFile.exists()){ 
    	    uploadFile.mkdir(); //创建这个月录
    	    }
    		
    		// 创建上传文件的保存路径，建议在WEB-INF路径下，安全，用户无法直接访问上传的文件
    		String tmpPath = this.getServletContext().getRealPath("/WEB-INF/tmp");
    		File file = new File(tmpPath);
    		if (!file.exists()) { 
    			file.mkdir();//创建临时目录
    		}
    
    		// 处理上传的文件,一般都需要通过流来获取,我们可以使用 request, getInputstream(),原生态的文件上传流获取,十分麻烦
    		// 但是我们都建议使用 Apache的文件上传组件来实现, common-fileupload,它需要旅 commons-io组件;
    		try { 
    			// 创建DiskFileItemFactory对象，处理文件路径或者大小限制
    			DiskFileItemFactory factory = getDiskFileItemFactory(file);
    			/* * //通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件 factory.setSizeThreshold(1024 * * 1024); //缓存区大小为1M factory.setRepository (file);//临时目录的保存目录,需要一个File */
    
    			// 2、获取ServletFileUpload
    			ServletFileUpload upload = getServletFileUpload(factory);
    
    			// 3、处理上传文件
    			// 把前端请求解析，封装成FileItem对象，需要从ServletFileUpload对象中获取
    			String msg = uploadParseRequest(upload, request, uploadPath);
    			
    			// Servlet请求转发消息
    			System.out.println(msg);
    			if(msg == "文件上传成功!") { 
    				// Servlet请求转发消息
    				request.setAttribute("msg",msg);
    				request.getRequestDispatcher("info.jsp").forward(request, response);
    			}else { 
    				msg ="请上传文件";
    				request.setAttribute("msg",msg);
    				request.getRequestDispatcher("info.jsp").forward(request, response);
    			}
    
    		} catch (FileUploadException e) { 
    			// TODO 自动生成的 catch 块
    			e.printStackTrace();
    		}
    	}
    
    	public static DiskFileItemFactory getDiskFileItemFactory(File file) { 
    		DiskFileItemFactory factory = new DiskFileItemFactory();
    		// 通过这个工厂设置一个缓冲区,当上传的文件大于这个缓冲区的时候,将他放到临时文件中;
    		factory.setSizeThreshold(1024 * 1024);// 缓冲区大小为1M
    		factory.setRepository(file);// 临时目录的保存目录,需要一个file
    		return factory;
    	}
    
    	public static ServletFileUpload getServletFileUpload(DiskFileItemFactory factory) { 
    		ServletFileUpload upload = new ServletFileUpload(factory);
    		// 监听长传进度
    		upload.setProgressListener(new ProgressListener() { 
    
    			// pBYtesRead:已读取到的文件大小
    			// pContextLength:文件大小
    			public void update(long pBytesRead, long pContentLength, int pItems) { 
    				System.out.println("总大小：" + pContentLength + "已上传：" + pBytesRead);
    			}
    		});
    
    		// 处理乱码问题
    		upload.setHeaderEncoding("UTF-8");
    		// 设置单个文件的最大值
    		upload.setFileSizeMax(1024 * 1024 * 10);
    		// 设置总共能够上传文件的大小
    		// 1024 = 1kb * 1024 = 1M * 10 = 10м
    
    		return upload;
    	}
    
    	public static String uploadParseRequest(ServletFileUpload upload, HttpServletRequest request, String uploadPath)
    			throws FileUploadException, IOException { 
    
    		String msg = "";
    		
    		// 把前端请求解析，封装成FileItem对象
    		List<FileItem> fileItems = upload.parseRequest(request);
    		for (FileItem fileItem : fileItems) { 
    			if (fileItem.isFormField()) { // 判断上传的文件是普通的表单还是带文件的表单
    				// getFieldName指的是前端表单控件的name;
    				String name = fileItem.getFieldName();
    				String value = fileItem.getString("UTF-8"); // 处理乱码
    				System.out.println(name + ": " + value);
    			} else { // 判断它是上传的文件
    				
    				// ============处理文件==============
    
    				// 拿到文件名
    				String uploadFileName = fileItem.getName();
    				System.out.println("上传的文件名: " + uploadFileName);
    				if (uploadFileName.trim().equals("") || uploadFileName == null) { 
    					continue;
    				}
    
    				// 获得上传的文件名/images/girl/paojie.png
    				String fileName = uploadFileName.substring(uploadFileName.lastIndexOf("/") + 1);
    				// 获得文件的后缀名
    				String fileExtName = uploadFileName.substring(uploadFileName.lastIndexOf(".") + 1);
    
    				/* * 如果文件后缀名fileExtName不是我们所需要的 就直按return.不处理,告诉用户文件类型不对。 */
    
    				System.out.println("文件信息[件名: " + fileName + " ---文件类型" + fileExtName + "]");
    				// 可以使用UID（唯一识别的通用码),保证文件名唯
    				// 0UID. randomUUID(),随机生一个唯一识别的通用码;
    				String uuidPath = UUID.randomUUID().toString();
    				
    				// ================处理文件完毕==============
    
    				// 存到哪? uploadPath
    				// 文件真实存在的路径realPath
    				String realPath = uploadPath + "/" + uuidPath;
    				// 给每个文件创建一个对应的文件夹
    				File realPathFile = new File(realPath);
    				if (!realPathFile.exists()) { 
    					realPathFile.mkdir();
    				}
    				// ==============存放地址完毕==============
    				
    				
    				// 获得文件上传的流
    				InputStream inputStream = fileItem.getInputStream();
    				// 创建一个文件输出流
    				// realPath =真实的文件夹;
    				// 差了一个文件;加上翰出文件的名产"/"+uuidFileName
    				FileOutputStream fos = new FileOutputStream(realPath + "/" + fileName);
    
    				// 创建一个缓冲区
    				byte[] buffer = new byte[1024 * 1024];
    				// 判断是否读取完毕
    				int len = 0;
    				// 如果大于0说明还存在数据;
    				while ((len = inputStream.read(buffer)) > 0) { 
    					fos.write(buffer, 0, len);
    				}
    				// 关闭流
    				fos.close();
    				inputStream.close();
    				
    				msg = "文件上传成功!";
    				fileItem.delete(); // 上传成功,清除临时文件
    				//=============文件传输完成=============
    			}
    		}
    		return msg;
    
    	}
    }

**注册xml:**

<servlet>
      	<servlet-name>upload</servlet-name>
      	<servlet-class>com.mengyangchen.FileSerlvet</servlet-class>
      </servlet>
      <servlet-mapping>
     <servlet-name>upload</servlet-name>
     <url-pattern>/upload.do</url-pattern>

**导入依赖：**

<dependency>
    			<groupId>commons-fileupload</groupId>
    			<artifactId>commons-fileupload</artifactId>
    			<version>1.4</version>
    		</dependency>
    	
    		<dependency>
    			<groupId>commons-io</groupId>
    			<artifactId>commons-io</artifactId>
    			<version>2.6</version>
    		</dependency>

**index.jsp:**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    	<body>
    		<%--
    		GET：上传文件大小有限制
    		POST：上传文件大小没有限制
    		 ${ pageContext.request.contextPath}
    		 --%>
    		<form action="upload.do" enctype="multipart/form-data"  method="post">
    			上传用户：<input type="text" name="username"><br/>
    			<P><input type="file" name="file1"></P>
    			<P><input type="file" name="file1"></P>
    			<P><input type="submit" value="提交"> | <input type="reset"></P>
    		</form>
    	</body>
    </html>

info.jsp

<%@ page language="java" contentType="text/html;charset=UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <title>Insert title here</title>
    </head>
    <body>
    
    <%=request.getAttribute("msg")%>
    
    </body>
    </html>

> Great minds have purpose, others have wishes.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70]: /images/20221119/7edcea4bbf1242a887c14b33e267bfec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210112145132789.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210112201805881.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210112202151266.png]: https://img-blog.csdnimg.cn/20210112202151266.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210112203841474.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210112211300329.png]: https://img-blog.csdnimg.cn/20210112211300329.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210112213728368.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210113222142418.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70#pic_center