1. 初识Spring MVC

1.1 什么是Spring MVC

Spring MVC是Spring Framework的一部分，是基于 Java 实现 MVC 的轻量级 Web 框架。
Spring的 web 框架围绕 DispatcherServlet [ 调度Servlet ] 设计，DispatcherServlet 的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；

1.2 前端控制器

SpringMVC的原理如下图所示：

Spring MVC - 图1

执行原理图
Spring MVC - 图2

  1. 用户发送请求至前端控制器 DispatcherServlet。
  2. DispatcherServlet 收到请求调用处理器映射器 HandlerMapping。
  3. 处理器映射器根据请求 url 找到具体的处理器，生成处理器执行链 HandlerExecutionChain(包括处理器对象和处理器拦截器)一并返回给 DispatcherServlet。
  4. DispatcherServlet 根据处理器 Handler 获取处理器适配器 HandlerAdapter 执行处理一系列的操作，如：参数封装，数据格式转换，数据验证等操作。
  5. 执行处理器 Handler(Controller，也叫页面控制器)。
  6. Handler 执行完成返回 ModelAndView。
  7. HandlerAdapter 将 Handler 执行结果 ModelAndView 返回到 DispatcherServlet
  8. DispatcherServlet 将 ModelAndView 传给 ViewReslover 视图解析器。
  9. ViewReslover 解析后返回具体 View
  10. DispatcherServlet 对 View 进行渲染视图（即将模型数据 model 填充至视图中）。
  11. DispatcherServlet 响应用户，将 View 最终视图呈现给用户。

1.3 快速上手

1、导入相关依赖；

  1. <dependencies>
  2.     <!-- jackson -->
  3.     <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
  4.     <dependency>
  5.         <groupId>com.fasterxml.jackson.core</groupId>
  6.         <artifactId>jackson-databind</artifactId>
  7.         <version>2.9.8</version>
  8.     </dependency>
  10.     <dependency>
  11.         <groupId>org.springframework</groupId>
  12.         <artifactId>spring-webmvc</artifactId>
  13.         <version>5.2.5.RELEASE</version>
  14.     </dependency>
  16.     <dependency>
  17.         <groupId>org.projectlombok</groupId>
  18.         <artifactId>lombok</artifactId>
  19.         <version>1.18.12</version>
  20.     </dependency>
  22.     <!-- servlet -->
  23.     <dependency>
  24.         <groupId>jstl</groupId>
  25.         <artifactId>jstl</artifactId>
  26.         <version>1.2</version>
  27.     </dependency>
  28.     <dependency>
  29.         <groupId>javax.servlet</groupId>
  30.         <artifactId>javax.servlet-api</artifactId>
  31.         <version>4.0.0</version>
  32.     </dependency>
  33.     <!-- 实体类简写 -->
  34.     <dependency>
  35.         <groupId>org.projectlombok</groupId>
  36.         <artifactId>lombok</artifactId>
  37.         <version>1.18.12</version>
  38.     </dependency>
  39. </dependencies>
  41. <build>
  42.     <resources>
  43.         <resource>
  44.             <directory>src/main/java</directory>
  45.             <includes>
  46.                 <include>**/*.properties</include>
  47.                 <include>**/*.xml</include>
  48.             </includes>
  49.             <filtering>false</filtering>
  50.         </resource>
  51.         <resource>
  52.             <directory>src/main/resources</directory>
  53.             <includes>
  54.                 <include>**/*.properties</include>
  55.                 <include>**/*.xml</include>
  56.             </includes>
  57.             <filtering>false</filtering>
  58.         </resource>
  59.     </resources>
  60. </build>

2、配置 web.xml 文件；

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  7.     <!--1.注册servlet-->
  8.     <servlet>
  9.         <servlet-name>SpringMVC</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
  12.         <init-param>
  13.             <param-name>contextConfigLocation</param-name>
  14.             <param-value>classpath:spring-servlet.xml</param-value>
  15.         </init-param>
  16.         <!-- 启动顺序，数字越小，启动越早 -->
  17.         <load-on-startup>1</load-on-startup>
  18.     </servlet>
  20.     <!--所有请求都会被springmvc拦截 -->
  21.     <servlet-mapping>
  22.         <servlet-name>SpringMVC</servlet-name>
  23.         <url-pattern>/</url-pattern>
  24.     </servlet-mapping>
  26. </web-app>

/ 和 /* 的区别：

  • /：不会匹配到.jsp， 只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类 。
  • /：会匹配 .jsp，会出现返回 jsp视图 时再次进入 spring 的 DispatcherServlet 类，导致找不到对应的 controller 所以报404错。

3、配置 spring-config.xml 配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd
  8.        http://www.springframework.org/schema/context
  9.        https://www.springframework.org/schema/context/spring-context.xsd
  10.        http://www.springframework.org/schema/mvc
  11.        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  13.     <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
  14.     <context:component-scan base-package="com.xuwei.controller"/>
  15.     <!-- 让Spring MVC不处理静态资源 -->
  16.     <mvc:default-servlet-handler />
  17.     <!--
  18.     支持mvc注解驱动
  19.         在spring中一般采用@RequestMapping注解来完成映射关系
  20.         要想使@RequestMapping注解生效
  21.         必须向上下文中注册DefaultAnnotationHandlerMapping
  22.         和一个AnnotationMethodHandlerAdapter实例
  23.         这两个实例分别在类级别和方法级别处理。
  24.         而annotation-driven配置帮助我们自动完成上述两个实例的注入。
  25.      -->
  26.     <mvc:annotation-driven />
  28.     <!-- 视图解析器 -->
  29.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
  30.           id="internalResourceViewResolver">
  31.         <!-- 前缀 -->
  32.         <property name="prefix" value="/WEB-INF/jsp/" />
  33.         <!-- 后缀 -->
  34.         <property name="suffix" value=".jsp" />
  35.     </bean>
  37. </beans>

注意：在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

4、创建Controller，编写一个 Java 控制类：com.xuwei.controller.HelloController , 注意编码规范

  1. @Controller
  2. @RequestMapping("/HelloController")
  3. public class HelloController {
  5.     //真实访问地址 : 项目名/HelloController/hello
  6.     @RequestMapping("/hello")
  7.     public String sayHello(Model model){
  8.         //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
  9.         model.addAttribute("msg","hello,SpringMVC");
  10.         //web-inf/jsp/hello.jsp
  11.         return "hello";
  12.     }
  13. }
  • @Controller 是为了让 Spring IOC 容器初始化时自动扫描到；
  • @RequestMapping 是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是 /HelloController/hello；
  • 方法中声明 Model 类型的参数是为了把 Action 中的数据带到视图中；
  • 方法返回的结果是视图的名称 hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

5、创建视图层，在WEB-INF/ jsp 目录中创建 hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；也可以通过EL表示取出Model中存放的值，或者对象；

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.     <head>
  4.         <title>SpringMVC</title>
  5.     </head>
  6.     <body>
  7.         ${msg}
  8.     </body>
  9. </html>

2. RestFul风格

Restful 是一设置种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

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

3. 结果跳转

3.1 ModelAndView、Model、ModelMap

SpringMVC 内部使用一个 org.springframework.ui.Model 接口存储的数据模型，功能类似于 Java.uitl.Map, 但是比 Map 更好用 org.springframework.ui.ModelMap 实现 Map 接口。

SpringMVC 在调用方法前会创建一个隐含的数据模型，作为模型数据的存储容器， 成为”隐含模型”。如果处理方法入参为 Map 或者 Model 类型，SpringMVC 会将隐含模型的引用传递给这些入参。

  • Model 是一个接口， 其实现类为 ExtendedModelMap，继承了 ModelMap 类。
  • ModelMap 对象主要用于传递控制方法处理数据到结果页面，也就是说我们把结果页面上需要的数据放到 ModelMap 对象中即可。ModelMap 或者 Model 通过 addAttribute 方法向页面传递参数。注意：modelmap 本身不能设置页面跳转的url地址别名或者物理跳转地址

  • ModelAndView 对象有两个作用：

    • 设置转向地址，这也是 ModelAndView 和 ModelMap 的主要区别，通过 setViewName 方法；

    • 通过 addObject 方法可以将结果页面需要的数据放到 ModelAndView 对象中，类似于request对象的setAttribute方法的作用，用来在一个请求过程中传递处理的数据。

      3.2 转发和重定向

      1. @Controller
      2. public class ResultSpringMVC2 {
      3. @RequestMapping("/rsm2/t1")
      4. public String test1(){
      5.   //转发
      6.   return "test";
      7. }
      9. @RequestMapping("/rsm2/t2")
      10. public String test2(){
      11.   //重定向
      12.   return "redirect:/index.jsp";
      13.   //return "redirect:hello.do"; //hello.do为另一个请求/
      14. }

4. 解决乱码问题

4.1 Get 请求乱码解决

1、修改 tomcat 配置文件 ：设置编码！

  1. <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
  2.            connectionTimeout="20000"
  3.            redirectPort="8443" />

2、自定义过滤器

  1. package com.kuang.filter;
  3. import javax.servlet.*;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletRequestWrapper;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.io.IOException;
  8. import java.io.UnsupportedEncodingException;
  9. import java.util.Map;
  11. /**
  12. * 解决get和post请求 全部乱码的过滤器
  13. */
  14. public class GenericEncodingFilter implements Filter {
  16.    @Override
  17.    public void destroy() {
  18.   }
  20.    @Override
  21.    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  22.        //处理response的字符编码
  23.        HttpServletResponse myResponse=(HttpServletResponse) response;
  24.        myResponse.setContentType("text/html;charset=UTF-8");
  26.        // 转型为与协议相关对象
  27.        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
  28.        // 对request包装增强
  29.        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
  30.        chain.doFilter(myrequest, response);
  31.   }
  33.    @Override
  34.    public void init(FilterConfig filterConfig) throws ServletException {
  35.   }
  37. }
  39. //自定义request对象，HttpServletRequest的包装类
  40. class MyRequest extends HttpServletRequestWrapper {
  42.    private HttpServletRequest request;
  43.    //是否编码的标记
  44.    private boolean hasEncode;
  45.    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
  46.    public MyRequest(HttpServletRequest request) {
  47.        super(request);// super必须写
  48.        this.request = request;
  49.   }
  51.    // 对需要增强方法 进行覆盖
  52.    @Override
  53.    public Map getParameterMap() {
  54.        // 先获得请求方式
  55.        String method = request.getMethod();
  56.        if (method.equalsIgnoreCase("post")) {
  57.            // post请求
  58.            try {
  59.                // 处理post乱码
  60.                request.setCharacterEncoding("utf-8");
  61.                return request.getParameterMap();
  62.           } catch (UnsupportedEncodingException e) {
  63.                e.printStackTrace();
  64.           }
  65.       } else if (method.equalsIgnoreCase("get")) {
  66.            // get请求
  67.            Map<String, String[]> parameterMap = request.getParameterMap();
  68.            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
  69.                for (String parameterName : parameterMap.keySet()) {
  70.                    String[] values = parameterMap.get(parameterName);
  71.                    if (values != null) {
  72.                        for (int i = 0; i < values.length; i++) {
  73.                            try {
  74.                                // 处理get乱码
  75.                                values[i] = new String(values[i]
  76.                                       .getBytes("ISO-8859-1"), "utf-8");
  77.                           } catch (UnsupportedEncodingException e) {
  78.                                e.printStackTrace();
  79.                           }
  80.                       }
  81.                   }
  82.               }
  83.                hasEncode = true;
  84.           }
  85.            return parameterMap;
  86.       }
  87.        return super.getParameterMap();
  88.   }
  90.    //取一个值
  91.    @Override
  92.    public String getParameter(String name) {
  93.        Map<String, String[]> parameterMap = getParameterMap();
  94.        String[] values = parameterMap.get(name);
  95.        if (values == null) {
  96.            return null;
  97.       }
  98.        return values[0]; // 取回参数的第一个值
  99.   }
  101.    //取所有值
  102.    @Override
  103.    public String[] getParameterValues(String name) {
  104.        Map<String, String[]> parameterMap = getParameterMap();
  105.        String[] values = parameterMap.get(name);
  106.        return values;
  107.   }
  108. }

4.2 Post 请求乱码解决

可以在 web.xml 中配置 Spring 自带的过滤器。

  1. <filter>
  2.     <filter-name>encoding</filter-name>
  3.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  4.     <init-param>
  5.         <param-name>encoding</param-name>
  6.         <param-value>utf-8</param-value>
  7.     </init-param>
  8. </filter>
  9. <filter-mapping>
  10.     <filter-name>encoding</filter-name>
  11.     <url-pattern>/*</url-pattern>
  12. </filter-mapping>

5. JSON交互

5.1 JSON 使用

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

  1. var obj = JSON.parse('{"a": "Hello", "b": "World"}');
  2. //结果是 {a: 'Hello', b: 'World'}

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

  1. var json = JSON.stringify({a: 'Hello', b: 'World'});
  2. //结果是 '{"a": "Hello", "b": "World"}'

5.2 使用 Jackson

1、导入 jackson 依赖。

  1. <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
  2. <dependency>
  3.    <groupId>com.fasterxml.jackson.core</groupId>
  4.    <artifactId>jackson-databind</artifactId>
  5.    <version>2.9.8</version>
  6. </dependency>

2、配置 web.xml。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  7.     <!--1.注册servlet-->
  8.     <servlet>
  9.         <servlet-name>SpringMVC</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  11.         <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
  12.         <init-param>
  13.             <param-name>contextConfigLocation</param-name>
  14.             <param-value>classpath:springmvc-servlet.xml</param-value>
  15.         </init-param>
  16.         <!-- 启动顺序，数字越小，启动越早 -->
  17.         <load-on-startup>1</load-on-startup>
  18.     </servlet>
  20.     <!--所有请求都会被springmvc拦截 -->
  21.     <servlet-mapping>
  22.         <servlet-name>SpringMVC</servlet-name>
  23.         <url-pattern>/</url-pattern>
  24.     </servlet-mapping>
  26.     <filter>
  27.         <filter-name>encoding</filter-name>
  28.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  29.         <init-param>
  30.             <param-name>encoding</param-name>
  31.             <param-value>utf-8</param-value>
  32.         </init-param>
  33.     </filter>
  34.     <filter-mapping>
  35.         <filter-name>encoding</filter-name>
  36.         <url-pattern>/</url-pattern>
  37.     </filter-mapping>
  39. </web-app>

3、配置 spring-config.xml。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.                            http://www.springframework.org/schema/beans/spring-beans.xsd
  8.                            http://www.springframework.org/schema/context
  9.                            https://www.springframework.org/schema/context/spring-context.xsd
  10.                            http://www.springframework.org/schema/mvc
  11.                            https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  13.     <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
  14.     <context:component-scan base-package="com.kuang.controller"/>
  16.     <!-- 视图解析器 -->
  17.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
  18.           id="internalResourceViewResolver">
  19.         <!-- 前缀 -->
  20.         <property name="prefix" value="/WEB-INF/jsp/" />
  21.         <!-- 后缀 -->
  22.         <property name="suffix" value=".jsp" />
  23.     </bean>
  25. </beans>

4、编写 User 实体类。

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. public class User {
  6.     private String name;
  7.     private int age;
  8.     private String sex;
  10. }

5、编写 Controller。

  1. @Controller
  2. public class UserController {
  4.     @RequestMapping("/json1")
  5.     @ResponseBody
  6.     public String json1() throws JsonProcessingException {
  7.         //创建一个jackson的对象映射器，用来解析数据
  8.         ObjectMapper mapper = new ObjectMapper();
  9.         //创建一个对象
  10.         User user = new User("秦疆1号", 3, "男");
  11.         //将我们的对象解析成为json格式
  12.         String str = mapper.writeValueAsString(user);
  13.         //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
  14.         return str;
  15.     }
  17. }

6、启动测试，发现乱码！
Spring MVC - 图3

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

  1. //produces:指定响应体返回类型和编码
  2. @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

8、如果每次定义方法都要定义 produces 属性的话，太麻烦了，乱码统一解决，在 spring-config 中配置:

  1. <mvc:annotation-driven>
  2.     <mvc:message-converters register-defaults="true">
  3.         <bean class="org.springframework.http.converter.StringHttpMessageConverter">
  4.             <constructor-arg value="UTF-8"/>
  5.         </bean>
  6.         <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  7.             <property name="objectMapper">
  8.                 <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
  9.                     <property name="failOnEmptyBeans" value="false"/>
  10.                 </bean>
  11.             </property>
  12.         </bean>
  13.     </mvc:message-converters>
  14. </mvc:annotation-driven>

9、我们可以在类上使用注解 @RestController，表示该类所有的方法都只会返回 json 字符串了。

6. Ajax 处理

6.1 认识 Ajax

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML），一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

6.2 使用 Ajax

1、配置 web.xml 和 spring-config.xml，这里省略。
2、编写一个 AjaxController。

  1. @RequestMapping("/a3")
  2. public String ajax3(String name,String pwd){
  3.     String msg = "";
  4.     //模拟数据库中存在数据
  5.     if (name!=null){
  6.         if ("admin".equals(name)){
  7.             msg = "OK";
  8.         }else {
  9.             msg = "用户名输入错误";
  10.         }
  11.     }
  12.     if (pwd!=null){
  13.         if ("123456".equals(pwd)){
  14.             msg = "OK";
  15.         }else {
  16.             msg = "密码输入有误";
  17.         }
  18.     }
  19.     return msg; //由于@RestController注解，将msg转成json格式返回
  20. }

3、前端页面 login.jsp

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.     <head>
  4.         <title>ajax</title>
  5.         <script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.min.js"></script>
  6.         <script>
  8.             function a1(){
  9.                 $.post({
  10.                     url:"${pageContext.request.contextPath}/a3",
  11.                     data:{'name':$("#name").val()},
  12.                     success:function (data) {
  13.                         if (data.toString()=='OK'){
  14.                             $("#userInfo").css("color","green");
  15.                         }else {
  16.                             $("#userInfo").css("color","red");
  17.                         }
  18.                         $("#userInfo").html(data);
  19.                     }
  20.                 });
  21.             }
  22.             function a2(){
  23.                 $.post({
  24.                     url:"${pageContext.request.contextPath}/a3",
  25.                     data:{'pwd':$("#pwd").val()},
  26.                     success:function (data) {
  27.                         if (data.toString()=='OK'){
  28.                             $("#pwdInfo").css("color","green");
  29.                         }else {
  30.                             $("#pwdInfo").css("color","red");
  31.                         }
  32.                         $("#pwdInfo").html(data);
  33.                     }
  34.                 });
  35.             }
  37.         </script>
  38.     </head>
  39.     <body>
  40.         <p>
  41.             用户名:<input type="text" id="name" onblur="a1()"/>
  42.             <span id="userInfo"></span>
  43.         </p>
  44.         <p>
  45.             密码:<input type="text" id="pwd" onblur="a2()"/>
  46.             <span id="pwdInfo"></span>
  47.         </p>
  48.     </body>
  49. </html>

7. 拦截器

7.1 什么是拦截器

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

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

  • servlet规范中的一部分，任何 java web 工程都可以使用
  • 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

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

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

    7.2 自定义拦截器（验证用户是否登录）

    1、编写一个登录页面 login.jsp。

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3.   <head>
    4.       <title>Title</title>
    5.   </head>
    7.   <h1>登录页面</h1>
    8.   <hr>
    10.   <body>
    11.       <form action="${pageContext.request.contextPath}/user/login">
    12.           用户名：<input type="text" name="username"> <br>
    13.           密码：<input type="password" name="pwd"> <br>
    14.           <input type="submit" value="提交">
    15.       </form>
    16.   </body>
    17. </html>

2、编写一个 Controller 处理请求。

  1. @Controller
  2. @RequestMapping("/user")
  3. public class UserController {
  5.     //跳转到登陆页面
  6.     @RequestMapping("/jumplogin")
  7.     public String jumpLogin() throws Exception {
  8.         return "login";
  9.     }
  11.     //跳转到成功页面
  12.     @RequestMapping("/jumpSuccess")
  13.     public String jumpSuccess() throws Exception {
  14.         return "success";
  15.     }
  17.     //登陆提交
  18.     @RequestMapping("/login")
  19.     public String login(HttpSession session, String username, String pwd) throws Exception {
  20.         // 向session记录用户身份信息
  21.         System.out.println("接收前端==="+username);
  22.         session.setAttribute("user", username);
  23.         return "success";
  24.     }
  26.     //退出登陆
  27.     @RequestMapping("logout")
  28.     public String logout(HttpSession session) throws Exception {
  29.         // session 过期
  30.         session.invalidate();
  31.         return "login";
  32.     }
  33. }

3、编写一个登录成功的页面 success.jsp。

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.     <head>
  4.         <title>Title</title>
  5.     </head>
  6.     <body>
  8.         <h1>登录成功页面</h1>
  9.         <hr>
  11.         ${user}
  12.         <a href="${pageContext.request.contextPath}/user/logout">注销</a>
  13.     </body>
  14. </html>

4、在 index 页面上测试跳转！启动 tomcat 测试，没有登录也可以进入主页!

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.     <head>
  4.         <title>$Title$</title>
  5.     </head>
  6.     <body>
  7.         <h1>首页</h1>
  8.         <hr>
  9.         <%--登录--%>
  10.         <a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
  11.         <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>
  12.     </body>
  13. </html>

5、编写用户登录拦截器。

  1. public class LoginInterceptor implements HandlerInterceptor {
  3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
  4.         // 如果是登陆页面则放行
  5.         System.out.println("uri: " + request.getRequestURI());
  6.         if (request.getRequestURI().contains("login")) {
  7.             return true;
  8.         }
  10.         HttpSession session = request.getSession();
  12.         // 如果用户已登陆也放行
  13.         if(session.getAttribute("user") != null) {
  14.             return true;
  15.         }
  17.         // 用户没有登陆跳转到登陆页面
  18.         request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
  19.         return false;
  20.     }
  22.     public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
  24.     }
  26.     public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
  28.     }
  29. }

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

  1. <!--关于拦截器的配置-->
  2. <mvc:interceptors>
  3.     <mvc:interceptor>
  4.         <mvc:mapping path="/**"/>
  5.         <bean id="loginInterceptor" class="com.kuang.interceptor.LoginInterceptor"/>
  6.     </mvc:interceptor>
  7. </mvc:interceptors>

8. 文件上传

8.1 使用 IO 流写文件

1、导入文件上传的 jar 包。

  1. <!--文件上传-->
  2. <dependency>
  3.     <groupId>commons-fileupload</groupId>
  4.     <artifactId>commons-fileupload</artifactId>
  5.     <version>1.3.3</version>
  6. </dependency>
  7. <!--servlet-api导入高版本的-->
  8. <dependency>
  9.     <groupId>javax.servlet</groupId>
  10.     <artifactId>javax.servlet-api</artifactId>
  11.     <version>4.0.1</version>
  12. </dependency>

2、配置 bean：multipartResolver

这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误

  1. <!-- 文件上传-->
  2. <bean id="multipartResolver"
  3.       class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  4.     <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
  5.     <property name="defaultEncoding" value="utf-8"/>
  6.     <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
  7.     <property name="maxUploadSize" value="10485760"/>
  8.     <property name="maxInMemorySize" value="40960"/>
  9. </bean>

3、编写前端页面。

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.     <head>
  4.         <title>$Title$</title>
  5.     </head>
  6.     <body>
  7.         <h3>hello world</h3>
  9.         <form action="/upload" enctype="multipart/form-data" method="post">
  10.             <input type="file" name="file"/>
  11.             <input type="submit" value="upload">
  12.         </form>
  14.     </body>
  15. </html>

4、编写 Controller

  1. @Controller
  2. public class FileController {
  4.     //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
  5.     @RequestMapping("/upload")
  6.     public String fileUpload(@RequestParam("file")CommonsMultipartFile file,
  7.                              HttpServletRequest request) throws IOException {
  8.         //获取文件名
  9.         String uploadFileName = file.getOriginalFilename();
  11.         //如果文件名为空，直接回到首页
  12.         if ("".equals(uploadFileName)) {
  13.             return "redirect:/index.jsp";
  14.         }
  16.         //上传路径保存设置
  17.         String path = request.getServletContext().getRealPath("/upload");
  18.         //如果路径不存在，创建一个
  19.         File realPath = new File(path);
  20.         if (! realPath.exists()) {
  21.             realPath.mkdir();
  22.         }
  23.         System.out.println("上传文件保存地址：" + realPath);
  25.         InputStream is = file.getInputStream(); //文件输入流
  26.         OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
  28.         //读取写出
  29.         int len=0;
  30.         byte[] buffer = new byte[1024];
  31.         while ((len=is.read(buffer))!=-1){
  32.             os.write(buffer,0,len);
  33.             os.flush();
  34.         }
  35.         os.close();
  36.         is.close();
  37.         return "redirect:/index.jsp";
  38.     }
  39. }

5、测试上传文件，OK!

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

1、编写Controller

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

2、前端表单提交地址修改
3、访问提交测试，OK！

8.3 文件下载

1、编写 controller

  1. @RequestMapping(value="/download")
  2. public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
  3.     //要下载的图片地址
  4.     String  path = request.getServletContext().getRealPath("/upload");
  5.     String  fileName = "基础语法.jpg";
  7.     //1、设置response 响应头
  8.     response.reset(); //设置页面不缓存,清空buffer
  9.     response.setCharacterEncoding("UTF-8"); //字符编码
  10.     response.setContentType("multipart/form-data"); //二进制传输数据
  11.     //设置响应头
  12.     response.setHeader("Content-Disposition",
  13.                        "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));
  15.     File file = new File(path,fileName);
  16.     //2、 读取文件--输入流
  17.     InputStream input=new FileInputStream(file);
  18.     //3、 写出文件--输出流
  19.     OutputStream out = response.getOutputStream();
  21.     byte[] buff =new byte[1024];
  22.     int index=0;
  23.     //4、执行 写出操作
  24.     while((index= input.read(buff))!= -1){
  25.         out.write(buff, 0, index);
  26.         out.flush();
  27.     }
  28.     //5、关闭流
  29.     out.close();
  30.     input.close();
  31.     return null;
  32. }

2、前端 index.jsp

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