【SpringMVC学习笔记】—— 【二】请求参数的绑定 + 常用注解

👉 原文首发： 小牛肉的个人博客，欢迎来访~

---

---

一、基本数据绑定

控制器方法中带有参数

@Controller
public class HelloController {

    /*请求映射*/
    @RequestMapping(path = "/hello")
    public String sayHello(String username, String password){
        System.out.println("Hello SpringMVC"+ username + password);
        return "success"; //返回名为success的jsp文件
    }
}

a标签请求中带上和控制器参数名一样的参数，并赋值

<a href="/hello?username=123&password=1234">hello</a>

二、请求参数绑定实体类型

实体类

public class Account implements Serializable {
    private String username;
    private String password;
    private Double money;

    public String getUsername() {
        return username;
    }

    public void setUsername(String usernmae) {
        this.username = usernmae;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "usernmae='" + username + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                '}';
    }
}

name的名称要和JavaBean对象的属性名对应

 <form action = "/hello">
        姓名：<input type="text" name="username" /><br/>
        密码：<input type="text" name="password" /><br/>
        金额：<input type="text" name="money" /><br/>
        <input type="submit" value="提交" />
    </form>

控制器类直接传入该实体类对象

//控制器类
@Controller
public class HelloController {

    /*请求映射*/
    @RequestMapping(path = "/hello")
    public String sayHello(Account account){
        System.out.println(account); //会调用account的toString方法
        return "success"; //返回名为success的jsp文件
    }
}

Account{username=‘123’, password=‘123’, money=123.0}

如果该类中嵌入了一个其他类

public class Account implements Serializable{
    private String username;
    private String password;
    private Double money;
    private User user;

public class User implements Serializable {
    private String uname;
    private Integer age;

通过 user.uname 访问该嵌入类的属性

用户姓名：<input type="text" name="user.uname" /><br/>
用户年龄：<input type="text" name="user.age" /><br/>

Account{username=‘123’, password=‘123’, money=123.0, user=User{uname=‘123’, age=123}}

三、配置解决中文乱码的过滤器

在 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>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--拦截什么网址，此处设置全部拦截-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

四、请求参数绑定集合类型

public class Account implements Serializable{
    private String username;
    private String password;
    private Double money;

    private List<User> list;
    private Map<String,User> map;

将用户属性封装进 list 对象和 map 对象

此处 map 中的 key 命名为 first ，自己随意命名

 		用户姓名：<input type="text" name="list[0].uname" /><br/>
        用户年龄：<input type="text" name="list[0].age" /><br/>

        用户姓名：<input type="text" name="map['first'].uname" /><br/>
        用户年龄：<input type="text" name="map['first'].age" /><br/>

Account{username=‘231’, password=‘12’, money=123.0, list=[User{uname=‘嘿嘿’, age=123}], map={first=User{uname=‘呵呵’, age=321}}}

五、自定义类型转换器

表单提交的任何数据类型全部都是字符串类型，但是后台定义Integer类型，数据也可以封装上，因为 Spring框架内部会默认进行数据类型转换

比如：日期 Date 的格式如果为 2000/11/11 则可正确封装，但是如果不是这个格式（比如 2000-11-11），就会出错。

如果想自定义数据类型转换，可以实现 Converter 的接口

1. 定义一个类，实现 Converter 接口，该接口有两个泛型

public class StringToDateConverter implements Converter<String, Date> {
    /**
     * @param source 传进来的字符串
     * @return
     */
    @Override
    public Date convert(String source) {
        DateFormat format = null;
        try {
            if(StringUtils.isEmpty(source)) {
                throw new NullPointerException("请输入要转换的日期");
            }
            format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = format.parse(source); //字符串转日期类型
            return date;
        } catch (Exception e) {
            throw new RuntimeException("输入日期有误");
        }

    }
}

2. 在 Spring 配置文件中配置类型转换器

	<!--配置自定义类型转换器-->
    <bean id = "conversionServiceFactoryBean" class = "org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.smallbeef.utils.StringToDateConverter"></bean>
            </set>
        </property>
    </bean>

    <!--开启SpringMVC对注解的支持-->
    <mvc:annotation-driven conversion-service="conversionServiceFactoryBean"></mvc:annotation-driven>

六、使用 Servlet 原生的 API 对象作为方法参数

SpringMVC 还支持使用原始 ServletAPI 对象作为控制器方法的参数。
支持原始 ServletAPI 对象有：

• HttpServletRequest
• HttpServletResponse
• HttpSession
• java.security.Principal
• Locale
• InputStream
• OutputStream
• Reader
• Writer

我们可以把上述对象，直接写在控制的方法参数中使用。

@RequestMapping("/testServletAPI") 
public String testServletAPI(HttpServletRequest request, 
							HttpServletResponse response,
							HttpSession session) {  
       System.out.println(request);  
       System.out.println(response);  
       System.out.println(session);  
       return "success"; } 

七、常用注解

1. RequestParam

作用： 把请求中指定名称的参数给控制器中的形参赋值。
属性：

• value：请求参数中的名称。
• required：请求参数中是否必须提供此参数。默认值：true。表示必须提供，如果不提供将报错。

示例代码如下：

@RequestMapping("/useRequestParam") 
public String useRequestParam(@RequestParam("name")String username,      
             				@RequestParam(value="age",required=false)Integer age){  		
		System.out.println(username+","+age);  
		return "success"; 
}

则前端参数名称必须为name、age(由于设置了 required=false ，所以该参数可不提供)

<a href="/useRequestParam?name=test">requestParam 注解</a> 

2. RequestBody

作用： 用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。
(get 请求方式不适用。因为get请求会直接把参数放在地址 url 上 )

属性：

• required：是否必须有请求体。默认值是:true。
  当取值为 true 时,get 请求方式会报错。如果取值 为 false，get 请求得到是 null。

示例代码如下：

@RequestMapping("/useRequestBody") 
public String useRequestBody(@RequestBody(required=false) String body){  	
	System.out.println(body);  
	return "success"; 
}

post 请求 jsp代码： 
<form action="springmvc/useRequestBody" method="post"> 
 用户名称：<input type="text" name="username" ><br/>  
 用户密码：<input type="password" name="password" ><br/>  
 用户年龄：<input type="text" name="age" ><br/> 
 <input type="submit" value=" 保存 "> </form> 
------------------------------------------------------------------------------------
get 请求 jsp代码： 
<a href="springmvc/useRequestBody?body=test">requestBody 注解 get 请求</a> 

3. PathVaribale

作用： 用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个 {id} 就是 url 占位符。
url 支持占位符是 Spring3.0 之后加入的。是 SpingMVC 支持 rest 风格（见下文） URL 的一个重要标志。

属性：

• value：用于指定 url 中占位符名称。
• required：是否必须提供占位符

示例代码如下：

@RequestMapping("/usePathVariable/{sid}") 
public String usePathVariable(@PathVariable("sid") Integer id){  
	System.out.println(id);  
	return "success"; 
} 

路径上的名称 @RequestMapping("/usePathVariable/{sid}") 和注解中的名称 @PathVariable("sid") 要一致，和参数名称 Integer id 无关。

前端传参

<a href="/usePathVariable/100">pathVariable 注解</a> 

REST 风格 URL

什么是 rest：

• REST（英文：Representational State Transfer，简称 REST） 描述了一个架构样式的网络系统， 比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中，他是 HTTP 规范的主要编写者之 一。在目前主流的三种 Web 服务交互方案中，REST 相比于 SOAP（Simple Object Access protocol，简单 对象访问协议）以及 XML-RPC 更加简单明了，无论是对 URL 的处理还是对 Payload 的编码，REST 都倾向于用更 加简单轻量的方法设计和实现。值得注意的是 REST 并没有一个明确的标准，而更像是一种设计的风格。
• 它本身并没有什么实用性，其核心价值在于如何设计出符合 REST 风格的网络接口。

restful 的优点:
它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

restful 的特性：

• 资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。 它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个 URI（统一 资源定位符）指向它，每种资源对应一个特定的 URI 。要 获取这个资源，访问它的 URI 就可以，因此 URI 即为每一个资源的独一无二的识别符。

• 表现层（Representation）：把资源具体呈现出来的形式，叫做它的表现层（Representation）。
  比如，文本可以用 txt 格式表现，也可以用 HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。

• 状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。
  HTTP 协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生“状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是 “表现层状态转化”。
  具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

一般的url路径：每个方法对应不同的url路径

@RequeMapping("/user/delete")
public void delete(){
}

@RequeMapping("/user/findAll")
public void findAll(){
}

@RequeMapping("/user/add")
public void add(){
}

RESTful风格的路路径

@RequeMapping(value = "/user", method = RequestMethod.DELETE)
public void delete(){  // DELETE
}

@RequeMapping(value = "/user",method = RequestMethod.GET)
public void findAll(){ // GET
}

@RequeMapping(value = "/user/{id}",method = RequestMethod.GET)
public void findById(@PathVariable("id") String id){ // GET
}

@RequeMapping(value = "/user",method = RequestMethod.POST)
public void add(){	// POst
}

所有方法的路径都是一样的，通过发送的请求方式 get/post/delete/put 来确定使用哪个方法，如果两个方法的请求方式是相同的，则根据所带参数来判断调用哪个方法，比如上述代码中的findAll 和 findById 方法

4. RequestHeader

作用：用于获取请求消息头。
属性：

• value：提供消息头名称
• required：是否必须有此消息头

示例代码如下：

@RequestMapping("/useRequestHeader") 
public String useRequestHeader(@RequestHeader(value="Accept-Language",          	
								required=false)String requestHeader){  
	System.out.println(requestHeader);  
	return "success"; 
}

5. CookieValue

作用：
用于把指定 cookie 名称的值传入控制器方法参数。
属性：

• value：指定 cookie 的名称。
• required：是否必须有此 cookie。

@RequestMapping("/useCookieValue") 
public String useCookieValue(@CookieValue(value="JSESSIONID",required=false) String 	
cookieValue){  
	System.out.println(cookieValue);  
	return "success"; 
}

6. ModelAttribute

作用：
该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数。

@ModelAttribute 注解作用在方法上或者方法的参数上，表示将被注解的方法的返回值或者是被注解的参数作为Model的属性加入到Model中，然后Spring框架自会将这个Model传递给ViewResolver。Model的生命周期只有一个http请求的处理过程，请求处理完后，Model就销毁了。

• 出现在方法上，表示当前方法会在控制器的方法执行之前，先执行。 它可以修饰没有返回值的方法，也可 以修饰有具体返回值的方法。
• 出现在参数上，获取指定的数据给参数赋值。

属性：

• value：用于获取数据的 key。key 可以是 POJO(简单Java对象，实际就是普通JavaBean) 的属性名称，也可以是 map 结构的 key。

应用场景：当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据。
例如： 我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段内容置为 null，此时就可以使用此注解解决问题。

基于 POJO 属性的基本使用

示例代码如下：

<a href="springmvc/testModelAttribute?username=test">测试 modelattribute</a>

/** 
  * 被 ModelAttribute 修饰的方法,该方法会在控制器方法执行之前执行
  * @param user   
  * */  
  @ModelAttribute  
  public void showModel(User user) {   //直接获取前端传过来的值
  	System.out.println("执行了 showModel 方法"+user.getUsername());  
  } 
   /** 
  * 接收请求的方法   
  * @param user   
  * @return   
  */  
  @RequestMapping("/testModelAttribute")  
  public String testModelAttribute(User user) {   
  	System.out.println("执行了控制器的方法"+user.getUsername());   
  	return "success";  
  } 

ModelAttribute 修饰方法带返回值

需求：修改用户信息，要求用户的密码不能修改

示例代码如下：

<!-- 修改用户信息 
     没有用户密码项--> 
<form action="/updateUser" method="post"> 
 用户名称：<input type="text" name="username" ><br/>  
 用户年龄：<input type="text" name="age" ><br/>  
 <input type="submit" value=" 保存 "> </form> 

/** 
 * 模拟去数据库查询  
 * @param username  用户输入的用户名
 * @return  
 */ 
 private User findUserByName(String username) {  
 	User user = new User();  
 	user.setUsername(username); 
 	user.setAge(19);  //假设数据库中该用户年龄为19
 	user.setPassword("123456");  //假设数据库中该用户密码为123456
 	return user; 
}

@ModelAttribute 
public User showModel(String username) {  //直接获取前端传递过来的username
	//模拟去数据库查询  
	User abc = findUserByName(username); 
 	System.out.println("执行了 showModel 方法" + abc);  
 	return abc; 
}

/** 
 * 模拟修改用户方法  
 * @param user  该user为ModelAttribute返回的user对象abc
 * @return  
 */ 
@RequestMapping("/updateUser") 
public String testModelAttribute(User user) { //接收ModeleAttribute返回的user对象并根据前端传值进行修改
	System.out.println("控制器中处理请求的方法：修改用户："+user);  
	return "success"; 
} 

修改了年龄，password不变

执行了showModel方法User{username=‘das’, age=19, password=‘123456’}
控制器修改用户User{username=‘das’, age=12, password=‘123456’}

ModelAttribute 修饰方法不带返回值 + 修饰参数

/** 
 * 查询数据库中用户信息  
 * 无返回值，将user对象存入map中
 * @param user  
 */ 
 @ModelAttribute 
 public void showModel(String username,Map<String,User> map) { 
 	//模拟去数据库查询  
 	User user = findUserByName(username); 
 	System.out.println("执行了 showModel 方法"+user);  
 	map.put("abc",user); 
 } 
 
 /** 
 * 模拟修改用户方法  
 * @param user 直接用ModelAttrubute封装在map中的user对象
 * @return  
 */ 
 @RequestMapping("/updateUser") 
 public String testModelAttribute(@ModelAttribute("abc")User user) {  
 	System.out.println("控制器中处理请求的方法：修改用户："+user);  
 	return "success"; 
 }

7. SessionAttribute

@SessionAttribute这个注解只有当你想在某个特定的事件处理中临时保存session会话(红色标注)的时候才适用，而当需要永久保存session的话，还是采用常规的方法，比如说：session.setAttribute

作用： 用于多次执行控制器方法间的参数共享。 SessionAttribute 只能作用在类上
属性：

• value：用于指定存入的属性名称
• type：用于指定存入的数据类型。 和value中顺序要对应上
  所以可以这样写：
  @SessionAttributes(types = {User.class,Integer.class},value={“attr1”,”attr2”})

示例代码如下：

<a href="/testPut">存入 SessionAttribute</a> <hr/> 
<a href="/testGet">取出 SessionAttribute</a> <hr/> 
<a href="/testClean">清除 SessionAttribute</a> 

@Controller
@SessionAttributes(value ={"username","password"},types={Integer.class})  
public class SessionAttributeController {    
  /** 
  * 把数据存入 SessionAttribute   
  * @param model   
  * @return 
  *  Model 是 spring 提供的一个接口，该接口有一个实现类 ExtendedModelMap   
  *  该类继承了 ModelMap，而 ModelMap 就是 LinkedHashMap 子类   
  */   
  @RequestMapping("/testPut")    
  public String testPut(Model model){    
  	//下面的代码将Model中的参数保存到了session中       
  	model.addAttribute("username", "泰斯特");           		
  	model.addAttribute("password","123456");           
  	model.addAttribute("age", 31);   
    //跳转之前将数据保存到 username、password 和 age 中，因为注解@SessionAttribute 中有 这几个参数           
    return "success";       
  }               

	@RequestMapping("/testGet")       
	public String testGet(ModelMap model){           
	   System.out.println(model.get("username")+";"
	         +model.get("password")+";"+model.get("age"));           
	   return "success";       
	 }   
             
    @RequestMapping("/testClean")        
    public String complete(SessionStatus sessionStatus){       
    	sessionStatus.setComplete();            
    	return "success";        
    }   
}