首页 > 其他分享 >SpringMVC 学习记录

SpringMVC 学习记录

时间：2022-11-17 22:37:11浏览次数：41  
标签：RequestMapping return String 记录 SpringMVC 视图 学习 public 请求

SpringMVC

什么是MVC
MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M: Model, 模型层，指工程中的avaBean,作用是处理数据
JavaBean分为两类:
一类称为实体类Bean:专存储业务数据的,如Student、 User等
一类称为业务处理Bean:指Service或Dao对象，专用于处理业务逻辑和数据访问。
V： View, 视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C： Controller, 控制层，指工程中的servlet,作用是接收请求和响应浏览器
MVC的工作流程:
用户通过视图层发送请求到服务器，在服务器中请求被Controller接收, Controller调用相应的Mode层处理请求,处理完毕将结果返回到Controller, Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器

什么是SpringMVC
SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为Java EE项目表述层开发的首选方案。
注: 三层架构分为表述层(或表示层)、业务逻辑层、数据访问层,表述层表示前台页面和后台servlet

SpringMVC的特点
Spring 家族原生产品，与IOC容器等基础设施无缝对接
基于原生的Servlet, 通过了功能强大的前端控制器DispatcherServlet,对请求和响应进行统一处理
表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
代码清新简洁，大幅度提升开发效率
内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
性能卓著,尤其适合现代大型、超大型互联网项目要求

开始

  • 创建maven工程

  • 打包方式为war

    <packaging>war</packaging>

  • 引入依赖
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.20</version>
</dependency>

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

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

<!--    thymeleaf和spring5 整合包-->
<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring5</artifactId>
    <version>3.0.11.RELEASE</version>
</dependency>
  • 请求拦截

符合规则的请求都被Spring的DispatcherServlet处理

<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

/与/*有区别，/无法处理.jsp，因为tomcat的web.xml配置过jsp的请求拦截，/ *可以拦截所有请求包括jsp

SpringMVC的配置文件默认的位置和名称:

位置: WEB- INF下

名称: <servlet - name>-servlet . xml，当前配置下的配置文件名为SpringMVC- servlet . xml

自定义配置文件位置、服务器启动时初始化DispatcherServlet

<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath:SpringMVC-servlet.xml</param-value>
    </init-param>
<!--        DispatcherServlet load on startup 服务器启动时初始化-->
    <load-on-startup>1</load-on-startup>
</servlet>
...

创建配置文件SpringMVC- servlet . xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!--    开启组件扫描-->
    <context:component-scan base-package="com.learn"/>

<!--    thymeleaf视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!--视图前缀-->
                        <property name="prefix" value="/templates/"/>
                        <!--视图后缀-->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

处理静态资源，例如html、js、 css、 jpg，若只设置该标签,则只能访问静态资源，其他请求则无法访问，此时必须设置<mvc:annotation-driven/>解决问题

<mvc:default-servlet-handler/>
<mvc:annotation-driven>
    <mvc:message-converters>
        <!--处理响应中文乱码-->
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <property name="defaultCharset" value="UTF-8"/>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

配置tomcat服务器

编写页面

web-app/templates/index.hml

编写HelloController

@Controller
public class HelloController {
    @RequestMapping("/")
    public String helloIndex(){
        // 返回逻辑视图
        return "index";
    }
}

运行服务器，访问tomcat配置的URL，如http://localhost:8080/

@RequestMapping

概要

  • 作用：将请求和处理请求的控制器方法关联起来，建立映射关系

  • SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

  • 注解位置：

    • 类: 设置映射请求的请求路径的初始信息
    • 法: 设置映射请求请求路径的具体信息

  • 参数，@RequestMapping("/test") <=> @RequestMapping(value = "/test")

public @interface RequestMapping{
    String name() default "";
    @AliasFor("path")
    String[] value() default {};
    @AliasFor("value")
    String[] path() default {};// 当前浏览器所发送请求的请求路径匹配value属性中的任何一个值则当前请求就会被注解所标识的方法进行处理
    RequestMethod[] method() default {};// 请求方式 GET POST PUT DELETE HEAD OPTIONS PATCH TRACE,匹配任意一种将被处理,他们也有自己的mapping如@GetMapping
    String[] params() default {};
    // "username":表示当前所匹配请求的请求参数中必须携带username参数
    // '!username": 表示当前所匹配请求的请求参数中一定不能携带username参数
    // "username=123":表示当前所匹配请求的请求参数中必须携带username参数且值必须为123
    // "username!=456":表示当前所匹配请求的请求参数中可以不携带username,若携带值一定不能是456
    String[] headers() default {};
    // "Referer":要求请求映射所匹配的请求必须携带Referer请求头信息
    // "!Referer":要求请求映射所匹配的请求必须不能携带Referer请求头信息
    // "Referer=aaa":要求请求映射所匹配的请求必须携带header请求头信息且Referer=aaa
    // "Referer!=bbb":要求请求映射所匹配的请求必须携带header请求头信息且Referer!=bbb
    String[] consumes() default {};
    String[] produces() default {};
}

@Controller
@RequestMapping("/main")
public class HelloController {
    @RequestMapping("/index")  // http://localhost:8080/main/index
    public String helloIndex(){
        return "index";
    }

    @RequestMapping("/hello")  // http://localhost:8080/main/hello
    public String toHello(){
        return "hello";
    }
}

@Controller
public class HelloController {
    @RequestMapping("/")  // http://localhost:8080/
    public String helloIndex(){
        return "index";
    }
    @RequestMapping("/hello")  // http://localhost:8080/hello
    public String toHello(){
        return "hello";
    }
}

为什么"/"可以匹配到 http://localhost:8080/ ?这与你配置tomcat服务器时设置的URL有关

若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到

Ant风格

  • ?：表示任意的单个字符
  • *：表示任意的0个或多个字符
  • **：表示任意层数的任意目录 如：/**/test 可以匹配到 /do/test 和 /main/do/test
  • 注意：在使用**时，只能使用/**/xx的方式

RESTful

SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

/back/user/{id}

@Controller
@RequestMapping("/back")
public class BackController {
    @RequestMapping("/user/{id}")  
    public String getUser(@PathVariable("id")Integer userId){// 路径拿到参数id的值赋值给userId
        return "info";
    }
    
    @RequestMapping("/user/{param1}/{param2}")
    public String action(@PathVariable("param1")Integer p1,@PathVariable("param2")Integer p2){
        return "action";
    }
}

@RequestBody

public @interface RequestBody {
    boolean required() default true;
}

可以获取请求体信息，使用@RequestBody注解标识控制器方法的形參，当前请求的请求体就会为当前注解所标识的形参赋值

示例

ajax

// ajax
$.ajax({
    url: "/test",
    method: "POST",
    contentType: "application/json;charset=UTF-8",
    data: JSON.stringify({// 需要JSON.stringify()......否则400.....
        name: "张三",
        gender: "123456",
        age: 18
    }), success: function (res) {
        console.log(res)
    }
})

axios

axios.post("/test",{
    name:"张三",
    gender: "男",
    age: 18
}).then(res => {
    console.log(res)
}).catch(err => {
    console.log(err)
})

@RequestMapping(value = "/test",method = RequestMethod.POST)
public void test(@RequestBody User user, HttpServletResponse response) throws IOException {
    System.out.println(user);
    response.getWriter().write(user.toString());
}

除此之外还可以使用Map接收...等等...

// ...
public void test(@RequestBody Map<String,String> map){
	//...
}

踩坑

415异常：Content type 'application/json;charset=UTF-8' not supported.....

02:51:15.601 [http-nio-8080-exec-7] WARN org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver - Resolved [org.springframework.web.HttpMediaTypeNotSupportedException: Content type 'application/json;charset=UTF-8' not supported]
02:51:15.602 [http-nio-8080-exec-7] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 415 UNSUPPORTED_MEDIA_TYPE

需要jackson依赖..........

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jdk8</artifactId>
  <version>2.13.4</version>
</dependency>

@RequestHeader

针对请求头

public @interface RequestHeader {
    @AliasFor("name")
    String value() default "";
    @AliasFor("value")
    String name() default "";
    boolean required() default true;// 必须携带该请求头信息
    String defaultValue() default "\n\t\t\n\t\t\n\ue000\ue001\ue002\n\t\t\t\t\n";
}

将请求头信息和控制器方法的形参绑定

@RequestMapping("/test")
public String test(@RequestHeader("Referer")String referer){
    return "test";
}

@CookieValue

针对cookie

public @interface CookieValue {
    @AliasFor("name")
    String value() default "";
    @AliasFor("value")
    String name() default "";
    boolean required() default true;
    String defaultValue() default "\n\t\t\n\t\t\n\ue000\ue001\ue002\n\t\t\t\t\n";
}

将cookie数据和控制器方法的形参绑定

@RequestMapping("/aaa")
public String aaa(@CookieValue("JSESSIONID")String jSessionId){
    return "aaa";
}

@ResponseBody

public @interface ResponseBody {
}

使用

@RequestMapping(value = "/test")
@ResponseBody
public User test() {
    return new User("zhangsan","男",20);
}

请求：http://localhost:8080/test

响应：{"name":"zhangsan","gender":"男","age":20}

@RestController

@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    @AliasFor(
        annotation = Controller.class
    )
    String value() default "";
}

获取请求参数

一、通过ServletAPI

@RequestMapping("/hello")
public String toHello(HttpServletRequest request){
    String username = request.getParameter("username");
    return "hello";
}

二、通过SpringMVC方式

参数名一致

http://xxx/user?username=123

@RequestMapping("/user")
public String getUser(String username){
    return "info";
}

参数名不一致

@RequestParam
public @interface RequestParam{
    @AliasFor("name")
    String value() default "";// 参数名
    @AliasFor("value")
    String name() default "";
    boolean required() default true;// 必须携带该参数 如@RequestParam(value = "id",required = true)  则请求时必须携带id参数
    String defaultValue() default "\n\t\t\n\t\t\n\ue000\ue001\ue002\n\t\t\t\t\n";// 如：@RequestParam(value = "id", defaultValue = "123") 给id设置默认值为123
}

http://xxx/user?username=123

@RequestMapping("/user")
public String getUser(@RequestParam("username")String user){
    return "info";
}

参数是实体类

@RequestMapping("/user")
public String getUser(User user){
    return "info";
}

请求参数乱码

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter, 但是必须在web.xml中进行注册

在HttpServletRequest获取请求参数之前设置编码，所以，编码过滤在web.xml必须在处理请求之前

示例

http://localhost:8080/hello?name=张三

@RequestMapping("/hello")
public String toHello(String name){
    System.out.println(name);// 此时输出：张三 ，乱码
    return "hello";
}

解决

web.xml

<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>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

forceEncoding：连同响应编码也设置成UTF-8

域对象共享数据

Request

ServletAPI

使用ServletAPI向request域对象共享数据

@RequestMapping("/hello")
public String toHello(HttpServletRequest request){
    request.setAttribute("username", "123");
    return "hello";
}

ModelAndView

使用ModelAndView向request域对象共享数据

  • ModelAndView有Model和View的功能
    • Model：主要用于向请求域共享数据
    • View：主要用于设置视图，实现页面跳转
@RequestMapping("/hello")
public ModelAndView toHello(){
    ModelAndView mv = new ModelAndView();
    // 共享数据
    mv.addObject("msg","hello");
    // 页面跳转
    mv.setViewName("hello");
    return mv;
}

<h2 th:text="${msg}"></h2>

Model

使用Model向request域对象共享数据

@RequestMapping("/hello")
public String toHello(Model model){
    // 共享数据
    model.addAttribute("msg","hello");
    return "hello";
}

<h2 th:text="${msg}"></h2>

ModelMap

与Model类似

@RequestMapping("/hello")
public String toHello(ModelMap modelMap){
    // 共享数据
    modelMap.addAttribute("msg","hello");
    return "hello";
}

<h2 th:text="${msg}"></h2>

Map

@RequestMapping("/hello")
public String toHello(Map<String,Object> map){
    // 共享数据
    map.put("msg","hello");
    return "hello";
}

<h2 th:text="${msg}"></h2>

在底层中，这些类型的形参最终都是通过BindingAwareModelMap创建

Session

示例

@RequestMapping("/hello")
public String toHello(HttpSession session){
    session.setAttribute("msg", "hello session");
    return "hello";
}

 <h2 th:text="${session.msg}"></h2>

钝化与活化

勾上框框即可

Application

@RequestMapping("/hello")
public String toHello(HttpSession session){
    ServletContext servletContext = session.getServletContext();
    // 共享数据
    servletContext.setAttribute("msg", "hello application");
    return "hello";
}

 <h2 th:text="${application.msg}"></h2>

View

SpringMVC中的视图是View接口，视图的作用渲染数据,将模型Model中的数据展示给用户
SpringMVC视图的种类很多，默认有转发视图和重定向视图，当工程引入jstI的依赖，转发视图会自动转换为JstIView，若使用的视图技术为Thymeleaf,在SpringMVC的配置文件中配置 了Thymeleaf的视图解析器,由此视图解析器解析之后所得到的是ThymeleafView

SpringMVC视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户，SpringMVC视图的种类很多,默认有转发视图和重定向视图，当工程引入jstl的依赖，转发视图会自动转换为]stIView，若使用的视图技术为Thymeleaf,在SpringMVC的配置 文件中配置了Thymeleaf的视图解析器,由此视图解析器解析之后所得到的是ThymeleafView

thymeleafView

浏览器发送请求，若请求地址符合前端控制器的url-pattern, 该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件,通过扫描组件找到控制器,将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回-个字符串类型的视图名称,该视图名称会被视图解析器解析,加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面

转发并渲染

@RequestMapping("/")
public String helloIndex(){
    return "index";
}

InternalResourceView

@RequestMapping("/hello")
public String toHello(){
    return "forward:/main/hello";// 转发
}

如果是JSP，需要配置该视图解析器

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"></bean>

RedirectView

重定向

@RequestMapping("/hello")
public String toHello(){
    return "redirect:/main/hello";
}

视图控制器

视图控制器:为当前的请求直接设置视图名称实现页面跳转
若设置视图控制器，则只有视图控制器所设置的请求会被处理，其他的请求将全部404
此时必须在配置一个标签: <mvc :annotation -driven />

<mvc:annotation-driven/>
<mvc:view-controller path="/" view-name="index"/>

RESTful

Representational State Transfer,表现层资源状态转移。

<!--    请求方式过滤，可以使用put和delete-->
<filter>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

以post请求发送，并携带_method参数过去，如果以ajax发送请求，不需要携带_method参数

<a th:href="@{/user}">获取所有用户信息</a>
<a th:href="@{/user/1}">根据ID获取用户信息</a>

<form th:action="@{/user}" method="post">
    <input type="submit" value="添加用户信息"/>
</form>

<form th:action="@{/user}" method="post">
    <input name="_method" type="hidden" value="delete"/>
    <input type="submit" value="删除用户信息"/>
</form>

<form th:action="@{/user}" method="post">
    <input name="_method" type="hidden" value="put"/>
    <input type="submit" value="修改用户信息"/>
</form>

// 查询所有
@RequestMapping("/user")
public String getUsers(){
    return "success";
}
// 查询单个
@RequestMapping("/user/{id}")
public String getUserById(){
    return "success";
}
// 添加
@RequestMapping("/user")
public String addUser(){
    return "success";
}
// 删除
@RequestMapping(value = "/user",method = RequestMethod.DELETE)
public String deleteUser(){
    return "success";
}
// 修改
@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String updateUser(){
    return "success";
}

处理静态资源

<!--处理静态资源，例如html、js、 css、 jpg，若只设置该标签,则只能访问静态资源，其他请求则无法访问，此时必须设置<mvc:default-servlet-handler/>解决问题-->
<mvc:default-servlet-handler/>

文件上传/下载

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文使用ResponseEntity实现下载文件的功能

前置

<!--    文件上传解析器 通过id获取bean，必须设置id为multipartResolver-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.3</version>
</dependency>

下载

@RequestMapping(value = "/test/download")
public ResponseEntity<byte[]> testDownload(HttpSession session) throws IOException {
    ServletContext servletContext = session.getServletContext();
    // 普通项目是out目录   maven是target目录（war包）
    String realPath = servletContext.getRealPath("static" + File.separator + "img");// E:\xxx\learnSpringMvc\target\learnSpringMvc\static\img
    realPath = realPath + File.separator + "test.jpg";
    // 创建流
    FileInputStream inputStream = new FileInputStream(realPath);
    // 字节
    byte[] bytes = new byte[inputStream.available()];// 字节数
    // 流 -->> 字节
    inputStream.read(bytes);
    MultiValueMap<String,String> headers = new HttpHeaders();// 响应头
    // 设置狭隘方式Content-Disposition以附件attachment方式下载
    headers.add("Content-Disposition", "attachment;filename=test.jpg");
    
    HttpStatus statusCode = HttpStatus.OK;// 响应状态码
    // 响应实体对象
    return new ResponseEntity<>(bytes, headers, statusCode);
}

上传

@RequestMapping("/test/upload")
@ResponseBody
public String upload(MultipartFile file, HttpSession session) throws IOException {
    if (file == null) {
        return "获取目标文件失败";
    }
    // 原始文件名
    String originalFilename = file.getOriginalFilename();
    if (originalFilename == null){
        return "获取文件名失败";
    }
    // 截取后缀
    System.out.println(originalFilename);
    if (!originalFilename.contains(".")){
        return "获取文件后缀失败";
    }
    String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
    // 上下文
    ServletContext servletContext = session.getServletContext();
    // 真实路径
    String uploadPath = servletContext.getRealPath("upload");
    // 目录是否存在
    File f = new File(uploadPath);
    if (!f.exists()){
        if (!f.mkdir()) {
            // 创建目录失败
            return "error";
        }
    }
    // 上传文件名
    String finalPath = uploadPath + File.separator + UUID.randomUUID() + suffix;
    System.out.println("上传文件位置：" + finalPath);
    // 上传
    file.transferTo(new File(finalPath));

    return "success";
}

⚠️ 注意前端input的name要与MultipartFile的变量名一致

拦截器

示例

SpringMVC中的拦截器用于拦截控制器方法的执行
SpringMVC中的拦截器需要实现HandlerInterceptor
SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置:

@Component
public class HelloInterceptor implements HandlerInterceptor {
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("渲染完视图之后执行...");
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("控制器方法之后执行...");
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("控制器方法之前执行...");
        return true;// false表示被拦截，不放行
    }
}

<mvc:interceptors>
<!--    bean和ref标签所配置的拦截器默认对DispatcherServlet处理的所有的请求进行拦截-->
<!--        <ref bean="helloInterceptor"/>-->
<!--        精确拦截请求 处理与不处理的路径    /*表示一个层级，并不是所有请求，/**表示所有请求  -->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/bbb"/>
        <ref bean="helloInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

拦截顺序

@Component
public class HelloInterceptor implements HandlerInterceptor {
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("HelloInterceptor afterCompletion...");
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("HelloInterceptor postHandle...");
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("HelloInterceptor preHandle...");
        return false;
    }
}

@Component
public class SecondInterceptor implements HandlerInterceptor {
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("SecondInterceptor afterCompletion...");
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("SecondInterceptor postHandle...");
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("SecondInterceptor preHandle...");
        return true;
    }
}

helloInterceptor preHandle -->> true

secondInterceptor preHandle -->> true

标签：RequestMapping,return,String,记录,SpringMVC,视图,学习,public,请求
From： https://www.cnblogs.com/piggyyy/p/16901245.html

相关文章

  • 学习python-89
    今日学习内容celery介绍它是一个异步任务提交的框架作用：完成异步任务：提高项目的并发量。之前开启线程做，现在用celery做。完成延迟任务完成定时任务架构：消息中......
  • 学习python-Day90
    一、课程板块相关分析以及创建建表思路：有个课程表通过类型字段区分划分不同课，所以这三种课的表字段是是不一样的。一种课设计一张表FreeCourse 免费课程Course 实......
  • JDBC学习笔记
    JDBC学习笔记一.前阶段0.0前章HTMLCSSJS负责结构，表现，行为服务端Tomcat有关的XML语言（可拓展性），可以自定义标签，用于写配置文件的服务器Tomcat的组件Servlet......
  • STA学习记录4-输入输出路径约束
    @目录1输入路径约束2输出路径约束参考1输入路径约束由于STA不能检查不受约束路径上的时序约束，因此需要约束所有路径来进行时序分析当然，如果存在一些输入控制信号，我们......
  • 【C++】如果你准备学习C++,并且有C语言的基础，我希望你能简单的过一遍知识点。
    相关视频——黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili（1-83）我的小站——半生瓜のblog我知道这个视频早已经被很多人学习并且记录​笔记，......
  • C++学习------cstdint头文件的源码学习02---宏定义
    续接上文讲解常见整型的上下限这里事先定义了如下整形的上下限占用位数有符号/无符号上限下限8有符号127-1288无符号255016有符号32767-3276816无符号65535032有符号2147483......
  • std::move() 学习
    转自：https://stackoverflow.com/questions/28595117/why-can-we-use-stdmove-on-a-const-object1.右值int a = 10;左值是有固定的内存地址，&a即左值的地址，我们可以把&......
  • Rust库学习-cipher(简单使用)
    介绍cipher是Rust的一个密码库实践Cargo.toml[dependencies]aes="0.8.2"base64="0.13.1"cipher="0.4.3"main.rsuseaes::cipher::{generic_array::Generic......
  • 面向高效网络渗透测试的强化学习
    一、本文的贡献本文提出并且评估了一个基于人工智能的PT系统————IAPTS，系统利用RL技术来学习和再现PT活动。该模块集成了工业框架，能够在未来类似的测试用例中捕获信息......
  • 2022-2023-1 20221420《计算机基础与程序设计》第十二周学习总结
    作业信息这个作业属于哪个课程：这个作业的要求在：2022-2023-1《计算机基础与程序设计》教学进程-娄老师-博客园(cnblogs.com)这个作业的目标：《C语言程序设计》第......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99