SpringMVC_Two

SpringMVC_Two

响应数据和结果视图

创建工厂

导坐标:

  1. <!-- 版本锁定 -->
  2. <properties>
  3.  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  4.  <maven.compiler.source>1.8</maven.compiler.source>
  5.  <maven.compiler.target>1.8</maven.compiler.target>
  6.  <spring.version>5.0.2.RELEASE</spring.version>
  7. </properties>
  11. <dependencies>
  12.  <dependency>
  13.  <groupId>org.springframework</groupId>
  14.  <artifactId>spring-context</artifactId>
  15.  <version>${spring.version}</version>
  16.  </dependency>
  18.  <dependency>
  19.  <groupId>org.springframework</groupId>
  20.  <artifactId>spring-web</artifactId>
  21.  <version>${spring.version}</version>
  22.  </dependency>
  24.  <dependency>
  25.  <groupId>org.springframework</groupId>
  26.  <artifactId>spring-webmvc</artifactId>
  27.  <version>${spring.version}</version>
  28.  </dependency>
  30.  <dependency>
  31.  <groupId>javax.servlet</groupId>
  32.  <artifactId>servlet-api</artifactId>
  33.  <version>2.5</version>
  34.  <scope>provided</scope>
  35.  </dependency>
  37.  <dependency>
  38.  <groupId>javax.servlet.jsp</groupId>
  39.  <artifactId>jsp-api</artifactId>
  40.  <version>2.0</version>
  41.  <scope>provided</scope>
  42.  </dependency>
  43. </dependencies>

配置web.xml

在web.xml配置文件中核心控制器DispatcherServlet

  1. <!-- SpringMVC的核心控制器 -->
  2. <servlet>
  3.  <servlet-name>dispatcherServlet</servlet-name>
  4.  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5.  <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
  6.  <init-param>
  7.  <param-name>contextConfigLocation</param-name>
  8.  <param-value>classpath:springmvc.xml</param-value>
  9.  </init-param>
  10.  <!-- 配置servlet启动时加载对象 -->
  11.  <load-on-startup>1</load-on-startup>
  12. </servlet>
  13. <servlet-mapping>
  14.  <servlet-name>dispatcherServlet</servlet-name>
  15.  <url-pattern>/</url-pattern>
  16. </servlet-mapping>

处理乱码的过滤器：

  1. <!--处理乱码的过滤器-->
  2. <filter>
  3.  <filter-name>CharacterEncodingFilter</filter-name>
  4.  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  5.  <init-param>
  6.  <param-name>encoding</param-name>
  7.  <param-value>UTF-8</param-value>
  8.  </init-param>
  9. </filter>
  10. <filter-mapping>
  11.  <filter-name>CharacterEncodingFilter</filter-name>
  12.  <url-pattern>/*</url-pattern>
  13. </filter-mapping>

配置编写springmvc.xml的配置文件

在resources下创建springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.  xsi:schemaLocation="
  7.         http://www.springframework.org/schema/beans
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd
  9.         http://www.springframework.org/schema/mvc
  10.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  11.         http://www.springframework.org/schema/context
  12.         http://www.springframework.org/schema/context/spring-context.xsd">
  14.  <!-- 1：配置spring创建容器时要扫描的包 -->
  15.  <context:component-scan base-package="com.le"></context:component-scan>
  17.  <!-- 2：配置视图解析器 -->
  18.  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  19.  <property name="prefix" value="/WEB-INF/pages/"></property>
  20.  <property name="suffix" value=".jsp"></property>
  21.  </bean>
  23.  <!-- 3：配置spring开启注解mvc的支持 -->
  24.  <mvc:annotation-driven></mvc:annotation-driven>
  25. </beans>

创建index.jsp

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

在WEB-INF下创建pages的文件夹，创建success.jsp

  1. <body>
  2. <h1>访问成功</h1>
  3. </body>

返回值分类

Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址。

创建response.jsp

  1. <body>
  2. <h3>返回字符串</h3>
  3. <a href="user/testReturnString">返回字符串</a><br>
  4. <a href="user/userUpdate">修改用户（表单回显）</a>
  5. </body>

创建包com.le.controller，创建类UserController.java

  1. @Controller
  2. @RequestMapping(path = "/user")
  3. public class UserController {
  5.  // 返回字符串
  6.  @RequestMapping(path="/testReturnString")
  7.  public String testReturnString(){
  8.  System.out.println("执行了testReturnString方法！");
  9.  return "success";
  10.  }
  12.  /**
  13.      * 请求参数的绑定
  14.      */
  15.  @RequestMapping(value="/userUpdate")
  16.  public String userUpdate(Model model) {
  17.  // 模拟从数据库中查询的数据，在页面上进行回显
  18.  User user = new User();
  19.         user.setUsername("张三");
  20.         user.setPassword("123");
  21.         user.setAge(18);
  22.         model.addAttribute("user", user);
  23.  return "update";
  24.  }
  25. }

在WEB-INF的pages下，编写update.jsp

  1. <%@ page contentType="text/html;charset=UTF-8" language="java"  isELIgnored="false" %>
  2. <html>
  3. <head>
  4.  <title>Title</title>
  5. </head>
  6. <body>
  7. <h3>修改用户</h3>
  8. ${ requestScope }
  9. <form action="${pageContext.request.contextPath}/
  10. user/update" method="post">
  11.     姓名：<input type="text" name="username" value="${ user.username }"><br>
  12.     密码：<input type="text" name="password" value="${ user.password }"><br>
  13.     年龄：<input type="text" name="age" value="${ user.age }"><br>
  14.  <input type="submit" value="提交">
  15. </form>
  16. </body>
  17. </html>

点击“提交”

  1. // 更新保存
  2. @RequestMapping(value = "/update")
  3. public String update(User user){
  4.  System.out.println("执行UserController的update的方法！user："+user);
  5.  return "success";
  6. }

返回值是void

情况1：如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到。

默认会跳转到@RequestMapping(path="/testVoid")testVoid的页面。

response.jsp

  1. <h3>无返回值void</h3>
  2. <a href="user/testVoid">无返回值</a>

userController.java

  1. // 无返回值
  2. @RequestMapping(path="/testVoid")
  3. public void testVoid(){
  4.  System.out.println("执行了testVoid方法！");
  5. }

1562425914728

情况2：可以使用请求转发或者重定向跳转到指定的页面

修改testVoid的方法

  1. @RequestMapping(value="/testVoid")
  2.  public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception {
  3.  System.out.println("请求转发或者重定向");
  4.  // 1：请求转发
  5. //  request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);
  6.  // 2：重定向
  7. //  response.sendRedirect(request.getContextPath()+"/index.jsp");
  10.         response.setCharacterEncoding("UTF-8");
  11.         response.setContentType("text/html;charset=UTF-8");
  13.  // 3：直接响应数据
  14.         response.getWriter().print("你好");
  15.  return;
  16.  }

页面结果：

情况3：如果不指定转发和重定向，直接响应数据。

1562425958319

返回值是ModelAndView对象

ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图

具体的代码如下

response.jsp

  1. <h3>返回ModelAndView对象</h3>
  2. <a href="user/testModelAndView">ModelAndView</a>

修改Usercontroller.java

  1. /**
  2. * 返回ModelAndView对象
  3. * 可以传入视图的名称（即跳转的页面），还可以传入对象。
  4. * @return
  5. * @throws Exception
  6. */
  7. @RequestMapping(value="/testModelAndView")
  8. public ModelAndView testModelAndView() throws Exception {
  9.  ModelAndView mv = new ModelAndView();
  10.  // 默认执行视图解析器，跳转到WEB-INF/pages/success.jsp的页面
  11.     mv.setViewName("success");
  13.  // 模拟从数据库中查询所有的用户信息
  14.  List<User> list = new ArrayList<>();
  15.  User user1 = new User();
  16.     user1.setUsername("张三");
  17.     user1.setPassword("123");
  19.  User user2 = new User();
  20.     user2.setUsername("赵四");
  21.     user2.setPassword("456");
  23.     list.add(user1);
  24.     list.add(user2);
  25.  // 添加对象
  26.     mv.addObject("list", list);
  28.  return mv;
  29. }

坐标:

  1. <dependency>
  2.  <groupId>jstl</groupId>
  3.  <artifactId>jstl</artifactId>
  4.  <version>1.2</version>
  5. </dependency>

success.jsp

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
  2. <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  3. <html>
  4. <head>
  5.  <title>Title</title>
  6. </head>
  7. <body>
  8. <h1>访问成功</h1>
  9. <h3>查询所有的数据</h3>
  10. <c:forEach items="${ list }" var="user">
  11.     ${ user.username }-----${user.password}<br>
  12. </c:forEach>
  13. </body>
  14. </html>

SpringMVC框架提供的转发和重定向

forward请求转发

UserController.java方法返回String类型，想进行请求转发也可以编写成：

response.jsp

  1. <h3>转发和重定向</h3>
  2. <a href="user/testForwardOrRedirect">ForwardOrRedirect</a>

转发和重定向

  1. /**
  2.      * 使用forward关键字进行请求转发
  3.      * "forward:转发的JSP路径"，不走视图解析器了，所以需要编写完整的路径
  4.      * @return
  5.      * @throws Exception
  6.      */
  7.  @RequestMapping("/testForwardOrRedirect")
  8.  public String testForwardOrRedirect() throws Exception {
  9.  System.out.println("testForwardOrRedirect方法执行了...");
  10. //        return "forward:/WEB-INF/pages/success.jsp";
  11.  return "forward:/user/testReturnString";
  12.  }

redirect重定向

controller方法返回String类型，想进行重定向也可以编写成

  1. /**
  2.      * 重定向
  3.      * @return
  4.      * @throws Exception
  5.      */
  6.  @RequestMapping("/testForwardOrRedirect")
  7.  public String testForwardOrRedirect() throws Exception {
  8.  System.out.println("testForwardOrRedirect方法执行了...");
  9. //        return "redirect:/index.jsp";
  10.  return "redirect:/user/testReturnString";
  11.  }

@ResponseBody响应json数据

去掉对静态资源的拦截

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img、css、js）也会被拦截到，从而不能被使用。

response.jsp

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <script src="js/jquery.min.js"></script>
  3. <script>
  4.     $(function(){
  5.         $("#btn").click(function(){
  6.             alert("ok");
  7.  })
  8.  })
  9. </script>
  10. <html>
  11. <head>
  12.  <title>Title</title>
  13. </head>
  14. <body>
  15. <h3>ResponseBody响应json数据</h3>
  16. <input type="button" value="提交" id="btn"/>
  17. </body>
  18. </html>

此时发现【提交】按钮不起作用，因为springMVC的使用了servlet的配置，servlet中使用/，拦截所有的请求，js/jquery.min.js也被拦截了，不起作用。

【解决方案】：需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置

推荐使用：在springmvc.xml中使用：

  1. <!--去掉所有的静态资源，让DispatchServlet不能拦截静态资源-->
  2. <!--方案一-->
  3. <mvc:default-servlet-handler></mvc:default-servlet-handler>

使用@RequestBody获取请求的数据

response.jsp

  1. <script>
  2.     $(function(){
  3.         $("#btn").click(function(){
  4. //          alert("ok");
  5.             $.ajax({
  6.                 url:"user/testJson",
  7.                 contentType:"application/json;charset=UTF-8",
  8.                 data:'{"username":"tom","password":"123","age":30}',
  9.                 dataType:"json",
  10.                 type:"post",
  11.                 success:function(data){
  12.                     alert(data);
  13.                     alert(data.addressName);
  14.  }
  15.  });
  16.  })
  17.  })
  18. </script>

UserController.java

  1. /**
  2. * 获取请求体的数据
  3. * @param body
  4. */
  5. @RequestMapping("/testJson")
  6. public void testJson(@RequestBody String body) {
  7.  System.out.println(body);
  8. }

img
但是此时获取了json数据的字符串，我们需要将数据封装到javaBean的对象怎么办？

↓↓↓↓↓↓↓

json字符串和JavaBean对象互相转换的过程中，需要使用jackson的jar包

  1. <dependency>
  2.  <groupId>com.fasterxml.jackson.core</groupId>
  3.  <artifactId>jackson-databind</artifactId>
  4.  <version>2.9.0</version>
  5. </dependency>
  6. <dependency>
  7.  <groupId>com.fasterxml.jackson.core</groupId>
  8.  <artifactId>jackson-core</artifactId>
  9.  <version>2.9.0</version>
  10. </dependency>
  11. <dependency>
  12.  <groupId>com.fasterxml.jackson.core</groupId>
  13.  <artifactId>jackson-annotations</artifactId>
  14.  <version>2.9.0</version>
  15. </dependency>

使用@ResponseBody注解将JavaBean对象转换成Json返回

使用@ResponseBody注解把JavaBean对象转换成json字符串，直接响应 
要求方法需要返回JavaBean的对象

response.jsp

  1. <script src="js/jquery.min.js"></script>
  2. <script>
  3.     $(function(){
  4.         $("#btn").click(function(){
  5. //          alert("ok");
  6.             $.ajax({
  7.                 url:"user/testJson",
  8.                 contentType:"application/json;charset=UTF-8",
  9.                 data:'{"username":"tom","password":"123","age":30}',
  10.                 dataType:"json",
  11.                 type:"post",
  12.                 success:function(data){
  13.                     alert(data);
  14.                     alert(data.username);
  15.                     alert(data.password);
  16.                     alert(data.age);
  17.  }
  18.  });
  19.  })
  20.  })
  21. </script>

注意：data:'{"username":"tom","password":"123","age":30}',一定保证单引号在外，双引号在里，否则抛出异常

UserController.java

  1. /**
  2. * 获取请求体的数据，响应数据Json
  3. * @param body
  4. */
  5. @RequestMapping("/testJson")
  6. public @ResponseBody User testJson(@RequestBody User user) {
  7.  // 请求user
  8.  System.out.println(user);
  9.  // 响应u
  10.  User u = new User();
  11.     u.setUsername("张三");
  12.     u.setPassword("123");
  13.     u.setAge(18);
  14.  return u;
  15. }

SpringMVC实现文件上传

文件上传的必要前提:

  • A form表单的enctype取值必须是：multipart/form-data （支持二进制数据） 
    (默认值是:application/x-www-form-urlencoded) （支持传递参数，例如：?username=zhangsan&age=18） 
    enctype:是表单请求正文的类型
  • B method属性取值必须是Post
  • C 提供一个文件选择域

文件上传的原理分析 :

​ 当form表单的enctype取值不是默认值后（例如：multipart/form-data），request.getParameter()将失效。

默认值：

enctype=”application/x-www-form-urlencoded”时，form表单的正文内容是：

key=value&key=value&key=value

当form表单的enctype取值为Mutilpart/form-data时，请求正文内容就变成： 每一部分都是MIME类型描述的正文

  1. -----------------------------7de1a433602ac 分界符
  2. Content-Disposition: form-data; name="userName" 协议头
  3. aaa 协议的正文
  4. -----------------------------7de1a433602ac
  5. Content-Disposition: form-data; name="file"; filename="C:\Users\zhy\Desktop\fileupload_demofile\b.txt"
  6. Content-Type: text/plain 协议的类型（MIME类型）
  7. bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
  8. -----------------------------7de1a433602ac--

springmvc传统方式的文件上传

坐标:

  1. <!-- 版本锁定 -->
  2. <properties>
  3.  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  4.  <maven.compiler.source>1.8</maven.compiler.source>
  5.  <maven.compiler.target>1.8</maven.compiler.target>
  6.  <spring.version>5.0.2.RELEASE</spring.version>
  7. </properties>
  11. <dependencies>
  12.  <dependency>
  13.  <groupId>org.springframework</groupId>
  14.  <artifactId>spring-context</artifactId>
  15.  <version>${spring.version}</version>
  16.  </dependency>
  18.  <dependency>
  19.  <groupId>org.springframework</groupId>
  20.  <artifactId>spring-web</artifactId>
  21.  <version>${spring.version}</version>
  22.  </dependency>
  24.  <dependency>
  25.  <groupId>org.springframework</groupId>
  26.  <artifactId>spring-webmvc</artifactId>
  27.  <version>${spring.version}</version>
  28.  </dependency>
  30.  <dependency>
  31.  <groupId>javax.servlet</groupId>
  32.  <artifactId>servlet-api</artifactId>
  33.  <version>2.5</version>
  34.  <scope>provided</scope>
  35.  </dependency>
  37.  <dependency>
  38.  <groupId>javax.servlet.jsp</groupId>
  39.  <artifactId>jsp-api</artifactId>
  40.  <version>2.0</version>
  41.  <scope>provided</scope>
  42.  </dependency>
  44.  <dependency>
  45.  <groupId>jstl</groupId>
  46.  <artifactId>jstl</artifactId>
  47.  <version>1.2</version>
  48.  </dependency>
  50.  <dependency>
  51.  <groupId>commons-fileupload</groupId>
  52.  <artifactId>commons-fileupload</artifactId>
  53.  <version>1.3.1</version>
  54.  </dependency>
  55.  <dependency>
  56.  <groupId>commons-io</groupId>
  57.  <artifactId>commons-io</artifactId>
  58.  <version>2.4</version>
  59.  </dependency>
  61. </dependencies>

web.xml

  1. <!-- SpringMVC的核心控制器 -->
  2. <servlet>
  3.  <servlet-name>dispatcherServlet</servlet-name>
  4.  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5.  <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
  6.  <init-param>
  7.  <param-name>contextConfigLocation</param-name>
  8.  <param-value>classpath:springmvc.xml</param-value>
  9.  </init-param>
  10.  <!-- 配置servlet启动时加载对象 -->
  11.  <load-on-startup>1</load-on-startup>
  12. </servlet>
  13. <servlet-mapping>
  14.  <servlet-name>dispatcherServlet</servlet-name>
  15.  <url-pattern>/</url-pattern>
  16. </servlet-mapping>
  18. <!--配置解决中文乱码过滤器-->
  19. <filter>
  20.  <filter-name>characterEncodingFilter</filter-name>
  21.  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  22.  <init-param>
  23.  <param-name>encoding</param-name>
  24.  <param-value>utf-8</param-value>
  25.  </init-param>
  26. </filter>
  27. <filter-mapping>
  28.  <filter-name>characterEncodingFilter</filter-name>
  29.  <url-pattern>/*</url-pattern>
  30. </filter-mapping>

springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.  xsi:schemaLocation="
  7.         http://www.springframework.org/schema/beans
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd
  9.         http://www.springframework.org/schema/mvc
  10.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  11.         http://www.springframework.org/schema/context
  12.         http://www.springframework.org/schema/context/spring-context.xsd">
  13.  <context:component-scan base-package="com.le.controller"/>
  15.  <!--视图解析器-->
  16.  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  17.  <property name="prefix" value="/WEB-INF/pages/"></property>
  18.  <property name="suffix" value=".jsp"></property>
  19.  </bean>
  21.  <mvc:annotation-driven></mvc:annotation-driven>
  23.  <!-- 设置静态资源不过滤 -->
  24.  <mvc:default-servlet-handler></mvc:default-servlet-handler>
  26. </beans>

导入index.jsp

  1. <body>
  2. <a href="user/testFileUpload">文件上传</a>
  3. </body>

UserController.java

  1. @Controller
  2. @RequestMapping(path = "/user")
  3. public class UserController {
  5.  // 文件上传
  6.  @RequestMapping(path="/testFileUpload")
  7.  public String testFileUpload(){
  8.  System.out.println("执行了testFileUpload方法！");
  9.  return "success";
  10.  }
  12. }

WEB-INF/pages/success.jsp

  1. <body>
  2. <h1>文件上传成功</h1>
  3. </body>

普通文件上传

index.jsp

  1. <%--
  2.    enctype="multipart/form-data"把请求体分成多个部分上传
  3. --%>
  4. <form action="user/testFileUpload1" method="post" enctype="multipart/form-data">
  5.     选择文件：<input type="file" name="upload"><br/>
  6.  <input type="submit" value="上传"/><br/>
  7. </form>

UserController.java

  1. // 文件上传
  2. @RequestMapping(path="/testFileUpload1")
  3. public String testFileUpload1(HttpServletRequest request) throws Exception {
  4.  System.out.println("执行了testFileUpload1方法！");
  5.  // 上传的位置，获取到项目根目录下的uploads文件夹绝对路径
  6.  String path = request.getSession().getServletContext().getRealPath("/uploads");
  7.  // 创建file对象
  8.  File file = new File(path);
  9.  // 判断是否存在
  10.  if(!file.exists()) {
  11.  // 创建目录
  12.         file.mkdirs();
  13.  }
  15.  // 创建磁盘文件项工厂
  16.  DiskFileItemFactory factory = new DiskFileItemFactory();
  17.  ServletFileUpload fileUpload = new ServletFileUpload(factory);
  18.  // 解析request
  19.  List<FileItem> list = fileUpload.parseRequest(request);
  20.  // 遍历，获取到每一个文件项的对象
  21.  for (FileItem fileItem : list) {
  22.  // 判断，当前fileItem是否是文件项
  23.  if(fileItem.isFormField()) {
  24.  // 说明是普通的表单 ，文本框
  25.  }else {
  26.  // 文件上传项 fileItem
  27.  // 获取到文件的名称
  28.  String filename = fileItem.getName();
  29.  // 生成唯一标识
  30.  String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
  31.             filename = uuid+"_"+filename;
  32.  // 上传文件
  33.             fileItem.write(new File(file, filename));
  34.  // 删除临时文件
  35.             fileItem.delete();
  36.  }
  37.  }
  39.  return "success";
  40. }

查看上传结果

SpringMVC传统方式文件上传

简化ServletFileUpload的写法。

SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的name属性名称相同。

1562426837176

springmvc.xml中配置

  1. <!-- 配置文件解析器对象，要求id名称必须是multipartResolver -->
  2. <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  3.  <!--文件大小限制：10*1024*1024字节，表示10M-->
  4.  <property name="maxUploadSize" value="10485760"/>
  5. </bean>

index.jsp

  1. <hr>
  2. <form action="user/testFileUpload2" method="post" enctype="multipart/form-data">
  3.     选择文件：<input type="file" name="upload"><br/>
  4.  <input type="submit" value="上传"/><br/>
  5. </form>

UserController.java

  1. /**
  2. * 使用的是SpringMVC的文件上传
  3. * 框架提供了一个类，表示上传文件的对象，底层已经帮你解析了request对象，把文件上传对象通过方法的参数传递进来
  4. *
  5.  * MultipartFile upload    变量名称必须和表单file标签的name属性名称相同，上传文件的对象，SpringMVC框架传递给你的。
  6. *
  7. * @param request
  8. * @return
  9. * @throws Exception
  10. */
  11. @RequestMapping("/testFileUpload2")//                                    ↓↓↓注意这里的参数名称需要和文件上传表单中的"name属性名称一致   
  12. public String testFileUpload2(HttpServletRequest request,MultipartFile upload) throws Exception {
  13.  System.out.println("SpringMVC的上传文件...");
  14.  // 上传的位置，获取到项目根目录下的uploads文件夹绝对路径
  15.  String path = request.getSession().getServletContext().getRealPath("/uploads");
  16.  // 创建file对象
  17.  File file = new File(path);
  18.  // 判断是否存在
  19.  if(!file.exists()) {
  20.  // 创建目录
  21.         file.mkdirs();
  22.  }
  24.  // 获取到文件的名称
  25.  String filename = upload.getOriginalFilename();
  26.  // 生成唯一标识
  27.  String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
  28.     filename = uuid+"_"+filename;
  29.  // 使用upload对象中方法就直接上传文件
  30.     upload.transferTo(new File(file, filename));
  32.  return "success";
  33. }

springmvc跨服务器方式的文件上传

分服务器的目的

在实际开发中，我们会有很多处理不同功能的服务器。例如：

应用服务器：负责部署我们的应用 （源码）

数据库服务器：运行我们的数据库

缓存和消息服务器：负责处理大并发访问的缓存和消息

文件服务器：负责存储用户上传文件的服务器。

图片服务器：负责存储用户上传的图片的信息。

(注意：此处说的不是服务器集群）

分服务器处理的目的是让服务器各司其职，从而提高我们项目的运行效率。

img

准备两个tomcat服务器，并创建一个用于存放图片的web工程

创建工程

选择项目，右键，new一个Module

1562427091124

创建2个tomcat服务器

一个应用服务器：用来启动springmvc_day02_fileupload（端口：8080）

img

另一个图片服务器：用来启动springmvc_day02_fileuploadserver（端口：9090）

img

两个服务器的端口需要不一致

同时在图片服务器上创建upload文件夹，用来指定上传的文件。

1562427144308

注意:这里要新建一个任意文件,不然可能会报错

坐标

  1. <dependency>
  2.  <groupId>commons-fileupload</groupId>
  3.  <artifactId>commons-fileupload</artifactId>
  4.  <version>1.3.1</version>
  5. </dependency>
  6. <dependency>
  7.  <groupId>commons-io</groupId>
  8.  <artifactId>commons-io</artifactId>
  9.  <version>2.4</version>
  10. </dependency>
  12. <dependency>
  13.  <groupId>com.sun.jersey</groupId>
  14.  <artifactId>jersey-core</artifactId>
  15.  <version>1.18.1</version>
  16. </dependency>
  17. <dependency>
  18.  <groupId>com.sun.jersey</groupId>
  19.  <artifactId>jersey-client</artifactId>
  20.  <version>1.18.1</version>
  21. </dependency>

index.jsp

  1. <hr>
  2. <form action="user/testFileUpload3" method="post" enctype="multipart/form-data">
  3.     选择文件：<input type="file" name="upload"><br/>
  4.  <input type="submit" value="上传"/><br/>
  5. </form>

UserController.java

  1. /**
  2. * 跨服务器上传文件，把文件上传到图片服务器中去
  3. * @param upload
  4. * @return
  5. * @throws Exception
  6. */
  7. @RequestMapping("/testFileUpload3")
  8. public String testFileUpload3(MultipartFile upload) throws Exception {
  9.  System.out.println("跨服务器上传文件...");
  11.  // 指定上传文件的路径
  12.  String path = "http://localhost:9090/springmvc_day02_fileuploadserver/uploads/";
  14.  // 获取到文件的名称
  15.  String filename = upload.getOriginalFilename();
  16.  // 生成唯一标识
  17.  String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
  18.     filename = uuid+"_"+filename;
  20.  // 上传文件
  21.  // 创建客户端对象
  22.  Client client = Client.create();
  23.     filename = path+filename;
  24.  // 连接图片服务器
  25.  WebResource webResource = client.resource(filename);
  26.  // 把文件上传到图片服务器上
  27.     webResource.put(upload.getBytes());
  29.  return "success";
  30. }

可在success.jsp中，显示上传的图片

  1. <body>
  2.     ${pageContext.request.contextPath}
  3.  <h1>访问成功！</h1>
  4.  <img src="http://localhost:8088/springmvc_day02_fileuploadserver/upload/D7E35E6EDAC94039BDE6533BEFF8F981_02.jpg"/>
  5. </body>

注意：如果抛出异常：returned a response status of 403 Forbidden

出现这个错误的原因是因为我将图片上传单独部署了一个服务器。但是图片不能写入。需要在这个存储图片的项目所在的tomcat中配置可写操作。具体的是在Tomcat目录下的conf文件夹下的web.xml中加入 
加入此行的含义是：接收文件的目标服务器可以支持写入操作。

  1. <servlet>
  2.  <servlet-name>default</servlet-name>
  3.  <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
  4.  <init-param>
  5.  <param-name>debug</param-name>
  6.  <param-value>0</param-value>
  7.  </init-param>
  8.  <init-param>
  9.  <param-name>readonly</param-name>
  10.  <param-value>false</param-value>
  11.  </init-param>
  12.  <init-param>
  13.  <param-name>listings</param-name>
  14.  <param-value>false</param-value>
  15.  </init-param>
  16.  <load-on-startup>1</load-on-startup>
  17.  </servlet>

SpringMVC的异常处理

异常处理思路

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。 系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理

1562427361062

SpringMVC的异常处理

坐标

  1. <!-- 版本锁定 -->
  2. <properties>
  3.  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  4.  <maven.compiler.source>1.8</maven.compiler.source>
  5.  <maven.compiler.target>1.8</maven.compiler.target>
  6.  <spring.version>5.0.2.RELEASE</spring.version>
  7. </properties>
  9. <dependencies>
  10.  <dependency>
  11.  <groupId>org.springframework</groupId>
  12.  <artifactId>spring-context</artifactId>
  13.  <version>${spring.version}</version>
  14.  </dependency>
  16.  <dependency>
  17.  <groupId>org.springframework</groupId>
  18.  <artifactId>spring-web</artifactId>
  19.  <version>${spring.version}</version>
  20.  </dependency>
  22.  <dependency>
  23.  <groupId>org.springframework</groupId>
  24.  <artifactId>spring-webmvc</artifactId>
  25.  <version>${spring.version}</version>
  26.  </dependency>
  28.  <dependency>
  29.  <groupId>javax.servlet</groupId>
  30.  <artifactId>servlet-api</artifactId>
  31.  <version>2.5</version>
  32.  <scope>provided</scope>
  33.  </dependency>
  35.  <dependency>
  36.  <groupId>javax.servlet.jsp</groupId>
  37.  <artifactId>jsp-api</artifactId>
  38.  <version>2.0</version>
  39.  <scope>provided</scope>
  40.  </dependency>
  42.  <dependency>
  43.  <groupId>jstl</groupId>
  44.  <artifactId>jstl</artifactId>
  45.  <version>1.2</version>
  46.  </dependency>
  47. </dependencies>

web.xml

  1. <!-- SpringMVC的核心控制器 -->
  2. <servlet>
  3.  <servlet-name>dispatcherServlet</servlet-name>
  4.  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5.  <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
  6.  <init-param>
  7.  <param-name>contextConfigLocation</param-name>
  8.  <param-value>classpath:springmvc.xml</param-value>
  9.  </init-param>
  10.  <!-- 配置servlet启动时加载对象 -->
  11.  <load-on-startup>1</load-on-startup>
  12. </servlet>
  13. <servlet-mapping>
  14.  <servlet-name>dispatcherServlet</servlet-name>
  15.  <url-pattern>/</url-pattern>
  16. </servlet-mapping>
  18. <!--配置解决中文乱码过滤器-->
  19. <filter>
  20.  <filter-name>characterEncodingFilter</filter-name>
  21.  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  22.  <init-param>
  23.  <param-name>encoding</param-name>
  24.  <param-value>utf-8</param-value>
  25.  </init-param>
  26. </filter>
  27. <filter-mapping>
  28.  <filter-name>characterEncodingFilter</filter-name>
  29.  <url-pattern>/*</url-pattern>
  30. </filter-mapping>

springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.  xsi:schemaLocation="
  7.         http://www.springframework.org/schema/beans
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd
  9.         http://www.springframework.org/schema/mvc
  10.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  11.         http://www.springframework.org/schema/context
  12.         http://www.springframework.org/schema/context/spring-context.xsd">
  13.  <context:component-scan base-package="com.le.controller"/>
  15.  <!--视图解析器-->
  16.  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  17.  <property name="prefix" value="/WEB-INF/pages/"></property>
  18.  <property name="suffix" value=".jsp"></property>
  19.  </bean>
  21.  <mvc:annotation-driven></mvc:annotation-driven>
  23.  <!-- 设置静态资源不过滤 -->
  24.  <mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
  25.  <mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
  26.  <mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->
  28. </beans>

导入index.jsp

  1. <body>
  2. <a href="user/testException">异常处理</a>
  3. </body>

UserController.java

  1. @Controller
  2. @RequestMapping(path = "/user")
  3. public class UserController {
  5.  // 自定义异常处理
  6.  @RequestMapping(path="/testException")
  7.  public String testException(){
  8.  System.out.println("执行了testException方法！");
  9.  int a = 10/0;
  10.  return "success";
  11.  }
  12. }

WEB-INF/pages/success.jsp

  1. <body>
  2. <h1>访问成功！</h1>
  3. </body>

1562427472222

自定义异常类

创建包com.le.exception，创建类SysException.java。

  1. /**
  2. * 自定义异常类
  3. */
  4. public class SysException extends Exception {
  6.  // 异常提示信息
  7.  private String message;
  9.  public String getMessage() {
  10.  return message;
  11.  }
  12.  public void setMessage(String message) {
  13.  this.message = message;
  14.  }
  15.  public SysException(String message) {
  16.  this.message = message;
  17.  }
  18. }

编写异常处理器

创建包com.le.exception，创建类SysExceptionResolver.java。

  1. /**
  2. * 编写异常处理器
  3. */
  4. public class SysExceptionResolver implements HandlerExceptionResolver {
  6.  /**
  7.      * 跳转到具体的错误页面的方法
  8.      */
  9.  @Override
  10.  public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, @Nullable Object o, Exception e) {
  11.         e.printStackTrace();
  12.  SysException se = null;
  13.  // 获取到异常对象
  14.  if(e instanceof SysException) {
  15.             se = (SysException) e;
  16.  }else {
  17.             se = new SysException("请联系管理员");
  18.  }
  19.  ModelAndView mv = new ModelAndView();
  20.  // 存入错误的提示信息
  21.         mv.addObject("message", se.getMessage());
  22.  // 跳转的Jsp页面
  23.         mv.setViewName("error");// 跳转到WEB-INF/pages/error.jsp
  24.  return mv;
  25.  }
  26. }

配置异常处理器（跳转到错误提示页面）

springmvc.xml

  1. <!-- 配置异常处理器 -->
  2. <bean id="sysExceptionResolver" class="com.le.exception.SysExceptionResolver"/>

修改UserController.java

  1. // 自定义异常处理
  2. @RequestMapping(path="/testException")
  3. public String testException() throws SysException{
  4.  System.out.println("执行了testException方法！");
  5.  try {
  6.  int a = 10/0;
  7.  } catch (Exception e) {
  8.  // 在控制台打印
  9.         e.printStackTrace();
  10.  throw new SysException("服务器繁忙，稍后再试...");
  11.  }
  12.  return "success";
  13. }

指定error.jsp错误页面

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
  2. <html>
  3. <head>
  4.  <title>Title</title>
  5. </head>
  6. <body>
  7. <h1>访问失败</h1>
  8. ${message}<br>
  9. </body>
  10. </html>

SpringMVC中的拦截器

拦截器的作用

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

用户可以自己定义一些拦截器来实现特定的功能（权限控制、日志处理等）。

谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

说到这里，可能大家脑海中有了一个疑问，这不是我们之前学的过滤器吗？是的它和过滤器是有几分相似，但是也有区别，接下来我们就来说说他们的区别：

过滤器和拦截器的区别：

区别1：

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

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

区别2：

过滤器在url-pattern中配置了/*之后，可以对所有要访问的资源拦截。

拦截器它是只会拦截访问的控制器方法（只会拦截Controller）

核心控制器设置成/，表示拦截所有请求

核心控制器设置成.do（.action），表示拦截.do结尾的url请求

要求必须实现：HandlerInterceptor接口。

1562427681113

自定义拦截器

坐标

  1. <!-- 版本锁定 -->
  2. <properties>
  3.  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  4.  <maven.compiler.source>1.8</maven.compiler.source>
  5.  <maven.compiler.target>1.8</maven.compiler.target>
  6.  <spring.version>5.0.2.RELEASE</spring.version>
  7. </properties>
  10. <dependencies>
  11.  <dependency>
  12.  <groupId>org.springframework</groupId>
  13.  <artifactId>spring-context</artifactId>
  14.  <version>${spring.version}</version>
  15.  </dependency>
  17.  <dependency>
  18.  <groupId>org.springframework</groupId>
  19.  <artifactId>spring-web</artifactId>
  20.  <version>${spring.version}</version>
  21.  </dependency>
  23.  <dependency>
  24.  <groupId>org.springframework</groupId>
  25.  <artifactId>spring-webmvc</artifactId>
  26.  <version>${spring.version}</version>
  27.  </dependency>
  29.  <dependency>
  30.  <groupId>javax.servlet</groupId>
  31.  <artifactId>servlet-api</artifactId>
  32.  <version>2.5</version>
  33.  <scope>provided</scope>
  34.  </dependency>
  36.  <dependency>
  37.  <groupId>javax.servlet.jsp</groupId>
  38.  <artifactId>jsp-api</artifactId>
  39.  <version>2.0</version>
  40.  <scope>provided</scope>
  41.  </dependency>
  43.  <dependency>
  44.  <groupId>jstl</groupId>
  45.  <artifactId>jstl</artifactId>
  46.  <version>1.2</version>
  47.  </dependency>
  48. </dependencies>

web.xml

  1. <!-- SpringMVC的核心控制器 -->
  2. <servlet>
  3.  <servlet-name>dispatcherServlet</servlet-name>
  4.  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5.  <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 -->
  6.  <init-param>
  7.  <param-name>contextConfigLocation</param-name>
  8.  <param-value>classpath:springmvc.xml</param-value>
  9.  </init-param>
  10.  <!-- 配置servlet启动时加载对象 -->
  11.  <load-on-startup>1</load-on-startup>
  12. </servlet>
  13. <servlet-mapping>
  14.  <servlet-name>dispatcherServlet</servlet-name>
  15.  <url-pattern>/</url-pattern>
  16. </servlet-mapping>
  18. <!--配置解决中文乱码过滤器-->
  19. <filter>
  20.  <filter-name>characterEncodingFilter</filter-name>
  21.  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  22.  <init-param>
  23.  <param-name>encoding</param-name>
  24.  <param-value>utf-8</param-value>
  25.  </init-param>
  26. </filter>
  27. <filter-mapping>
  28.  <filter-name>characterEncodingFilter</filter-name>
  29.  <url-pattern>/*</url-pattern>
  30. </filter-mapping>

springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:mvc="http://www.springframework.org/schema/mvc"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.  xsi:schemaLocation="
  7.         http://www.springframework.org/schema/beans
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd
  9.         http://www.springframework.org/schema/mvc
  10.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
  11.         http://www.springframework.org/schema/context
  12.         http://www.springframework.org/schema/context/spring-context.xsd">
  13.  <context:component-scan base-package="com.le.controller"/>
  15.  <!--视图解析器-->
  16.  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  17.  <property name="prefix" value="/WEB-INF/pages/"></property>
  18.  <property name="suffix" value=".jsp"></property>
  19.  </bean>
  21.  <mvc:annotation-driven></mvc:annotation-driven>
  23.  <!-- 设置静态资源不过滤 -->
  24.  <mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
  25.  <mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
  26.  <mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->
  28. </beans>

UserController.java

  1. @Controller
  2. @RequestMapping(path = "/user")
  3. public class UserController {
  5.  // 自定义拦截器
  6.  @RequestMapping(path="/testInterceptor")
  7.  public String testInterceptor(){
  8.  System.out.println("执行了testInterceptor方法！");
  9.  return "success";
  10.  }
  11. }

index.jsp

  1. <body>
  2. <a href="user/testInterceptor">自定义拦截器</a>
  3. </body>

WEB-INF/pages/success.jsp

  1. <body>
  2. <h1>访问成功</h1>
  3. </body>

自定义拦截器

创建包com.le.interceptor，创建类MyInterceptor1.java，实现HandlerInterceptor接口

  1. public class MyInterceptor1 implements HandlerInterceptor{
  3.  /**
  4.      * controller方法执行前，进行拦截的方法
  5.      * return true放行
  6.      * return false拦截
  7.      *   可以使用转发或者重定向直接跳转到指定的页面。
  8.      */
  9.  @Override
  10.  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  11.  System.out.println("访问Controller类之前执行...");
  12.  return true;
  13.  }
  14. }

配置拦截器类

在springmvc.xml中配置拦截器类

  1. <!--配置拦截器类-->
  2. <mvc:interceptors>
  3.  <mvc:interceptor>
  4.  <!-- 哪些方法进行拦截 -->
  5.  <mvc:mapping path="/user/*"/>
  6.  <!--哪些方法不进行拦截-->
  7.  <!--<mvc:exclude-mapping path="/user/save"/>-->
  8.  <!-- 注册拦截器对象 -->
  9.  <bean class="com.le.interceptor.MyInterceptor1"></bean>
  10.  </mvc:interceptor>
  11. </mvc:interceptors>

在success.jsp中添加：

  1. <body>
  2. <h1>访问成功</h1>
  3. <%
  4.  System.out.println("浏览器success.jsp执行...");
  5. %>
  6. </body>

1562427963457

HandlerInterceptor接口中的方法

1：preHandle方法是controller方法执行前拦截的方法

​ 可以使用request或者response跳转到指定的页面

​ return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。

​ return false不放行，不会执行controller中的方法。

2：postHandle是controller方法执行后执行的方法，在JSP视图执行前。

​ 可以使用request或者response跳转到指定的页面

​ 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。

3：afterCompletion方法是在JSP执行后执行（用的不多）

​ request或者response不能再跳转页面了，否则抛出异常。

修改：MyInterceptor.java

  1. public class MyInterceptor1 implements HandlerInterceptor{
  3.  /**
  4.      * controller方法执行前，进行拦截的方法（预处理）
  5.      * return true放行
  6.      * return false拦截
  7.      *   可以使用转发或者重定向直接跳转到指定的页面。
  8.      */
  9.  @Override
  10.  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  11.  System.out.println("MyInterceptor1访问Controller类之前执行...");
  12. //        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
  13.  return true;
  14.  }
  16.  /**
  17.      * controller方法执行后，进行拦截的方法（后处理），success.jsp执行之前
  18.      *   可以使用转发或者重定向直接跳转到指定的页面。
  19.      */
  20.  @Override
  21.  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
  22.  System.out.println("MyInterceptor1访问Controller类之后执行...");
  23. //        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
  24.  }
  26.  /**
  27.      *  success.jsp执行之后，该方法执行（终处理）
  28.      */
  29.  @Override
  30.  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
  31.  System.out.println("MyInterceptor1访问success.jsp之后...");
  32.  }
  33. }

1562428083605

配置多个拦截器

再编写一个拦截器的类MyInterceptor2.java

  1. public class MyInterceptor2 implements HandlerInterceptor{
  3.  /**
  4.      * controller方法执行前，进行拦截的方法（预处理）
  5.      * return true放行
  6.      * return false拦截
  7.      *   可以使用转发或者重定向直接跳转到指定的页面。
  8.      */
  9.  @Override
  10.  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  11.  System.out.println("MyInterceptor2访问Controller类之前执行...");
  12. //        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
  13.  return true;
  14.  }
  16.  /**
  17.      * controller方法执行后，进行拦截的方法（后处理），success.jsp执行之前
  18.      *   可以使用转发或者重定向直接跳转到指定的页面。
  19.      */
  20.  @Override
  21.  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
  22.  System.out.println("MyInterceptor2访问Controller类之后执行...");
  23. //        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
  24.  }
  26.  /**
  27.      *  success.jsp执行之后，该方法执行（终处理）
  28.      */
  29.  @Override
  30.  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
  31.  System.out.println("MyInterceptor2访问success.jsp之后...");
  32.  }
  33. }

配置2个拦截器

  1. <!--配置拦截器类-->
  2. <mvc:interceptors>
  3.  <mvc:interceptor>
  4.  <!-- 哪些方法进行拦截 -->
  5.  <mvc:mapping path="/user/*"/>
  6.  <!--哪些方法不进行拦截-->
  7.  <!--<mvc:exclude-mapping path="/user/save"/>-->
  8.  <!-- 注册拦截器对象 -->
  9.  <bean class="com.le.interceptor.MyInterceptor1"></bean>
  10.  </mvc:interceptor>
  11.  <mvc:interceptor>
  12.  <!-- 哪些方法进行拦截 -->
  13.  <mvc:mapping path="/**"/>
  14.  <!--哪些方法不进行拦截-->
  15.  <!--<mvc:exclude-mapping path="/user/save"/>-->
  16.  <!-- 注册拦截器对象 -->
  17.  <bean class="com.le.interceptor.MyInterceptor2"></bean>
  18.  </mvc:interceptor>
  19. </mvc:interceptors>

1562428164713

使用拦截器处理“权限控制”，例如，存在session就能访问Controller，不存在session不能访问Controller

posted @ 2019-07-06 23:54  不穿格子衫的徍爺  阅读(156)  评论(0)  编辑  收藏  举报