springmvc 如何接收参数

绝地灬酷狼 2022-04-10 14:18 395阅读 0赞 
  1. package com.maven.web.controller;
  3. import java.util.Arrays;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.web.bind.annotation.ModelAttribute;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestBody;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestMethod;
  12. import org.springframework.web.bind.annotation.RequestParam;
  13. import org.springframework.web.bind.annotation.RestController;
  15. import com.alibaba.fastjson.JSON;
  16. import com.maven.web.entity.UserInfo;
  18. /**
  19.  * 测试springmvc接收参数的几种方式
  20.  * @author Administrator
  21.  *
  22.  */
  24. //统一返回json数据到前端，不必在方法上添加@ResponseBody注解
  25. @RestController
  26. public class SpringController {
  28.     private Logger logger =  LoggerFactory.getLogger(this.getClass());
  30.     /**
  31.      * 1，form表单提交
  32.      * 可以直接通过参数名获取，
  33.      * 不添加注解时
  34.      * 注意参数名要和表单name一致,否则获取不到参数值,结果为null
  35.      * 
  36.      * 添加注解@RequestParam时，默认required=true
  37.      * 可以设置参数不必传required=false
  38.      * 如果没有则会抛异常:Required String parameter 'password' is not present
  39.      * 可以给参数设置默认值defaultValue="0000"
  40.      * 有默认值的情况下，required属性无效
  41.      * 
  42.      * @param userName
  43.      * @param password
  44.      */
  45.     @RequestMapping(value="/name/form/post/or/get",method={RequestMethod.POST,RequestMethod.GET})
  46.     public void formPost(String userName,
  47.             @RequestParam(value="password",required=true,defaultValue="0000") String password){
  48.         logger.info("form表单提交，通过参数名接收");
  49.         logger.info("name:"+userName+",gender:"+password);
  50.     }
  52.     /**
  53.      *,2，form表单提交
  54.      * 用一个实体bean来接收表单整体数据，注意bean的属性要和表单name一致
  55.      * 只有表单name与bean中属性值一致才会正确赋值，否则bean获取到的值为null
  56.      * 可以不添加任何注解
  57.      * 也可以添加注解 @ModelAttribute,括号里的别名可以任意取，也可以不填
  58.      * 
  59.      * @param userInfo
  60.      */
  61.     @RequestMapping(value="/bean/form/post/or/get",method={RequestMethod.POST,RequestMethod.GET})
  62.     public void formPost(@ModelAttribute UserInfo userInfo,String testParam){
  63.         logger.info("form表单提交，通过实体类接收,映射不到的属性,通过参数名接收");
  64.         logger.info("userInfo:"+userInfo);
  65.         logger.info("testParam:"+testParam);
  66.     }
  68.     /**
  69.      * 表单提交，相同参数名可以用数组接收
  70.      * post,get请求是一样的
  71.      * @param userName
  72.      */
  73.     @RequestMapping(value="/array/form/post/or/get",method={RequestMethod.POST,RequestMethod.GET})
  74.     public void formPost(String[] userName,String testParam){
  75.         logger.info("form表单提交，用数组接收相同参数名");
  76.         logger.info("userName:"+Arrays.toString(userName));
  77.         logger.info("testParam:"+testParam);
  78.     }
  80.     /**
  81.      * 链接请求
  82.      * 从url后面获取参数
  83.      * 必须使用@PathVariable注解
  84.      * 
  85.      * @param userName
  86.      * @param password
  87.      */
  88.     @RequestMapping(value="/link/get/{name}/{pwd}",method=RequestMethod.GET)
  89.     public void linkGetPath(@PathVariable("name") String userName,
  90.             @PathVariable("pwd") String password){
  91.         logger.info("通过链接/link/get/{name}/{pwd}访问传递参数");
  92.         logger.info("name:"+userName+",gender:"+password);
  93.     }
  95.     /**
  96.      * 链接请求
  97.      * 从url后面获取参数
  98.      * 可以使用@RequestParam注解，value必须跟传递的参数名一致
  99.      * 这里和表单get请求一样
  100.      * 
  101.      * @param userName
  102.      * @param password
  103.      */
  104.     @RequestMapping(value="/link/get/params",method=RequestMethod.GET)
  105.     public void linkGetParams(@RequestParam(value="name") String userName,
  106.             @RequestParam(value="pwd") String password){
  107.         logger.info("通过链接/link/get/params?name=&pwd=访问传递参数");
  108.         logger.info("name:"+userName+",gender:"+password);
  109.     }
  111.     /**
  112.      * 链接请求
  113.      * 从url后面获取参数
  114.      * 可以直接用参数名获取，不加注解，但是参数名要和传递的参数名一致
  115.      * 这里和表单get请求一样
  116.      * 
  117.      * @param userName
  118.      * @param password
  119.      */
  120.     @RequestMapping(value="/link/get",method=RequestMethod.GET)
  121.     public void linkGet(String userName,String password){
  122.         logger.info("通过链接/link/get?userName=&password=访问传递参数");
  123.         logger.info("name:"+userName+",gender:"+password);
  124.     }
  126.     /**
  127.      * 链接请求
  128.      * 通过url传递的参数也可以直接用java bean来接收
  129.      * 同表单提交一样，这里不需要加注解即可获取到
  130.      * 
  131.      * @param userInfo
  132.      */
  133.     @RequestMapping(value="/bean/link/get",method=RequestMethod.GET)
  134.     public void linkGet(UserInfo userInfo){
  135.         logger.info("通过链接/link/get?userName=&password=访问传递参数");
  136.         logger.info("userInfo:"+userInfo);
  137.     }
  139.     /**
  140.      * ajax请求,参数为json字符串
  141.      * get请求，同上，可以用参数名获取json字符串，然后后台对json字符串做处理
  142.      * 
  143.      * @param userInfo
  144.      */
  145.     @RequestMapping(value="/ajax/get",method=RequestMethod.GET)
  146.     public String ajaxGet(String json){
  147.         logger.info("ajax发送get请求，参数为json字符串");
  148.         logger.info("json:"+json);
  149.         UserInfo userInfo = JSON.parseObject(json, UserInfo.class);
  150.         logger.info("userInfo:"+userInfo);
  151.         return "success";
  152.     }
  154.     /**
  155.      * ajax请求,参数为json字符串
  156.      * post请求，必须添加@RequestBody注解，利用spring框架将json串转成java bean
  157.      * java bean 属性名称要和json字符串一致
  158.      * 
  159.      * @param userInfo
  160.      */
  161.     @RequestMapping(value="/ajax/post",method=RequestMethod.POST)
  162.     public String ajaxPost(@RequestBody UserInfo userInfo){
  163.         logger.info("ajax发送post请求，参数为json字符串");
  164.         logger.info("userInfo:"+userInfo);
  165.         return "success";
  166.     }
  168.     /**
  169.      * 测试json字符串是否可以直接用参数名获取
  170.      * 结果：不能获取到参数，加上注解@RequestParam也不行
  171.      * 可以加上注解@RequestBody，然后用String接收到整个json字符串
  172.      * 
  173.      * @param json
  174.      * @return
  175.      */
  176.     @RequestMapping(value="/ajax/post/params",method=RequestMethod.POST)
  177.     public String ajaxPostParams(@RequestBody String json){
  178.         logger.info("ajax发送post请求，参数为json字符串");
  179.         logger.info("json:"+json);
  180.         return "success";
  181.     }
  183.     /**
  184.      * ajax发送数组格式的字符串，
  185.      * 实际是数组格式的字符串，需要手动转换成数组对象
  186.      * @param params
  187.      * @return
  188.      */
  189.     @RequestMapping(value="/ajax/post/arr",method=RequestMethod.POST)
  190.     public String ajaxPostArr(@RequestBody String params){
  191.         logger.info("ajax传递数组格式的字符串");
  192.         logger.info("params:"+params);
  193.         String[] arr = JSON.parseObject(params, String[].class);
  194.         logger.info(Arrays.toString(arr));
  195.         return "success";
  196.     }
  198.     /**
  199.      * ajax直接传递数组对象，同时还可以传递其他参数，
  200.      * 类似表单提交，注意要设置：
  201.      * traditional：true
  202.      * contentType:默认
  203.      * 
  204.      * @param params
  205.      * @return
  206.      */
  207.     @RequestMapping(value="/ajax/post/arr2",method={RequestMethod.POST,RequestMethod.GET})
  208.     public String ajaxPostArr2(String[] params,String name){
  209.         logger.info("ajax传递数组对象");
  210.         logger.info(Arrays.toString(params));
  211.         logger.info("name:"+name);
  212.         return "success";
  213.     }
  215. }

前端html

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Insert title here</title>
  6. </head>
  7. <body>
  8.     <span style="font-size: 12px;color:red;">后台直接使用参数名获取表单参数,get,post请求一样</span>
  9.     <form id="form1" action="/com.maven.web/name/form/post/or/get" method="get">
  10.         <label>用户名</label> <input type="text" id="name" name="userName" /> <br />
  11.         <button
  12.             onclick="function(){document.getElementById('form1').submit();}">提交</button>
  13.     </form>
  14.     <br/>
  15.     <br/>
  16.     <span style="font-size: 12px;color:red;">后台直接使用java bean获取表单参数,get,post请求一样</span>
  17.     <form id="form2" action="/com.maven.web/bean/form/post/or/get" method="get">
  18.         <label>用户名</label> <input type="text" id="name" name="userName" /> 
  19.         <br />
  20.         <label>密码</label> <input type="text" id="password" name="password" />
  21.         <br />
  22.         <label>其他参数</label> <input type="text" name="testParam" />
  23.         <br />
  24.         <button
  25.             onclick="function(){document.getElementById('form2').submit();}">提交</button>
  26.     </form>
  27.     <br/>
  28.     <br/>
  29.     <span style="font-size: 12px;color:red;">后台使用String[]获取表单参数,get,post请求一样</span>
  30.     <form id="form3" action="/com.maven.web/array/form/post/or/get" method="get">
  31.         <label>用户名</label> <input type="text" name="userName" /> <br />
  32.         <label>用户名</label> <input type="text" name="userName" /> <br />
  33.         <label>其他参数</label> <input type="text" name="testParam" /><br />
  34.         <br />
  35.         <button
  36.             onclick="function(){document.getElementById('form3').submit();}">提交</button>
  37.     </form>
  38.     <br/>
  39.     <br/>
  40.     <span style="font-size: 12px;color:red;">发送链接,从url后面获取参数</span>
  41.     <br/>
  42.     <a href="http://localhost:8088/com.maven.web/link/get/aa/bb">链接1:/link/get/aa/bb,,通过注解@PathVariable获取</a>
  43.     <br/>
  44.     <a href="http://localhost:8088/com.maven.web/link/get/params?name=aa&pwd=bb">链接2:/link/get?name=aa&pwd=bb,通过注解@RequestParam获取</a>
  45.     <br/>
  46.     <a href="http://localhost:8088/com.maven.web/link/get?userName=aa&password=bb">链接3:/link/get?userName=aa&password=bb,直接通过注解参数名获取</a>
  47.     <br/>
  48.     <a href="http://localhost:8088/com.maven.web/bean/link/get?userName=aa&password=bb">链接4:/bean/link/get?userName=aa&password=bb,通过java bean获取</a>
  49. </body>
  50. </html>
  52. <!DOCTYPE html>
  53. <html>
  54. <head>
  55. <meta charset="UTF-8">
  56. <title>Insert title here</title>
  57. <script type="text/javascript" src="./jquery-2.1.1.js"></script>
  58. <script type="text/javascript">
  59. /**
  60.  * ajax get请求，通过url传递参数
  61.  * 后台接收到json的字符串，可以自行转换成对象
  62.  */
  63. function sendGet(){
  64.     var data = {'userName':'aaa','password':'0000'};
  65.     var json = JSON.stringify(data);
  66.     $.ajax({
  67.         method : 'GET',
  68.         data:{'json':json},
  69.         url : '/com.maven.web/ajax/get',
  70.         dataType : 'json',//返回数据格式
  71.         success : function(result) {
  72.             alert('success');
  73.         },
  74.         error : function(err) {
  75.             alert("error");
  76.         }
  77.     });
  78. };
  80. /**
  81.  * post请求，传递json格式数据，后台可以直接用实体bean接收
  82.  * contentType : 'application/json'
  83.  */
  84. function sendPost(){
  85.     var data = {'userName':'aaa','password':'0000'};
  86.     var json = JSON.stringify(data);
  87.     $.ajax({
  88.         method : 'POST',
  89.         url : '/com.maven.web/ajax/post',
  90.         data : json,
  91.         dataType : 'json',//返回数据格式
  92.         contentType : 'application/json',//必须为false
  93.         success : function(result) {
  94.             alert('success');
  95.         },
  96.         error : function(err) {
  97.             alert("error");
  98.         }
  99.     });
  100. };
  102. /**
  103.  * post 传递json格式数据，后台如果不用实体bean接收，可以直接用String接收
  104.  * 获取到json串然后自行转换成对象
  105.  */
  106. function sendPostParams(){
  107.     var data = {'userName':'aaa','password':'0000'};
  108.     var json = JSON.stringify(data);
  109.     $.ajax({
  110.         method : 'POST',
  111.         url : '/com.maven.web/ajax/post/params',
  112.         data : json,
  113.         dataType : 'json',//返回数据格式
  114.         contentType : 'application/json',
  115.         success : function(result) {
  116.             alert('success');
  117.         },
  118.         error : function(err) {
  119.             alert("error");
  120.         }
  121.     });
  122. };
  124. /**
  125.  * 通过json字符串的格式传递数组，后台需要手动获取参数转换成数组
  126.  * 如果只有一个参数，后台可以直接获取，但是如果有多个，后台必须封装成java bean来获取
  127.  * 属性对应json传递的参数名
  128.  */
  129. function sendPostArr(){
  130.     var _list = [];  
  132.     for (var i = 0; i < 5; i++) {  
  133.         _list[i] = 'a'+i;  
  134.     } 
  135.     var data = {'params':_list};
  136.     var json = JSON.stringify(_list);
  137.     $.ajax({
  138.         method : 'POST',
  139.         url : '/com.maven.web/ajax/post/arr',
  140.         data : json,
  141.         dataType : 'json',//返回数据格式
  142.         contentType : 'application/json',
  143.         success : function(result) {
  144.             alert('success');
  145.         },
  146.         error : function(err) {
  147.             alert("error");
  148.         }
  149.     });
  150. };
  152. /**
  153.  * 直接传递数组对象，后台可以用数组直接接收
  154.  * 这是模拟表单提交数据，可以直接传递参数
  155.  * 注意，传递数组的话，必须设置traditional: true
  156.  * 这里设置get,post请求都一样
  157.  */
  158. function sendPostArr2(){
  159.     var _list = [];  
  161.     for (var i = 0; i < 5; i++) {  
  162.         _list[i] = 'a'+i;  
  163.     } 
  164.     $.ajax({
  165.         method : 'GET',
  166.         url : '/com.maven.web/ajax/post/arr2',
  167.         data : {'params':_list,'name':'aaa'},
  168.         traditional: true,//当设置成true的时候就会用传统方式序列化参数
  169.         dataType : 'json',
  170.         success : function(result) {
  171.             alert('success');
  172.         },
  173.         error : function(err) {
  174.             alert("error");
  175.         }
  176.     });
  177. };
  179. </script>
  180. </head>
  181. <body>
  182. <span style="font-size: 12px;color:red;">ajax请求发送json字符串，后台不能直接用参数名获取</span>
  183. <br/>
  184. <a href="#" onclick="sendGet()">ajax get请求,后台可以直接用参数名接收</a>
  185. <br/>
  186. <br/>
  187. <a href="#" onclick="sendPost()">ajax post请求,后台用注解@RequestBody+java bean接收参数</a>
  188. <br/>
  189. <br/>
  190. <a href="#" onclick="sendPostParams()">ajax post请求,后台用注解@RequestBody+String接收整个json串</a>
  191. <br/>
  192. <br/>
  193. <a href="#" onclick="sendPostArr()">ajax post请求通过json字符串的格式传递数组，后台需要手动获取参数转换成数组</a>
  194. <br/>
  195. <br/>
  196. <a href="#" onclick="sendPostArr2()">ajax直接传递数组对象，后台可以用数组直接接收，post,get请求都一样</a>
  197. </body>
  198. </html>

发表评论

表情：
评论列表 （有 0 条评论，395人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SpringMVC-参数接收

    > 逐个参数接收  只要保证请求参数名与该请求处理方法的参数名相同即可  SpringMVC 绑定请求参数是自动实现的，但是要想使用，必须遵循使用要求： 1、如果是基本类

    以你之姓@以你之姓@/ 0 赞/ 360 阅读