• 02 SpringMVC 参数获取

    目录

    项目结构：

    一、SpringMVC参数获取_封装为简单数据类型

    二、SpringMVC参数获取_封装为对象类型

    1.封装单个对象

    2.封装关联对象

    三、SpringMVC参数获取_封装为List集合类型

    1.封装为简单数据类型集合

    2.封装为对象类型List集合

    四、SpringMVC参数获取_封装为Map集合类型

    五、SpringMVC参数获取_使用Servlet原生对象获取参数

    六、SpringMVC参数获取_自定义参数类型转换器

    七、SpringMVC参数获取_编码过滤器

    八、知识点整理：

    项目结构：

    一、SpringMVC参数获取_封装为简单数据类型

     在Servlet中我们通过 request.getParameter(name) 获取请求参数。该方式存在两个问题：

    （1）请求参数较多时会出现代码冗余

    （2）与容器紧耦合

    而 SpringMVC 支持参数注入的方式用于获取请求数据，即将请求参数直接封装到方法的参数当中。用法如下：
    1.在controller层编写控制方法 
    1. @Controller
    2. public class MyController1 {
    3.     // 获取简单类型参数
    4.     @RequestMapping("/c1/param1")
    5.     public void simpleParam(String username,int age){
    6.         System.out.println(username);
    7.         System.out.println(age);
    8.     }
    9. }

    2.访问该方法时，请求参数名和方法参数名相同，即可完成自动封装

    http://localhost:8080/c1/param1?username=bz&age=10

    二、SpringMVC参数获取_封装为对象类型

     SpringMVC支持将参数直接封装为对象，写法如下：

    1.封装单个对象

    1.在domain层编写Student实体类 
    1. public class Student {
    2.     private int id;
    3.     private String name;
    4.     private String sex;
    5.     // 省略getter/setter/tostring
    6. }

    2.在controller层编写控制器方法

    1.  // 获取对象类型参数
    2.     @RequestMapping("/c1/param2")
    3.     public void objParam(Student student){
    4.         System.out.println(student);
    5.     }

    3.访问该方法时，请求参数名和方法参数的属性名相同，即可完成自动封装。

    http://localhost:8080/c1/param2?id=1&name=bz&sex=female

    2.封装关联对象

    1.在domain层编写Address、Student实体类

    1. public class Address {
    2.     private String info; //地址信息
    3.     private String postcode; //邮编
    4.     // 省略getter/setter/tostring
    5. }
    1. public class Student {
    2.     private int id;
    3.     private String name;
    4.     private String sex;
    5.     private Address address; // 地址对象
    6.     // 省略getter/setter/tostring
    7. }

    2.在controller层编写控制器方法

    1. // 获取关联对象类型参数
    2.     @RequestMapping("/c1/param3")
    3.     public void objParam2(Student student){
    4.         System.out.println(student);
    5.     }

    3.访问该方法时，请求参数名和方法参数的属性名相同，即可完成自动封装。

    http://localhost:8080/c1/param3?id=1&name=bz&sex=female&address.info=beijing&address.postcode=030000

    注意，要用“关联对象名.属性名”来调用关联对象的属性

    4.我们也可以使用表单发送带有参数的请求： 

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>表单提交title>
    5. head>
    6. <body>
    7.    <form action="/c1/param3" method="post">
    8.        id:<input name="id">
    9.        姓名:<input name="name">
    10.        性别:<input name="sex">
    11.        住址:<input name="address.info">
    12.        邮编:<input name="address.postcode">
    13.        <input type="submit">
    14.    form>
    15. body>
    16. html>

    5.访问方法

    http://localhost:8080/param.jsp

    三、SpringMVC参数获取_封装为List集合类型

     SpringMVC支持将参数封装为List或Map集合，写法如下：

    封装为List集合

    1.封装为简单数据类型集合

    1.在controller层编写控制器方法

    1.     /**
    2.      *   封装为简单数据类型（基本数据类型+字符串类型）的list参数
    3.      *     注意，封装为简单数据类型list参数，参数前必须添加@RequestParam注解
    4.      *     在网页添加数据时，直接users=？&users=？。。。。即可，
    5.      *      如http://localhost:8080/c1/param4?users=ni&users=2
    6.      */
    7.     @RequestMapping("/c1/param4")
    8.     public void listParam(@RequestParam List users){
    9.         System.out.println(users);
    10.     }

    该方式也可以绑定数组类型：

    1. /**
    2.      *      封装为数组类型参数
    3.      *     注意，封装为数组参数，参数前必须添加@RequestParam注解
    4.      *     在网页添加数据时，直接users=？&users=？。。。。即可，
    5.      *      如http://localhost:8080/c1/param4?users=ni&users=2
    6.      */
    7.     @RequestMapping("/c1/param5")
    8.     public void listParam2(@RequestParam String[] users){
    9.         System.out.println(users[0]);
    10.         System.out.println(users[1]);
    11.     }

    2.请求的参数写法：

    http://localhost:8080/c1/param4?users=bj&users=sxt

    2.封装为对象类型List集合

    SpringMVC 不支持将参数封装为对象类型的 List 集合，但可以封装到有List 属性的对象中。

    1.在domain层编写Student实体类

    1. public class Student {
    2.     private int id;
    3.     private String name;
    4.     private String sex;
    5.     private List
       address; // 地址集合
    6.     // 省略getter/setter/tostring
    7. }

    2.在controller层编写控制器方法

    1.     //封装为list对象中，但不能直接封装，要将list集合放在对象中，对象中包含集合属性
    2.     @RequestMapping("/c1/param6")
    3.     public void listParam3(Student student){
    4.         System.out.println(student);
    5.     }
    3.请求的参数写法
    http://localhost:8080/c1/param6？id=1&name=bz&sex=female&address[0].info=bj&address[0].postcode=100010&address[1].info=sh&address[1].postcode=100011

    四、SpringMVC参数获取_封装为Map集合类型

    同样， SpringMVC 要封装 Map 集合，需要封装到有 Map 属性的对象中。

    1.在domain层编写Student实体类

    1. public class Student {
    2.     private int id;
    3.     private String name;
    4.     private String sex;
    5.     private Map address;// 地址集合
    6.    // 省略getter/setter/tostring
    7. }

    2.在controller层编写控制器方法

    1.  //封装为Map对象中，但不能直接封装，要将list集合放在对象中，对象中包含集合属性
    2.     @RequestMapping("/c1/param7")
    3.     public void MapParam(Student student){
    4.         System.out.println(student);
    5.     }

    3.请求的参数写法

    http://localhost:8080/c1/param7?
    id=1&name=bz&sex=female&address[‘one’].info=bj&address[‘one’].postcode=100010&address[‘two’].info=sh&address[‘two’].postcode=100011

    五、SpringMVC参数获取_使用Servlet原生对象获取参数

     SpringMVC也支持使用Servlet原生对象，在方法参数中定义HttpServletRequest 、 HttpServletResponse 、 HttpSession 等类型的参数即可直接在方法中使用。

    1. //使用Servlet原生对象
    2.     @RequestMapping("c1/param8")
    3.     public void servletParam(HttpServletRequest request, HttpServletResponse response, HttpSession session){
    4.         //原生对象获取参数
    5.         System.out.println(request.getParameter("name"));
    6.         System.out.println(response.getCharacterEncoding());
    7.         System.out.println(session.getId());
    8.     }
    访问该方法即可：http://localhost:8080/c1/param8?name=bjsxt
    一般情况下，在 SpringMVC 中都有对 Servlet 原生对象的方法的替代，推荐使用SpringMVC 的方式代替 Servlet 原生对象。（即一般不使用servlet原生对象）

    六、SpringMVC参数获取_自定义参数类型转换器

     前端传来的参数全部为字符串类型（也就是说前端输入的不管是整数还是字符串或是其他类型，传来的都是String类型），SpringMVC使用自带的转换器将字符串参数转为需要的类型。如：

    1.     // 获取简单类型参数
    2.     @RequestMapping("/c1/param1")
    3.     public void simpleParam(String username,int age){
    4.         System.out.println(username);
    5.         System.out.println(age);
    6.     }

    请求路径：http://localhost:8080/c1/param1?username=bz&age=10

    但在某些情况下，无法将字符串转为需要的类型，如Date日期类型： 
    1.   //自定义类型
    2.     @RequestMapping("c1/param9")
    3.     public void dateParam(Date birthday){
    4.         System.out.println(birthday);
    5.     }
    由于日期数据有很多种格式，SpringMVC 没办法把所有格式的字符串转换成日期类型。比如参数格式为 birthday=2025 - 01 - 01 时， SpringMVC就无法解析参数。此时需要自定义参数类型转换器。
    1.定义类型转换器类，实现Converter接口 
    1. //定义类型转换器，实现Converter接口
    2. public class DateConverter implements Converter {
    3.     @Override
    4.     public Date convert(String source) {
    5.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
    6.         Date date = null;
    7.         try {
    8.             date = sdf.parse(source);
    9.         } catch (ParseException e) {
    10.             e.printStackTrace();
    11.         }
    12.         return date;
    13.     }
    14. }
    2.在springmvc.xml中注册类型转换器对象 
    2.     <mvc:annotation-driven conversion-service="converterFactory">mvc:annotation-driven>
    3.  
    4.     
    5.     <bean id="converterFactory" class="org.springframework.context.support.ConversionServiceFactoryBean">
    6.         
    7.         <property name="converters">
    8.             <set>
    9.                 
    10.                 <bean class="com.itbaizhan.converter.DateConverter">bean>
    11.             set>
    12.         property>
    13.     bean>
    此时再访问http://localhost:8080/c1/param9?birthday=2025-01-01时，SpringMVC即可将请求参数封装为Date类型的参数。

    七、SpringMVC参数获取_编码过滤器

     在传递参数时，tomcat8以上能处理get请求的中文乱码（Maven工具中tomcat只更新到tomcat7，但tomcat7以上版本的功能都能实现。），但不能处理post请求的中文乱码。

    1.在webapp层编写jsp表单param2.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>编码过滤器title>
    5. head>
    6. <body>
    7. <form action="/cn/param" method="post">
    8.     姓名：<input name="username">
    9.          <input type="submit">
    10. form>
    11. body>
    12. html>

    2.在controller层编写控制器方法

    1. //编码过滤器
    2.     @RequestMapping("/cn/param")
    3.     public void code(String username){
    4.         System.out.println(username);
    5.     }
    3.SpringMVC提供了处理中文乱码的过滤器，在web.xml中配置该过滤器即可解决中文乱码问题： 
    1. web-app PUBLIC
    2.  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    3.  "http://java.sun.com/dtd/web-app_2_3.dtd" >
    4.  
    5. <web-app>
    6.   <display-name>Archetype Created Web Applicationdisplay-name>
    7.   
    8.   <filter>
    9.     <filter-name>encFilterfilter-name>
    10.     <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    11.     <init-param>
    12.       <param-name>encodingparam-name>
    13.       <param-value>utf-8param-value>
    14.     init-param>
    15.   filter>
    16.   <filter-mapping>
    17.     <filter-name>encFilterfilter-name>
    18.     <url-pattern>/*url-pattern>
    19.   filter-mapping>4
    20.  
    22.   <servlet>
    23.     <servlet-name>dispatcherServletservlet-name>
    24.     <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    25.     <init-param>
    26.       <param-name>contextConfigLocationparam-name>
    27.       <param-value>classpath:springmvc.xmlparam-value>
    28.     init-param>
    29.     <load-on-startup>1load-on-startup>
    30.   servlet>
    31.   <servlet-mapping>
    32.     <servlet-name>dispatcherServletservlet-name>
    33.     <url-pattern>/url-pattern>
    34.   servlet-mapping>
    35. web-app>

    4.请求路径：http://localhost:8080/param2.jsp

    八、知识点整理：

    1.在SpringMVC中，接受简单类型参数时，请求参数名和“方面参数名”相同即可自动封装

    2.在SpringMVC中，接受对象类型参数时，请求参数名和"方法对象参数的属性名"相同即可自动封装

    3.在SpringMVC中，接受简单数据类型List参数，必须在方法参数前加“@RequestParam”

    4.SpringMVC不支持封装对象类型的List参数，但可以封装“有List属性的对象”

    5.SpringMVC要封装Map集合的参数，需要封装到“有Map属性的对象”中

    6.在SpringMVC中，通过“在方法参数中定义Servlet原生对象”获取Servlet原生对象

    7. 在SpringMVC中，通过使用Servlet原生对象“request.getParameter("参数名") ”获取请求参数

    8.SpringMVC自定义类型转换器需要实现接口“Converter ”

    9.SpringMVC提供了“编码过滤器 ”解决参数中文乱码问题

  • 相关阅读:
    WR | 水源水耐药基因稳定赋存的关键：以致病菌为“源”，群落构建主导菌为“汇”...
    脚本：用python实现五子棋
    如何生成钱包
    管理数据质量、准确性和一致性的策略
    简述 HTTP 请求的过程是什么？
    43.MQ—RabbitMQ
    GZ038 物联网应用开发赛题第9套
    云计算系统的多维度安全部署
    微擎模块 名片小程序 1.7.9 小程序前端+后端有加密，优化代码，新增付费发布幻灯片
    Halcon实例转OpenCvSharp(C# OpenCV)实现--瓶口缺陷检测(附源码)
  • 原文地址：https://blog.csdn.net/m0_51697147/article/details/126282769