springMVC基础知识

最新推荐文章于 2020-06-28 16:25:05 发布

借汝之光，得以光明

最新推荐文章于 2020-06-28 16:25:05 发布

阅读量2.8k

点赞数 1

分类专栏： SpringMVC 文章标签： springMVC基础知识

本文链接：https://blog.csdn.net/weixin_44588495/article/details/98315044

版权

SpringMVC 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1、简单搭建一个springMVC

项目目录

在这里插入图片描述

引入所需要的依赖

这里我们采用maven工程去管理我们所需要的jar包。在pom.xml中引入我们的依赖。

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
<!--    锁定版本号-->
    <spring.version>5.0.2.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

配置web.xml

这里面配有前端控制器和加载springMVC的配置文件。同时我们一般配置解决中文乱码。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
<!--  配置servlet-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--    加载SpringMVC配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
   <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

springMVC.xml文件

这里需要配置扫描对应的controller注解、配置视图解析器、配置映射处理器、配置处理器适配器、开启注解扫描、过滤静态资源等。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/mvc
             http://www.springframework.org/schema/mvc/spring-mvc.xsd
             http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
        ">
<!--    扫描对应的包-->
    <context:component-scan base-package="com.spring"></context:component-scan>
<!--    视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/>
    </bean>
<!--    映射处理器-->
    <bean class="org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping" abstract="true"/>
<!--    处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter" abstract="true"/>
    <mvc:annotation-driven />
<!--    静态资源-->
    <mvc:resources mapping="/css/*" location="resources/css/"/>
    <mvc:resources mapping="/js/*" location="resources/js/"/>
    <mvc:resources mapping="/images/*" location="resources/images/"/>

</beans>

Controlle类

开启tomcat后就可以扫描找到对应的controller类，通过/con/test找到对应的方法，返回success.jsp页面。

package com.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.UUID;

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test() t {

        return "success";
    }

}

2、请求参数绑定

@RequestMapping注解

这是一个非常重要的注解。这个注解用于用户的请求路径。

作用：用于建立请求URL和处理请求方法之间的对应关系。
如果再二级访问目录没有值的时候表示的默认访问，请求来的路径直接默认执行没有值的方法
当该注解放在类上的时候就表示的是一级访问目录。
当该方法放在方法上的时候就表示是二级访问目录。
属性：
value：用于指定请求的URL。它和path属性的作用是一样的。
method：用于指定请求的方式。

例如：

1、@RequestMapping(path = “/hello”,method = {RequestMethod.POST})params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一摸一样。
2、@RequestMapping(path = “/hello”,method = {RequestMethod.POST},params = {“username”})<a href=“user/hello?username=111”>asdasd </ a>
3、@RequestMapping(path = “hello”,headers = {“Accept”})，headers：发送的请求中必须包含请求头**

请求参数绑定

请求参数的绑定说明
- 绑定机制
  - 表单提交的数据都是k=v格式的，username=111&&password=222
  - SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
  - 要求：提交提交表单的name和参数的名称是相同的
- 支持的数据类型
  - 基本数据类型和字符串类型
  - 实体类型（JavaBean）
  - 集合数据类型（List，map集合等）

基本数据类型和字符串类型

对于普通的基本类型参数，只需要在方法的参数中参数名与前端提交的form表单的name名字一样就可以，传递到后端。

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello")
    public String sayHellow(String username,String password){
        return "success";
    }
}

<form action="user/hello">
    <input type="text" name="username">
    <input type="text" name="password">
    <input type="submit">
</form>

直接就可以获取表单的username和password。

实体类型（JavaBean）

这里面的Account是一个类，类里面包含了username、password、user（对象），有get和set方法，同时user对象有name、和age两个属性，也有get和set方法。这里面需要表单名称和对象属性名称一致。

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello")
    public String sayHellow(Account account){
        System.out.println(account);
        return "success";
    }
}

<form method="post" action="user/hello" >
    <input type="text" name="username">
    <input type="text" name="password">
    <input type="text" name="user.name">
    <input type="text" name="user.age">
    <input type="submit" name="submit">
</form>

集合数据类型（List，map集合等）

这里面的list和map集合，可以通过类似于数组索引的东西进行存储数据。list集合用的是0开始的索引（数组下标），map集合用的制定的字符串形式的索引。
Account类

public class Account implements Serializable {
    private String username;
    private String password;
    private List<User> list;
    private Map<String,User> map;

controller类

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello",headers = {"Accept"})
    public String sayHellow(Account account){
        System.out.println(account);
        return "success";
    }
}

<form method="post" action="user/hello" >
    <input type="text" name="username">
    <input type="text" name="password">
    <input type="text" name="list[0].name">
    <input type="text" name="list[0].age">
    <input type="text" name="map['one'].name">
    <input type="text" name="map['one'].age">
    <input type="submit" name="submit">
</form>

获取原生Servlet的API

对于controller的每一个方法，实际上都是一个servlet。同样的也可以获取原生的api，像写servlet那样进行交互。
直接书写request、response就可以了。

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello",headers = {"Accept"})
    public String sayHellow(HttpServletRequest request, HttpServletResponse response){
        System.out.println(request);
        HttpSession session = request.getSession();
        System.out.println(session);
        ServletContext context = session.getServletContext();
        System.out.println(context);
        System.out.println(response);
        return "success";
    }
}

这些servlet的方法都是可以用的。

response.setContentType("text;html;charset=utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().append(json);

3、SpringMVC 常用注解

@RequestParam

作用：
把请求中指定名称的参数给控制器中的形参赋值
属性：
name：请求参数中的名称
required：请求参数中是否必须提供此参数。默认为true，表示必须提供，如果不提供就报错。
例如：当前台传输的数据的名称与后台参数列表中的名字不一样的时候，就可以用这种方法，这里的name属性和value是一样的。这里name的属性值就是前台传输过来参数的名称。这种避免了两个名字必须一样的问题。

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(@RequestParam(name = "username") String name) {
        return "success";
    }
}

@RequestBody

@RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)；GET方式无请求体，所以使用@RequestBody接收数据时，前端不能使用GET方式提交数据，而是用POST方式进行提交。在后端的同一个接收方法里，@RequestBody与@RequestParam()可以同时使用，@RequestBody最多只能有一个，而@RequestParam()可以有多个。

作用：
用于获取请求体的内容，直接使用得到的是key=value&key=value …结构的数据。get请求方式不适用。
属性：
required：是否必须有请求体。默认值是true，当前取值为true时，get请求方式会报错。如果取值为false，get请求得到的是null。
例如：获取整个请求体的内容。

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(@RequestBody String body) {
        return "success";
    }
}

@PathVariable

作用：
拥有绑定URL中的占位符，例如：url中有/delete/{id}，{id}就是占位符
属性：
value：指定url中的占位符名称。
Restful风格的url
请求路径一样，可以根据不同的请求方式去执行后台的不同方法。
restful风格的url优点：
结构清晰、符合标准、易于理解、容易扩展
测试：localhost:8080/user/hello/10

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test/{sid}")
    public String test(@PathVariable(name = "sid") String id) {
        return "success";
    }
}

@RequestHeader

作用：
用于获取请求消息头
属性：
value：提供消息头名称。
required：是否必须有此消息头。
实际开发中不怎么用。
获取Accept内容。

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(@RequestHeader(value = "Accept") String header) {
        return "success";
    }
}

@CookieValue

作用：
用于指定cookie名称的值传入控制器的方法参数。
属性：
value：cookie名称。
required：是否必须有此cookie。

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(@CookieValue(value = "") String copkie) {
        return "success";
    }
}

@ModelAttribute

作用：
可以修饰方法和参数
1、出现在方法上，表示当前方法会在控制器的方法执行之前，先执行。它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法。
2、出现在参数上，获取指定的数据给参数赋值。
属性：
value：用于获取数据的key。key可以是pojo的属性名称，也可以是map结构的key。
应用场景：当表单提交数据不是完整的实体数据时，保证没有提交数据的字段使用数据库对象原来的数据。
例如：
我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段设置为null，此时就可以使用该注解。
在方法上：

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String sayHellow() {
    	System.out.println("sayHello");
        return "success";
    }
    @ModelAttribute
    public void showUser(){
        System.out.println("showUser");
    }
}

在这里插入图片描述

方法有返回值，返回值会成为下一个方法的对应参数。

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello")
    public String sayHellow(User user){
        System.out.println("sayHello..");
        return "success";
    }
    @ModelAttribute
    public User showUser(String name){
        System.out.println("shouUser..");
        User user = new User():
        user.setName(name);
        user.setAge(10);
        user.setDate(new Date());
        return user;
    }
}

方法无返回值：在这里中被注解的方法先执行，这里呢形参有一个Map集合，我们最后将user对象放入到Map集合中去，之后后执行sayHello方法时在取出来。用的也是一个注解。这里就是用在参数上。

@Controller
@RequestMapping(path = "user")
public class controller {
    @RequestMapping(path = "hello")
    public String sayHellow(@ModelAttribute("aaa") User user){
        System.out.println("sayHello..");
        return "success";
    }
    @ModelAttribute
    public void showUser(String name, Map<String,User> map){
        System.out.println("shouUser..");
        User user = new User():
        user.setName(name);
        user.setAge(10);
        user.setDate(new Date());
        map.put("aaa",user);
    }
}

@SessionAttributes

作用：
用于多次执行控制器方法间的参数共享。
属性：
value：用于指定存入属性的名称。
type：用于指定存入数据的数据类型。
model将值放入到RequestScope中，@SessionAttributes只能修饰类。将该值放入到sessionScope中。

@Controller
@RequestMapping(path = "user")
@SessionAttributes(value = "msg")
public class controller {
    @RequestMapping(path = "hello")
    public String sayHellow(Model model){
        model.addAttribute("msg","1111");
        return "success";
    }
}

清除

@RequestMapping(path = "del")
 public String delSessionAttribute(SessionStatus status){
    status.setComplete();
    return "success";
}

4、返回值类型及响应数据类型

响应返回值之String类型

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

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(){
        System.out.println("test.....");
        return "success";
    }
}

响应返回值之void类型

默认会去找testVoid.jsp这个文件。

@RequestMapping(path = "testVoid")
    public void testVoid(){
        System.out.println("test.....");
        
    }

可以利用请求转发，然后去跳转到success.jsp页面，重定向因为是两次请求，所以无法访问WEB-INF中的内容

@RequestMapping(path = "testVoid")
    public void testVoid(HttpServletRequest request, HttpServletResponse response) throws Exception, IOException {
        System.out.println("test.....");
        //请求转发
//        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
//        重定向
//        response.sendRedirect(request.getContextPath()+"/index.jsp");
//        直接响应
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().print("hello");
        return;
    }
}

响应返回值之ModelAndView类型

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

 @RequestMapping(path = "testModel")
    public ModelAndView testModel(){
        System.out.println("test.....");
        ModelAndView mv = new ModelAndView();
        User user = new User();
        //把user对象存储到mv对象中去，也会把user对象存储到request对象中
        mv.addObject("user",user);
        //跳转到哪个页面
        mv.setViewName("success");
        return mv;
    }

响应之使用forward和redirect进行页面跳转

这两个方法用不了视图解析器，需要自己去写路径。

forward转发：controller方法在提供了String类型的返回值之后，默认就是请求转发。关键字forward。

 @RequestMapping(path = "testString")
    public String testString(){
        System.out.println("test.....");
        //return "forward:/WEB-INF/pages/success.jsp";
        return "redirect:index.jsp";
    }

@ResponseBody响应json数据

我们知道当用户发送一个请求的时候，就会拦截所有的资源，导致的一个问题就是静态资源（img、css、js）也会被拦截到，从而不能被使用。解决问题就是需要配置静态资源不进行拦截，在springMVC.xml配置文件添加如下配置。

mvc:resources标签配置不过滤
获取json数据：利用RequestBody这个注解。
ajax

		$(".btn")[0].onclick = function(){
                $.ajax({
                    type : "post",
                    url : "con/testAjax",
                    cache : false,
                    data : {
                        "username":"hhhh",
                        "password":"bbbb"
                    },
                    dataType : "text",
                    success : function(msg) {
                         var user = JSON.parse(msg);
                         alert(user.username);
                    },
                    error : function(XMLHttpRequest, textStatus, errorThrown) {
                        alert("获取数据失败！");
                    }
                })
            }

有三种获取的方式：

1、简单的，这样可以获取数据。

@RequestMapping(path = "testAjax")
    public String testAjax(User user){
        System.out.println(user);
        return "success";
    }

执行结果：
在这里插入图片描述

2、直接为这个字符串

	@RequestMapping(path = "testAjax")
    public String testAjax(@RequestBody String body){
        System.out.println(body);
        return "success";
    }

在这里插入图片描述

3、导入json的相关jar包

	<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.8</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.8</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>

利用@ResponseBody注解，该注解可以将对象转换成字符串返回给前端的success回调函数。

@RequestMapping(path = "testAjax")
    public @ResponseBody User testAjax(User user){
        System.out.println(user);
        System.out.println(user.getUsername());
        user.setUsername("aaaa");
        user.setPassword("aaaa");
        return user;
    }

在这里插入图片描述

5、实现文件上传

传统方式

必要前提
1、form表单的enctype取值必须是：multipart/form-data（默认值是：application/x-www-form-urlencoded）
2、method属性必须是：post
3、提供一个文件选择域input type=“file”
依赖的jar，借助第三方组件。

	<dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>

过程分析
1、首先必须要有一个前端的页面，这个待会再说，不是重点。
2、上传的文件都是在request请求中的，这个上传的方法之所以要用post是因为如果用get请求的话，会把文件上传的内容全部放在请求的地址中。如果是post请求的话，会将所有的内容放入到请求体之中。
3、然后我们要获取要放入文件的文件路径。判断这个路径是不是存在的，如果是不存在的，那么就创建一个文件夹。
4、解析request对象，这是一个list集合，在这个集合中还含有其他的普通表单项，所以需要判断是不是文件项。
5、获取文件的名称，然后输入到对应的目录下，删除临时文件。

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(HttpServletRequest request) throws Exception {
        //使用fileupload组件完成文件上传
        //上传的位置
        String realPath = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断，该路径是否存在
        File file = new File(realPath);
        if(!file.exists())
            file.mkdir();
//        解析request对象，获取上传文件项
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
//        解析request
        List<FileItem> items = upload.parseRequest(request);
//        遍历
        for(FileItem fileItem:items){
            //进行判断，当前item对象是否是上传文件项。
            if(!fileItem.isFormField()){
                //不是普通表单项
                //获取上传文件的名称
                String filename = fileItem.getName();
//                完成上传
                fileItem.write(new File(realPath,filename));
//                删除临时文件
                fileItem.delete();
            }
        }
        return "success";
    }

}

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2019/6/30
  Time: 0:09
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>文件上传</h3>
<form action="con/test" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload"><br>
    <input type="submit" value="上传">
</form>
</body>
</html>

框架实现文件上传

原理
这里我们自己去配置一个文件解析器，然后可以直接在controller里面获取文件上传项。这里参数中的upload必须和input上传文件标签中的upload是一样的。

在这里插入图片描述

主要代码，我们只需要修改上面的springMVC.xml文件就可以了，这里添加了一个bean，这里的id必须是multipartResolver

	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/>
    </bean>

controller类

@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test(HttpServletRequest request, MultipartFile upload) throws Exception {
        //使用fileupload组件完成文件上传
        //上传的位置
        String realPath = request.getSession().getServletContext().getRealPath("/uploads/");
        //判断，该路径是否存在
        File file = new File(realPath);
        if(!file.exists())
            file.mkdir();
        //获取文件的名字
        String fileName = upload.getOriginalFilename();
        //把文件的名字设置成唯一值
        String uuid = UUID.randomUUID().toString().replace("-","");W
        fileName = uuid+"_"+fileName;
        // 完成上传
        upload.transferTo(new File(realPath,fileName));
        return "success";
    }
}

这里只是解析和上传的时候和之前不太一样。

6、异常处理

编写自定义异常类（做提示信息）
编写异常处理器
配置异常处理器（跳转到提示页面）

主要代码

自定义异常类

package com.spring.exception;

public class SysException extends Exception {
    private String message;

    public SysException(String message) {
        this.message = message;
    }
    @Override
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}

异常处理器，这里的ex就是接收抛出的异常，利用ModelAndView跳转页面。

package com.spring.resolver;

import com.spring.exception.SysException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class SysResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        SysException e = null;
        if(ex instanceof SysException){
            e = (SysException) ex;
        }else{
            e = new SysException("系统正在维护");
        }
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
        mv.setViewName("error");
        return mv;
    }
}

测试类：通过throw向上抛出异常。

package com.spring.controller;

import com.spring.exception.SysException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import java.util.UUID;

@Controller
@RequestMapping(path = "con")
public class controller {
    @RequestMapping(path = "test")
    public String test() throws  Exception{
        try {
            int a = 10 / 0;
        } catch (Exception e) {
            e.printStackTrace();
            throw new SysException("出错了.....");
        }

        return "success";
    }

}

配置处理器
springMVC.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/mvc
             http://www.springframework.org/schema/mvc/spring-mvc.xsd
             http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
        ">
    <context:component-scan base-package="com.spring"></context:component-scan>
<!--视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
<!--    配置异常处理器-->
    <bean id="sysResolver" class="com.spring.resolver.SysResolver"></bean>
    <mvc:annotation-driven />

</beans>

运行结果

在这里插入图片描述
点击后

7、拦截器

原理

类似于Servlet开发中的过滤器Filter，用于对处理器（controller）进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。
拦截器链就是将拦截器按一定顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

拦截器和过滤器的区别

过滤器是servlet规范中的一部分，任何java web工程都可以使用。
拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能用。
过滤器在url-pattern中配置了/*之后，可以对所有要访问的资源所拦截。
拦截器只会拦截访问的控制器方法，如果访问的是jsp，html，css，image或者js是不会进行拦截的。

自定义拦截器的步骤

第一步，编写一个普通类实现HandlerInterceptor接口

package com.spring.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Interceptor implements HandlerInterceptor {
    //预处理，controller方法执行之前，return 为true是放行执行下一个拦截器，如果没有，执行controller中的代码
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("interceptor的preHandle执行了");
        return true;
    }
}

第二步，配置拦截器

springMVC.xml

<!--    配置异拦截器-->
    <mvc:interceptors>
<!--        配置具体的拦截器-->
        <mvc:interceptor>
<!--            具体拦截哪一个方法-->
            <mvc:mapping path="/con/*"/>
<!--            配置拦截器类-->
            <bean class="com.spring.interceptor.Interceptor" />
<!--            不要拦截哪个方法-->
<!--            <mvc:exclude-mapping path=""/>-->
        </mvc:interceptor>

运行结果

在这里插入图片描述

HandlerInterceptor其余的三个方法

上述将了第一个方法这里再次回顾一下

preHandle方法是controller方法执行前拦截的方法
可以使用request或者response跳转到指定的页面
return true放行，执行下一个拦截器，如果没有就执行controller中的方法。
return false不放行，不会执行controller中的方法。
postHandle方法是controller方法执行后执行的方法，在jsp视图执行前
可以使用request或者response跳转到指定的页面
如果制定了跳转页面，那么，controller方法跳转的页面将不会显示
afterCompletion方法在jsp执行后执行
rerequest或者response不能跳转到指定的页面

配置多个拦截器

在创建一个拦截器类。然后配置，这里的执行顺序是Interceptor的preHandle --> Interceptor1的preHandle --> controller方法 —>Interceptor1的postHandle --> Interceptor的postHandle -->Interceptor1的afterCompletion --> Interceptor的afterCompletion

 <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/con/*"/>
            <bean class="com.spring.interceptor.Interceptor" />
        </mvc:interceptor>

        <mvc:interceptor>
            <mvc:mapping path="/con/*"/>
            <bean class="com.spring.interceptor.Interceptor1" />
        </mvc:interceptor>

    </mvc:interceptors>