zoukankan      html  css  js  c++  java

  • 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:UserszhyDesktopfileupload_demofile.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
  • 相关阅读:
    亚信防毒墙网络版卸载
    Ubuntu之apt
    Python（00）：内存中读写数据StringIO和BytesIO
    Windows使用cmd命令行中查看、修改、删除与添加环境变量
    微信小程序教程
    微信小程序之云开发
    微信小程序-简易计算器
    第一个微信小程序——实现获取用户信息替换用户名和头像到首页
    Python（00）：RSA加解密
    Python（00）：使用selenium模块
  • 原文地址：https://www.cnblogs.com/leccoo/p/11144769.html
Copyright © 2011-2022 走看看