精华内容
下载资源
问答
  • RequestMapping

    2020-07-31 23:10:04
    一、@RequestMapping 映射请求注解 SpringMVC 使用 @RequestMapping 注解为控制器指定可以处理哪些 URL 请求 在控制器的类定义及方法定义处都可标注 @RequestMapping 标记在类上:提供初步的请求映射信息。相对于 ...

    一、@RequestMapping 映射请求注解

    SpringMVC 使用 @RequestMapping 注解为控制器指定可以处理哪些 URL 请求
    在控制器的类定义及方法定义处都可标注 @RequestMapping
    标记在类上:提供初步的请求映射信息。相对于 WEB 应用的根目录
    标记在方法上:提供进一步的细分映射信息。相对于标记在类上的 URL
    若类上未标注 @RequestMapping,则方法处标记的 URL 相对于 WEB 应用的根目录

    作用:DispatcherServlet 截获请求后,就通过控制器上 @RequestMapping 提供的映射信息确定请求所对应的处理方法。

    二、@ RequestMapping源码参考

    package org.springframework.web.bind.annotation;
    
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping {
        //映射请求的名称
        String[] value() default {};
        //指定请求方式,POST、GET等
        RequestMethod[] method() default {};
        //请求参数
        String[] params() default {};
        //请求头
        String[] headers() default {};
        
        String[] consumes() default {};
        
        String[] produces() default {};
    }

    三、定义控制器方法

    @Controller  //声明Bean对象,为一个控制器组件
    @RequestMapping("/springmvc") //为当前类的所有请求地址指定一个基准路径
    public class HelloWorldController {
        //映射请求的名称:用于客户端请求;类似Struts2中action映射配置的,action名称
        //1、使用 @RequestMapping 注解来映射请求的 URL
        //2、返回值会通过视图解析器解析为实际的物理视图
        //对于 InternalResourceViewResolver 视图解析器,会做如下的解析:
        //1、通过 prefix + returnVal + 后缀 这样的方式得到实际的物理视图
        //2、做转发操作 "/WEB-INF/views/success.jsp"
        @RequestMapping(value="/helloworld")
        public String helloworld(){
            System.out.println("hello,world");
            return "success"; //结果如何跳转呢?需要配置映射解析器
        }        
    }

    四、RequestMapping映射请求方式

    1、标准的 HTTP 请求报头
    在这里插入图片描述
    2、RequestMapping 属性映射请求参数、请求方法或请求头
    @RequestMapping 除了可以使用请求 URL 映射请求外,还可以使用请求方法、请求参数及请求头映射请求

    @RequestMapping属性:他们之间是与的关系,联合使用多个条件可让请求映射更加精确化
    value:请求 URL(重要)
    method:请求方法(重要)限定请求方式,如GET、POST等
    params:请求参数(支持简单的表达式)
    heads:请求头的映射条件(支持简单的表达式)
    consumes:只接受内容类型是何种的请求,即规定请求头中的
    content-typeproduces:告知浏览器要返回的内容是什么,即给响应头中加上 content-type

    五、value & method 映射请求 URL 和 请求方法

    定义控制器方法

    @Controller
    @RequestMapping("/springmvc")
    public class SpringMVCController {
        //指定只接受 POST 请求方式
        //默认为全接受
        @RequestMapping(value="/testMethord", method=RequestMethod.POST)
        public String testMethord(){
            System.out.println("testMethord...");
            return "success";
        }
    }

    以get方式请求发生请求错误405

    <a herf="springmvc/testMethord">testMethord</a>

    在这里插入图片描述
    以post方式请求成功

    <from action="springmvc/testMethord" method="post">
        <input type="submit" value="submit">
    </from>
    展开全文
  • requestmapping

    2017-06-16 10:18:13
     //@RequestMapping("hello") //请求映射注解 //@RequestMapping(value="/hello.do") //@RequestMapping(value="/hello.do", method=RequestMethod.GET) @RequestMapping(value="/hello.do", metho

    功能:请求映射

    写法

            //@RequestMapping("hello") //请求映射注解
    //@RequestMapping(value="/hello.do")
    //@RequestMapping(value="/hello.do", method=RequestMethod.GET)
    @RequestMapping(value="/hello.do", method={RequestMethod.GET , RequestMethod.POST})



    注意:浏览器直接写url或者a标签都是get请求

    一般情况下,form表单提交的是post请求,ajax请求指定post请求


    如果两个controller类中(UserController StudentController),有相同的方法,则可以在方类前加@requestMapping("/user") @requestMapping("/student"),在访问方法的时候,加上根路径

    展开全文
  • @RequestMapping用法详解

    万次阅读 多人点赞 2018-11-30 15:29:13
    在Spring MVC 中使用 @RequestMapping 来映射请求,也就是通过它来指定控制器可以处理哪些URL请求,相当于Servlet中在web.xml中配置 &lt;servlet&gt;  &lt;servlet-name&gt;servletName&lt;/...

     

     

    一、@RequestMapping 简介

    在Spring MVC 中使用 @RequestMapping 来映射请求,也就是通过它来指定控制器可以处理哪些URL请求,相当于Servlet中在web.xml中配置

    <servlet>
        <servlet-name>servletName</servlet-name>
        <servlet-class>ServletClass</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>servletName</servlet-name>
        <url-pattern>url</url-pattern>
    </servlet-mapping>

    的映射作用一致。让我们先看一下RequestMapping注解类的源码:

    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface RequestMapping {
    	String name() default "";
    	String[] value() default {};
    	String[] path() default {};
    	RequestMethod[] method() default {};
    	String[] params() default {};
    	String[] headers() default {};
    	String[] consumes() default {};
    	String[] produces() default {};
    }

    1)在@Target中有两个属性,分别为 ElementType.METHOD 和 ElementType.TYPE ,也就是说 @RequestMapping 可以在方法和类的声明中使用

    2)可以看到注解中的属性除了 name() 返回的字符串,其它的方法均返回数组,也就是可以定义多个属性值,例如 value() 和 path() 都可以同时定义多个字符串值来接收多个URL请求

     

    二、准备工作:(注:后面的示例都将基于准备工作)

    1)新建一个 Web 工程,取名为 SpringMVC 

    2)新建一个的控制器类:UserController

    package cn.kolbe.spring.mvc.controller;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
    
    	public String login() {
    		return "success";
    	}
    }

    3)新建和配置 web.xml 以及 spring-mvc.xml 文件

    略(具体参见 前一章:Spring MVC 学习笔记(一):HelloWorld

    4)新建一个测试的 JSP 页面 index.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Spring MVC</title>
    </head>
    <body>
    	<p> <a href="#">User Login</a>
    </body>
    </html>

    5)新建一个成功跳转的页面 JSP 页面 welcome.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Spring MVC</title>
    </head>
    <body>
    
    	<h1>Welcome</h1>
    
    </body>
    </html>

     

    三、测试 @RequestMapping 中的 value 和 path 属性(这两个属性作用相同,可以互换,如果仅有这一个属性,则可以省略,下面两个例子均采用省略的方式)

    1)将 @RequestMapping 注解在 login 方法上,而UserController上不添加 @RequestMapping 注解,这时的请求 URL 是相对于 Web 根目录

    @Controller
    public class UserController {
    
    	@RequestMapping("/login")
    	public String login() {
    		return "success";
    	}
    }

    这时的方法 login() 能处理的 URL 请求路径是基于 Web 应用的,也就是 http://localhost/SpringMVC/login,也就是 index.jsp 页面中的 User Login 链接地址应该是:

    <a href="login">User Login</a>

     

    2)将 @RequestMapping 注解在 UserController 类上,这时类的注解是相对于 Web 根目录,而方法上的是相对于类上的路径

    @Controller
    @RequestMapping("/user")
    public class UserController {
    
    	@RequestMapping("/login")
    	public String login() {
    		return "success";
    	}
    }

    这时的方法login()能处理的 URL 请求路径则是 http://localhost/SpringMVC/user/login,也就是 index.jsp 页面中的 User Login 链接地址应该是:

    <a href="user/login">User Login</a>

     

    四、测试 @RequestMapping 的 method 属性

    1)简介:@RequestMapping 中的 method 主要用来定义接收浏览器发来的何种请求。在Spring中,使用枚举类

    org.springframework.web.bind.annotation.RequestMethod来定义浏览器请求的方式。

    Http规范定义了多种请求资源的方式,最基本的有四种,分别为:GET(查)、POST(增)、PUT(改)、DELETE(删),而URL则用于定位网络上的资源相当于地址的作用,配合四种请求方式,可以实现对URL对应的资源的增删改查操作。

    在实际应用中,很多人并没有按照这个规范做,因为使用GET/POST同样可以完成PUT和DELETE操作,甚至GET也可以完成POST操作,因为GET不需要用到表单,而POST却需要通过表单来发送。

    2)通过 @RequestMapping(value="/login",method=RequestMethod.GET) 来指定 login()方法 仅处理通过 GET 方式发来的请求

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
    
    	@RequestMapping(path = "/login", method=RequestMethod.GET)
    	public String login() {
    		return "success";
    	}
    }

    这时,如果浏览器发来的请求不是GET的话,将收到浏览器返回的错误提示,也就是得通过链接的方式而不是表单的方式:

    <a href="user/login>User Login</a>

    3)通过 @RequestMapping(value="/login",method=RequestMethod.POST) 来指定 login()方法 仅处理通过 POST 方式发来的请求

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
    
    	@RequestMapping(path = "/login", method=RequestMethod.POST)
    	public String login() {
    		return "success";
    	}
    }

    这时,必须通过表单的方式发送请求,否则将收到浏览器返回的错误提示

    <form action="user/login" method="post">
        <input type="submit" value="使用Post发送请求"/>
    </form>

    4)由于在 RequestMapping 注解类中 method() 方法返回的是 RequestMethod 数组,所以可以给 method 同时指定多个请求方式,例如:

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
            // 该方法将同时接收通过GET和POST方式发来的请求
    	@RequestMapping(path = "/login", method={RequestMethod.POST,RequestMethod.GET})
    	public String login() {
    		return "success";
    	}
    }

     

    五、测试 @RequestMapping 的 params 属性,该属性表示请求参数,也就是追加在URL上的键值对,多个请求参数以&隔开,例如:

    http://localhost/SpringMVC/user/login?username=kolbe&password=123456

    则这个请求的参数为username=kolbe以及password=123456,@RequestMapping 中可以使用 params 来限制请求参数,来实现进一步的过滤请求,举个例子:

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
            
            // 该方法将接收 /user/login 发来的请求,且请求参数必须为 username=kolbe&password=123456
    	@RequestMapping(path = "/login", params={"username=kolbe","password=123456"})
    	public String login() {
    		return "success";
    	}
    }

    该例中则表示 UserController 中的 login() 方法仅处理 /user/login 发来的请求,且必须带有 username=kolbe&password=123456 的请求参数,否则浏览器将返回HTTP 404的错误, 对应 index.jsp 中的键接地址为:

    <a href="user/login?username=kolbe&password=123456">User Login</a>

     

    六、测试 @RequestMapping 的 headers 属性,该属性表示请求头

    用于HTTP协义交互的信息被称为HTTP报文,客户端发送的HTTP报文被称为请求报文,服务器发回给客户端的HTTP报文称为响应报文,报文由报文头部和报文体组成。

    请求头部(Request Headers):请求头包含许多有关客户端环境和请求正文的信息,例如浏览器支持的语言、请求的服务器地址、客户端的操作系统等。

    响应头部(Rsponse Headers):响应头也包含许多有用的信息,包括服务器类型、日期、响应内容的类型及编码,响应内容的长度等等。

    如果你安装的是Chrome浏览器,可以通过在网页中  右击鼠标---->审查元素---->Network---->Name中点击网页---->右侧查看Headers即可,如果Name中没有出现网页,可以刷新一下即可,下边是我电脑中的一个请求头部示例:

    Request Headers
        Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
        Accept-Encoding:gzip, deflate, sdch
        Accept-Language:zh-CN,zh;q=0.8
        Cache-Control:max-age=0
        Connection:keep-alive
        Cookie:JSESSIONID=210075B5E521CWE3CDE938076295A57A
        Host:localhost:8080
        Upgrade-Insecure-Requests:1
        User-Agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.93

    回规正题,通过 @RequestMapping 中的 headers 属性,可以限制客户端发来的请求

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
            // 表示只接收本机发来的请求
    	@RequestMapping(path = "/login", headers="Host=localhost:8080")
    	public String login() {
    		return "success";
    	}
    }

     

    七、带占位符的URL

    (一)带占位符的URL是Spring 3.0 新增的功能,可以通过 @PathVariable 将 URL 中的占位符绑定到控制器的处理方法的参数中,占位符使用{}括起来

    (二)使用方法:

    1)带占位符的URL示例:

    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
            
    	@RequestMapping(value="/{id}", method=RequestMethod.GET)
    	public String show(@PathVariable("id") Integer id) {
    		return "success";
    	}
    }

    在这个控制器中 show() 方法将可以接收 user/1、user/2、user/3等等的路径请求,请求的方法必须为GET,使用 @PathVariable 为应用实现 REST 规范提供了具大的便利条件。

     

    八、采用 REST 风格的 URL 请求

    1)简介:REST(Representational State Transfer):(资源)表现层状态转化,它是目前最流行的一种软件架构,其结构清晰、易于理解、扩展方便且符合标准,正在越来越多的被实践到应用中。

    2)REST 风格的 URL 请求

     请求路径        请求方法           作用
    -/user/1        HTTP GET        得到id为1的user
    -/user/1        HTTP DELETE     删除id为1的user
    -/user/1        HTTP PUT        更新id为1的user
    -/user          HTTP POST       新增user

    3)由于浏览器表单只支持 GET 和 POST 请求,为了实现 DELETE 和 PUT 请求,Spring 为我们提供了一个过滤器org.springframework.web.filter.HiddenHttpMethodFilter,可以为我们将 GET 和 POST 请求通过过滤器转化成 DELETE 和 PUT 请求。

    4)在 web.xml 中配置过滤器

    <!-- 配置 org.springframework.web.filter.HiddenHttpMethodFilter 过滤器 -->
    <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>

    5)由于浏览器表单无法发送 DELETE 和 PUT 请求,所以为了让 HiddenHttpMethodFilter 识别请求的方法,需要在表单中添加一个隐藏域,名字为 _method 值为 DELETE 或 POST 或PUT,修改后 index.jsp 页面代码如下:

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Spring MVC</title>
    </head>
    <body>
    <p>
     	<!-- 得到id为1的user -->
    	<a href="user/1">Test Rest GET</a>
    
    	<!-- 新建id为1的user -->
    	<form action="user" method="post">
    	        <input type="hidden" name="_method" value="POST"/>
    		<input type="submit" value="Test Rest POST"/>
    	</form>
    	
    	<!-- 删除id为1的user -->
    	<form action="user/1" method="post">
    		<input type="hidden" name="_method" value="DELETE"/>
    		<input type="submit" value="Test Rest DELETE"/>
    	</form>
    	
    	<!-- 更新id为1的user -->
    	<form action="user/1" method="post">
    		<input type="hidden" name="_method" value="PUT"/>
    		<input type="submit" value="Test Rest PUT"/>
    	</form>
    
    </body>
    </html>

    6)修改后的UserController代码

    package cn.kolbe.spring.mvc.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    @Controller
    @RequestMapping(path = "/user")
    public class UserController {
    
    	@RequestMapping(value="/{id}", method=RequestMethod.GET)
    	public String show(@PathVariable("id") Integer id) {
    		System.out.println("查看id为:" + id + "的user");
    		return "success";
    	}
    	
    	
    	@RequestMapping(value="/{id}", method=RequestMethod.PUT)
    	public String update(@PathVariable("id") Integer id) {
    		System.out.println("更新id为:" + id + "的user");
    		return "success";
    	}
    	
    	@RequestMapping(value="/{id}", method=RequestMethod.DELETE)
    	public String destroy(@PathVariable("id") Integer id) {
    		System.out.println("删除id为:" + id + "的user");
    		return "success";
    	}
    	
    	@RequestMapping(value="", method=RequestMethod.POST)
    	public String create() {
    		System.out.println("新建user");
    		return "success";
    	}
    }

     

    注:如果你的web项目是运行在Tomcat 8下,你会发现被过滤成DELETE和PUT请求,到达控制器后,返回时(forward)会报HTTP 405的错误提示

    HTTP Status 405 - Request method 'DELETE' not supported
    或
    HTTP Status 405 - JSPs only permit GET POST or HEAD

    有三种解决方案:

    (一)将 Tomcat 8 改为 Tomcat 7,在Tomcat 7 下运行是正常的

    (二)将请求转发(forward)改为请求重定向(redirect)

    (三)自己手动写一个Filter来包装HttpRequest中的getMethod()方法

    下面介绍一下第(三)种做法,也就是自己写一个Filter来包装从服务器发回来的HttpRequest请求:

     

     

     

    大致说一下流程,

    1. 在第1步中,客户端发送请求至服务器,这时如果发送的是POST请求且带有以_method为名的参数会被Spring的HiddenHttpMethodFilter给拦截。

    2. HiddenHttpMethodFilter内有一个静态内部类通过继承HttpServletRequestWrapper类并重写getMethod()方法,将该方法返回值设为_method隐藏域的值。

    3. HiddenHttpMethodFilter在包装好Request后,将请求发往服务器的控制器中对应的方法处理器,这时的请求变成了图中的 3、WrapperRequest by SpringFilter

    4. 服务器处理完请求后,产生了一个forward请求,产生相应的请求处理信息发往客户端,注意这时的request的getMethod()方法仍然是HiddenHttpMethodFilter包装过的

    5. 我们需要在服务器的响应请求到达客户端前进行拦截,这也是最关键的一步,通过自定义过滤器MyHttpMethodFilter进一步包装请求,将getMethod()方法返回值改成POST或GET即可

    6. 在web.xml中配置该filter,注意dispatcher结点值必须为FORWARD。由于字数超限,暂时说到这。。。

    <filter-mapping>
    	<filter-name>myFilter</filter-name>
    	<url-pattern>/*</url-pattern>
    	<dispatcher>FORWARD</dispatcher>
    </filter-mapping>

     

     

     

     

    展开全文
  • RequestMapping的用法(完整)

    万次阅读 多人点赞 2019-05-28 10:25:37
    @RequestMapping 是 Spring Web 应用程序中最常被用到的注解之一。这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上。 在这篇文章中,你将会看到 @RequestMapping 注解在被用来进行 Spring MVC 控制器...

    spring

    @RequestMapping 是 Spring Web 应用程序中最常被用到的注解之一。这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上。 

    在这篇文章中,你将会看到 @RequestMapping 注解在被用来进行 Spring MVC 控制器方法的映射可以如何发挥其多才多艺的功能的。 

    Request Mapping 基础用法 

    在 Spring MVC 应用程序中,RequestDispatcher (在 Front Controller 之下) 这个 servlet 负责将进入的 HTTP 请求路由到控制器的处理方法。 

    在对 Spring MVC 进行的配置的时候, 你需要指定请求与处理方法之间的映射关系。 


    要配置 Web 请求的映射,就需要你用上 @RequestMapping 注解。 

    @RequestMapping 注解可以在控制器类的级别和/或其中的方法的级别上使用。 

    在类的级别上的注解会将一个特定请求或者请求模式映射到一个控制器之上。之后你还可以另外添加方法级别的注解来进一步指定到处理方法的映射关系。 

    下面是一个同时在类和方法上应用了 @RequestMapping 注解的示例: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping("/")  
    5.     String get() {  
    6.         //mapped to hostname:port/home/  
    7.         return "Hello from get";  
    8.     }  
    9.     @RequestMapping("/index")  
    10.     String index() {  
    11.         //mapped to hostname:port/home/index/  
    12.         return "Hello from index";  
    13.     }  
    14. }  


    如上述代码所示,到 /home 的请求会由 get() 方法来处理,而到 /home/index 的请求会由 index() 来处理。 

    @RequestMapping 来处理多个 URI 

    你可以将多个请求映射到一个方法上去,只需要添加一个带有请求路径值列表的 @RequestMapping 注解就行了。 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.   
    5.     @RequestMapping(value = {  
    6.         "",  
    7.         "/page",  
    8.         "page*",  
    9.         "view/*,**/msg"  
    10.     })  
    11.     String indexMultipleMapping() {  
    12.         return "Hello from index multiple mapping.";  
    13.     }  
    14. }  


    如你在这段代码中所看到的,@RequestMapping 支持统配符以及ANT风格的路径。前面这段代码中,如下的这些 URL 都会由 indexMultipleMapping() 来处理: 

    • localhost:8080/home
    • localhost:8080/home/
    • localhost:8080/home/page
    • localhost:8080/home/pageabc
    • localhost:8080/home/view/
    • localhost:8080/home/view/view

    带有 @RequestParam 的 @RequestMapping 

    @RequestParam 注解配合 @RequestMapping 一起使用,可以将请求的参数同处理方法的参数绑定在一起。 

    @RequestParam 注解使用的时候可以有一个值,也可以没有值。这个值指定了需要被映射到处理方法参数的请求参数, 代码如下所示: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.   
    5.     @RequestMapping(value = "/id")  
    6.     String getIdByValue(@RequestParam("id") String personId) {  
    7.         System.out.println("ID is " + personId);  
    8.         return "Get ID from query string of URL with value element";  
    9.     }  
    10.     @RequestMapping(value = "/personId")  
    11.     String getId(@RequestParam String personId) {  
    12.         System.out.println("ID is " + personId);  
    13.         return "Get ID from query string of URL without value element";  
    14.     }  
    15. }  


    在代码的第6行,id 这个请求参数被映射到了 thegetIdByValue() 这个处理方法的参数 personId 上。 

    如果请求参数和处理方法参数的名称一样的话,@RequestParam 注解的 value 这个参数就可省掉了, 如代码的第11行所示。 

    @RequestParam 注解的 required 这个参数定义了参数值是否是必须要传的。 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/name")  
    5.     String getName(@RequestParam(value = "person", required = false) String personName) {  
    6.         return "Required element of request param";  
    7.     }  
    8. }  


    在这段代码中,因为 required 被指定为 false,所以 getName() 处理方法对于如下两个 URL 都会进行处理: 

    • /home/name?person=xyz
    • /home/name

    @RequestParam 的 defaultValue 取值就是用来给取值为空的请求参数提供一个默认值的。 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/name")  
    5.     String getName(@RequestParam(value = "person", defaultValue = "John") String personName) {  
    6.         return "Required element of request param";  
    7.     }  
    8. }  


    在这段代码中,如果 person 这个请求参数为空,那么 getName() 处理方法就会接收 John 这个默认值作为其参数。 

    用 @RequestMapping 处理 HTTP 的各种方法 

    Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。 

    所有的请求默认都会是 HTTP GET 类型的。 

    为了能降一个请求映射到一个特定的 HTTP 方法,你需要在 @RequestMapping 中使用 method 来声明 HTTP 请求所使用的方法类型,如下所示: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(method = RequestMethod.GET)  
    5.     String get() {  
    6.         return "Hello from get";  
    7.     }  
    8.     @RequestMapping(method = RequestMethod.DELETE)  
    9.     String delete() {  
    10.         return "Hello from delete";  
    11.     }  
    12.     @RequestMapping(method = RequestMethod.POST)  
    13.     String post() {  
    14.         return "Hello from post";  
    15.     }  
    16.     @RequestMapping(method = RequestMethod.PUT)  
    17.     String put() {  
    18.         return "Hello from put";  
    19.     }  
    20.     @RequestMapping(method = RequestMethod.PATCH)  
    21.     String patch() {  
    22.         return "Hello from patch";  
    23.     }  
    24. }  


    在上述这段代码中, @RequestMapping 注解中的 method 元素声明了 HTTP 请求的 HTTP 方法的类型。 

    所有的处理处理方法会处理从这同一个 URL( /home)进来的请求, 但要看指定的 HTTP 方法是什么来决定用哪个方法来处理。 

    例如,一个 POST 类型的请求 /home 会交给 post() 方法来处理,而一个 DELETE 类型的请求 /home 则会由 delete() 方法来处理。 

    你会看到 Spring MVC 将使用这样相同的逻辑来映射其它的方法。 

    用 @RequestMapping 来处理生产和消费对象 

    可以使用 @RequestMapping 注解的 produces 和 consumes 这两个元素来缩小请求映射类型的范围。 

    为了能用请求的媒体类型来产生对象, 你要用到 @RequestMapping 的 produces 元素再结合着 @ResponseBody 注解。 

    你也可以利用 @RequestMapping 的 comsumes 元素再结合着 @RequestBody 注解用请求的媒体类型来消费对象。 

    下面这段代码就用到的 @RequestMapping 的生产和消费对象元素: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/prod", produces = {  
    5.         "application/JSON"  
    6.     })  
    7.     @ResponseBody  
    8.     String getProduces() {  
    9.         return "Produces attribute";  
    10.     }  
    11.   
    12.     @RequestMapping(value = "/cons", consumes = {  
    13.         "application/JSON",  
    14.         "application/XML"  
    15.     })  
    16.     String getConsumes() {  
    17.         return "Consumes attribute";  
    18.     }  
    19. }  


    在这段代码中, getProduces() 处理方法会产生一个 JSON 响应, getConsumes() 处理方法可以同时处理请求中的 JSON 和 XML 内容。 

    使用 @RequestMapping 来处理消息头 

    @RequestMapping 注解提供了一个 header 元素来根据请求中的消息头内容缩小请求映射的范围。 

    在可以指定 header 元素的值,用 myHeader = myValue 这样的格式: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/head", headers = {  
    5.         "content-type=text/plain"  
    6.     })  
    7.     String post() {  
    8.         return "Mapping applied along with headers";  
    9.     }  
    10. }  


    在上面这段代码中, @RequestMapping 注解的 headers 属性将映射范围缩小到了 post() 方法。有了这个,post() 方法就只会处理到 /home/head 并且 content-typeheader 被指定为 text/plain 这个值的请求。 

    你也可以像下面这样指定多个消息头: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/head", headers = {  
    5.         "content-type=text/plain",  
    6.         "content-type=text/html"  
    7.     }) String post() {  
    8.         return "Mapping applied along with headers";  
    9.     }  
    10. }  


    这样, post() 方法就能同时接受 text/plain 还有 text/html 的请求了。 

    使用 @RequestMapping 来处理请求参数 

    @RequestMapping 直接的 params 元素可以进一步帮助我们缩小请求映射的定位范围。使用 params 元素,你可以让多个处理方法处理到同一个URL 的请求, 而这些请求的参数是不一样的。 

    你可以用 myParams = myValue 这种格式来定义参数,也可以使用通配符来指定特定的参数值在请求中是不受支持的。 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/fetch", params = {  
    5.         "personId=10"  
    6.     })  
    7.     String getParams(@RequestParam("personId") String id) {  
    8.         return "Fetched parameter using params attribute = " + id;  
    9.     }  
    10.     @RequestMapping(value = "/fetch", params = {  
    11.         "personId=20"  
    12.     })  
    13.     String getParamsDifferent(@RequestParam("personId") String id) {  
    14.         return "Fetched parameter using params attribute = " + id;  
    15.     }  
    16. }  


    在这段代码中,getParams() 和 getParamsDifferent() 两个方法都能处理相同的一个 URL (/home/fetch) ,但是会根据 params 元素的配置不同而决定具体来执行哪一个方法。 

    例如,当 URL 是 /home/fetch?id=10 的时候, getParams() 会执行,因为 id 的值是10,。对于 localhost:8080/home/fetch?personId=20 这个URL, getParamsDifferent() 处理方法会得到执行,因为 id 值是 20。 


    使用 @RequestMapping 处理动态 URI 

    @RequestMapping 注解可以同 @PathVaraible 注解一起使用,用来处理动态的 URI,URI 的值可以作为控制器中处理方法的参数。你也可以使用正则表达式来只处理可以匹配到正则表达式的动态 URI。 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping(value = "/fetch/{id}", method = RequestMethod.GET)  
    5.     String getDynamicUriValue(@PathVariable String id) {  
    6.         System.out.println("ID is " + id);  
    7.         return "Dynamic URI parameter fetched";  
    8.     }  
    9.     @RequestMapping(value = "/fetch/{id:[a-z]+}/{name}", method = RequestMethod.GET)  
    10.     String getDynamicUriValueRegex(@PathVariable("name") String name) {  
    11.         System.out.println("Name is " + name);  
    12.         return "Dynamic URI parameter fetched using regex";  
    13.     }  
    14. }  


    在这段代码中,方法 getDynamicUriValue() 会在发起到 localhost:8080/home/fetch/10 的请求时执行。这里 getDynamicUriValue() 方法 id 参数也会动态地被填充为 10 这个值。 

    方法 getDynamicUriValueRegex() 会在发起到 localhost:8080/home/fetch/category/shirt 的请求时执行。不过,如果发起的请求是 /home/fetch/10/shirt 的话,会抛出异常,因为这个URI并不能匹配正则表达式。 

    @PathVariable 同 @RequestParam的运行方式不同。你使用 @PathVariable 是为了从 URI 里取到查询参数值。换言之,你使用 @RequestParam 是为了从 URI 模板中获取参数值。 

    @RequestMapping 默认的处理方法 

    在控制器类中,你可以有一个默认的处理方法,它可以在有一个向默认 URI 发起的请求时被执行。 

    下面是默认处理方法的示例: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @RequestMapping()  
    5.     String  
    6.     default () {  
    7.         return "This is a default method for the class";  
    8.     }  
    9. }  


    在这段代码中,向 /home 发起的一个请求将会由 default() 来处理,因为注解并没有指定任何值。 

    @RequestMapping 快捷方式 

    Spring 4.3 引入了方法级注解的变体,也被叫做 @RequestMapping 的组合注解。组合注解可以更好的表达被注解方法的语义。它们所扮演的角色就是针对 @RequestMapping 的封装,而且成了定义端点的标准方法。 

    例如,@GetMapping 是一个组合注解,它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。 
    方法级别的注解变体有如下几个: 

    • @GetMapping
    • @PostMapping
    • @PutMapping
    • @DeleteMapping
    • @PatchMapping

    如下代码展示了如何使用组合注解: 
    代码 

    1. @RestController  
    2. @RequestMapping("/home")  
    3. public class IndexController {  
    4.     @GetMapping("/person")  
    5.     public @ResponseBody ResponseEntity < String > getPerson() {  
    6.         return new ResponseEntity < String > ("Response from GET", HttpStatus.OK);  
    7.     }  
    8.     @GetMapping("/person/{id}")  
    9.     public @ResponseBody ResponseEntity < String > getPersonById(@PathVariable String id) {  
    10.         return new ResponseEntity < String > ("Response from GET with id " + id, HttpStatus.OK);  
    11.     }  
    12.     @PostMapping("/person")  
    13.     public @ResponseBody ResponseEntity < String > postPerson() {  
    14.         return new ResponseEntity < String > ("Response from POST method", HttpStatus.OK);  
    15.     }  
    16.     @PutMapping("/person")  
    17.     public @ResponseBody ResponseEntity < String > putPerson() {  
    18.         return new ResponseEntity < String > ("Response from PUT method", HttpStatus.OK);  
    19.     }  
    20.     @DeleteMapping("/person")  
    21.     public @ResponseBody ResponseEntity < String > deletePerson() {  
    22.         return new ResponseEntity < String > ("Response from DELETE method", HttpStatus.OK);  
    23.     }  
    24.     @PatchMapping("/person")  
    25.     public @ResponseBody ResponseEntity < String > patchPerson() {  
    26.         return new ResponseEntity < String > ("Response from PATCH method", HttpStatus.OK);  
    27.     }  
    28. }  


    在这段代码中,每一个处理方法都使用 @RequestMapping 的组合变体进行了注解。尽管每个变体都可以使用带有方法属性的 @RequestMapping 注解来互换实现, 但组合变体仍然是一种最佳的实践 — 这主要是因为组合注解减少了在应用程序上要配置的元数据,并且代码也更易读。 

    @RequestMapping 总结 

    如你在本文中所看到的,@RequestMapping 注解是非常灵活的。你可以使用该注解配置 Spring MVC 来处理大量的场景用例。它可以被用来在 Spring MVC 中配置传统的网页请求,也可以是 REST 风格的 Web 服务

    展开全文
  • RequestMapping 注解

    2020-11-10 19:54:12
    RequestMapping 注解 RequestMapping代替 GetMapping 或PostMapping HTTPRequestservlet 可以获取请求方式 httpConn.setRequestMethod(request.getMethod());
  • 一、@RequestMapping可以作用在类上,也可以作用在方法上。 1、请求路径是单级目录,比如: 上面的例子只作用在方法上,没有作用在类上。 2、请求路径是多级目录,比如: 对应路径为:/a/b 二、value...
  • RequestMapping介绍

    2020-04-19 11:10:41
    @RequestMapping 看看注解源码,在那几个位置 就近? 协作? 常用方法:method=RequestMethod.GET/method=RequestMethod.POST RequestMapping中限定请求参数映射:params @RequestMapping(value="/testParams...
  • RequestMapping 参数

    2020-03-18 17:03:00
    RequestMapping 是一个用来处理请求地址映射的注解,可用于类或方法上。 用于类上:表示类中的所有响应请求的方法都是以该地址作为父路径 @RequestMapping("/building") public class BuildingController { } ...
  • @RequestMapping

    2020-05-07 11:17:47
    @RequestMapping RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。 RequestMapping注解有六个属性,下面我们把她分成三类...
  • requestMapping 注解

    2020-03-09 22:32:55
    一:@RequestMapping 1)可以修饰在类上:相当于请求URL的根路径 2)也可以修饰在方法上:url的具体业务 二:@RequestMapping还可以映射请求方式(method)、请求参数(params)、请求头 请求方式:method=post/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,061
精华内容 12,424
关键字:

requestmapping