1.3（Spring MVC学习笔记）数据绑定

一、数据绑定介绍

　　用户发送过来的数据，只有传递到服务器端的参数上才会起作用。

　　比如用户输入的用户名和密码要和后台方法中代表用户名和密码的变量关联起来，

　　从而才能使用用户传递的数据进行一些操作，这样数据才是有意义的，

　　两者之间的关联也称数据绑定。

　　数据绑定流程：

　　1.SpringMVC将ServletRequest对象传递给DataBinder组件。

　　2.将处理方法的入参对象传递给DataBinder.

　　3.DataBider组件调用ConversionService组件，ConversionService组件进行数据类型转换等工作

　　并将ServletReqeust对象中的消息填充到参数对象中。　

　　4.调用Validator组件对绑定了请求消息的的参数对象进行数据合法校验。

　　5.校验完成会生成数据绑定结果BindingResult对象，SpringMVC将BindingResult对象赋给处理方法中相应的参数。　

　　

二、简单数据绑定

　　2.1绑定简单数据类型

web.xml　　

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1"
  metadata-complete="true">
  <display-name>SpringMVC</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>

  <!-- 配置前端控制器 -->
  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class >
          org.springframework.web.servlet.DispatcherServlet
      </servlet-class> 

      <!-- 初始化时加载配置文件，该配置文件是在src目录下创建的。 -->
      <!-- <init-param>  该选项不配做会自动寻找WEB-INF下名为springmvc-servlet.xml的文件。-->
      <!--    <param-name>contextConfigLocation</param-name>-->
      <!--    <param-value>classpath:springmvc-config.xml</param-value>-->
      <!--</init-param>-->
      <!-- 当前servlet与容器一起加载 -->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <!-- 所有请求都会被前端控制器拦截-->
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

Controller类

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/dataBinder")
public class DataBinder {
    @RequestMapping("/getData")
    public String TestDataBinder(HttpServletRequest request, HttpServletResponse reponse, String name, int age) {
        String _name = request.getParameter("name");
        String _age = request.getParameter("age");
        System.out.println("_name:" + _name +"\n" + "name:" + name);
        System.out.println("_age:" + _age +"\n" + "age:" + age);
        return "success";
    }
}

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-4.3.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd">
       <!-- 开启扫描 -->
       <context:component-scan base-package = "com.springmvc.*"></context:component-scan>
       <!-- 配置处理器（Handle），映射/firstController请求 (Controller类),已由注解完成-->
       <!-- <bean name = "/firstController" class = "com.springmvc.firstmvc.FirstController"/> -->
       <!-- 配置映射处理器（handlerMapping) 将处理器（Handle）的name作为url进行查找(Spirng4.0以后无需配置) -->
       <!-- 配置适配处理器(HandlerAdapter) 适配处理器会调用处理器（Handle)即FirstController类(Spirng4.0以后无需配置) -->
       <!-- 处理器会返回一个ModelAndView,适配处理器将返回的ModelAndView交给前端控制器去处理了 -->
       <!-- 前端控制器根据ModelAndView中的View选择一个视图解析器（ViewReslover) -->
       <!-- 前端控制器将Model（msg "hello SpringMVC"）填充进视图解析器返回的视图，用户看到最后页面 -->
       <!-- 设置视图处理器及其前缀后缀 -->
       <bean id = "viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="prefix" value = "/WEB-INF/jsp/"></property>
           <property name="suffix" value = ".jsp"></property>
       </bean>
       <!-- 视图处理器解析后会将视图传递给前端控制器，前端控制对View进行渲染（将模型数据填入视图） -->
       <!-- 渲染结果会返回客户端浏览器显示 -->
</beans>

/WEB-INF/jsp/success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    success
</body>
</html>

http://localhost:8080/SpringMVC/dataBinder/getData?name=hcf&age=20

可以发现，通过reqeust.getParameter() 可以获取到请求参数。

Controller类中的TestDataBinder方法中的参数也获取到了请求参数。

注：控制器类中方法的参数名和请求中的参数名保持一致才能自动填充。

如果不一致可以通过注解的方法进行绑定。

例如

public String test(@RequestParam(value="name") String userName){
  ....
}

这样就可以将请求参数名为name的值绑定到userName上。

　　2.2绑定POJO类型。

　　绑定POJO类型即将用户请求信息封装到一个类中，然后这个类来完成参数的绑定。

　　注：请求参数名要和类中属性名一致。

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1"
  metadata-complete="true">
  <display-name>SpringMVC</display-name>

  <!-- 配置前端控制器 -->
  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class >
          org.springframework.web.servlet.DispatcherServlet
      </servlet-class> 

      <!-- 初始化时加载配置文件，该配置文件是在src目录下创建的。 -->
      <!-- <init-param>  该选项不配置，容器会自动寻找WEB-INF下名为springmvc(前端控制器配置的servlet-name)-servlet.xml的文件。-->
      <!--    <param-name>contextConfigLocation</param-name>-->
      <!--    <param-value>classpath:springmvc-config.xml</param-value>-->
      <!--</init-param>-->
      <!-- 当前servlet与容器一起加载 -->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <!-- 所有请求都会被前端控制器拦截-->
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

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-4.3.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd">
       <!-- 开启扫描 -->
       <context:component-scan base-package = "com.springmvc.*"></context:component-scan>
       <!-- 配置处理器（Handle），映射/firstController请求 (Controller类),已由注解完成-->
       <!-- <bean name = "/firstController" class = "com.springmvc.firstmvc.FirstController"/> -->
       <!-- 配置映射处理器（handlerMapping) 将处理器（Handle）的name作为url进行查找(Spirng4.0以后无需配置) -->
       <!-- 配置适配处理器(HandlerAdapter) 适配处理器会调用处理器（Handle)即FirstController类(Spirng4.0以后无需配置) -->
       <!-- 处理器会返回一个ModelAndView,适配处理器将返回的ModelAndView交给前端控制器去处理了 -->
       <!-- 前端控制器根据ModelAndView中的View选择一个视图解析器（ViewReslover) -->
       <!-- 前端控制器将Model（msg "hello SpringMVC"）填充进视图解析器返回的视图，用户看到最后页面 -->
       <!-- 设置视图处理器及其前缀后缀 -->
       <bean id = "viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="prefix" value = "/WEB-INF/jsp/"></property>
           <property name="suffix" value = ".jsp"></property>
       </bean>
       <!-- 视图处理器解析后会将视图传递给前端控制器，前端控制对View进行渲染（将模型数据填入视图） -->
       <!-- 渲染结果会返回客户端浏览器显示 -->
</beans>

　　POJO类　

public class Person {
    public String name;
    public int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Controller类

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.spring.pojo.Person;

@Controller
@RequestMapping("/dataBinder")
public class DataBinder {
    @RequestMapping("/getData")//登录页面提交表单后调用，该方法获取数据，最后返回success页面。
    public String TestDataBinder(Person per, Model model) {
        String _name = per.getName();
        int _age = per.getAge();
        model.addAttribute("name", _name);
        model.addAttribute("age", _age);
        System.out.println("_name:" + _name );
        System.out.println("_age:" + _age );
        return "success";
    }

    @RequestMapping("/login")//接收登录请求，返回登录页面。
    public String toLogin() {
        return "login";
    }
}

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action = "${pageContext.request.contextPath}/dataBinder/getData" method = "post">
        用户名:<input type = "text" name = "name"/><br/>
        密   码：<input type = "text" name = "age"/><br/>
        <input type = "submit"  value = "登录"/>
    </form>
</body>
</html>

success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    login success <br/>
    welcome: ${name } ${age }
</body>
</html>

首先输入localhost：8080/SpringMVC/dataBinder/login.执行控制类中的toLogin方法，跳转到loging.jsp页面。

在login.jsp页面输入用户名和密码，由于<input >中name属性的值和对象中的属性名相同，故进行自动绑定。

数据被封装成一个Person，然后提交到控制类中的TestDataBinder方法，从per中取出数据，并用model对象

设置数据，最后返回success页面。

　　2.3绑定包装POJO

　　有时一个类中的某一个属性是另外一个类的对象，也就是说一个类中包含另外一个类。

　　这个就需要将其包装起来再绑定。

Room.java(Room类中包含Person 和一个面积（area）属性)　　

public class Room {
    public Person person;
    public int area;

    public Person getPerson() {
        return person;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public int getArea() {
        return area;
    }
    public void setArea(int area) {
        this.area = area;
    }

}

　　接下来只需要对login.jsp、控制类中的TestDataBinder方法、success.jsp进行一定的修改即可。

login.jsp　　

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action = "${pageContext.request.contextPath}/dataBinder/getData" method = "post">
        姓   名:<input type = "text" name = "person.name"/><br/>
        年   龄：<input type = "text" name = "person.age"/><br/>
        面   积：<input type = "text" name = "area" /><br/>
        <input type = "submit"  value = "登录"/>
    </form>
</body>
</html>

此时传递的对象为room，如果请求参数是包装类（Room）直接的基本属性（如area），<input>中name的和参数名保持一致即可。

如果请求参数是包装类中其他类的属性，需要将<input>的name设置为对象属性名.属性(如person.name，其中person为Room类中Person类的属性名)

控制类

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.spring.pojo.*;

@Controller
@RequestMapping("/dataBinder")
public class DataBinder {
    @RequestMapping("/getData")//登录页面提交表单后调用，该方法获取数据，最后返回success页面。
    public String TestDataBinder(Room room, Model model) {//参数为Room类型
        String _name = room.getPerson().getName();
        int _age =room.getPerson().getAge();
        int _area = room.getArea();

        model.addAttribute("name", _name);
        model.addAttribute("age", _age);
        model.addAttribute("area", _area);

        System.out.println("_name:" + _name );
        System.out.println("_age:" + _age );
        System.out.println("area" + _area );
        return "success";
    }

    @RequestMapping("/login")//接收登录请求，返回登录页面。
    public String toLogin() {
        return "login";
    }
}

success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    login success <br/>
    welcome: ${name } ${age } ${area }
</body>
</html>

　　2.4自定义数据绑定

　　例如有时要将字符串日期转换为Date对象，这时就需要将其转换，然后再绑定。

　　　　2.4.1实现Convert接口进行转换

　　　　自定义转换类需要实现org.springframework.core.convert.converter.Converter接口

　　　　pubilic interface Convert<S,T>{

　　　　　　T convert(S source){...}

　　　　}

　　　　其中S是源类型，T是目标类型。S->T。

DataConvert.java(日期转换类)　　　　

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.core.convert.converter.Converter;

public class DataConvert implements Converter<String, Date> {

    @Override
    public Date convert(String dataStr) {
        // TODO Auto-generated method stub
        String pattern = "yyyy-MM-dd hh:mm:ss";
        DateFormat format = new SimpleDateFormat(pattern);
        Date date = null;
        try {
            date = format.parse(dataStr);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new IllegalArgumentException("无效的日期格式，请使用：" + pattern + "格式");
        }
        return date;
    }

}

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans     xmlns="http://www.springframework.org/schema/beans"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="
             http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd">
       <!-- 开启扫描 -->
       <context:component-scan base-package = "com.springmvc.*"></context:component-scan>
       <!-- 配置处理器（Handle），映射/firstController请求 (Controller类),已由注解完成-->
       <!-- <bean name = "/firstController" class = "com.springmvc.firstmvc.FirstController"/> -->
       <!-- 配置映射处理器（handlerMapping) 将处理器（Handle）的name作为url进行查找(Spirng4.0以后无需配置) -->
       <!-- 配置适配处理器(HandlerAdapter) 适配处理器会调用处理器（Handle)即FirstController类(Spirng4.0以后无需配置) -->
       <!-- 处理器会返回一个ModelAndView,适配处理器将返回的ModelAndView交给前端控制器去处理了 -->
       <!-- 前端控制器根据ModelAndView中的View选择一个视图解析器（ViewReslover) -->
       <!-- 前端控制器将Model（msg "hello SpringMVC"）填充进视图解析器返回的视图，用户看到最后页面 -->
       <!-- 设置视图处理器及其前缀后缀 -->
       <bean id = "viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="prefix" value = "/WEB-INF/jsp/"></property>
           <property name="suffix" value = ".jsp"></property>
       </bean> 

       <!-- 视图处理器解析后会将视图传递给前端控制器，前端控制对View进行渲染（将模型数据填入视图） -->
       <!-- 渲染结果会返回客户端浏览器显示 -->

       <!-- 配置自定义转换器 -->
       <mvc:annotation-driven conversion-service="conversionService"/> 

       <!-- 自定义转换器 -->
       <bean id = "conversionService" class = "org.springframework.context.support.ConversionServiceFactoryBean">
           <!-- converters属性用于指定所有自定义的Convert -->
           <property name="converters">
               <set>
                   <bean class = "com.springmvc.convert.DataConvert"></bean>
               </set>
           </property>
       </bean> 

</beans>

Controller类

import java.util.Date;

import org.springframework.web.bind.annotation.RequestMapping;

@org.springframework.stereotype.Controller
public class Controller {
    @RequestMapping("/dateConvert")
    public String dataConvert(Date date) {//请求参数中date会被转换去解析，然后绑定到形参date上
        System.out.println(date);
        return "success";
    }
}

success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
     success <br/>

</body>
</html>

输入的字符串要符合指定的格式

http://localhost:8080/SpringMVC/dateConvert?date=2019-2-20%208:36:40

其中URL的%20代表空格。

无效的格式：

http://localhost:8080/SpringMVC/dateConvert?date=111

　　　　　2.4.2实现Formatter接口进行转换

　　　　　　org.springframework.format.Formatter

　　　　　　public interface Formatter<T> extends Printer<T>,Parser<T>{}

　　　　　　实现Formatter接口后,需要实现print和parse两个方法。

　　　　　　其中T是目标对象，使用Formatter进行转换源目标必须是String类型。

　　　　　　使用和Convert大致相同。

　　DateFormatter.java(转换类)　　　

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

import org.springframework.format.Formatter;

public class DataFormatter implements Formatter<Date>{
    private String pattern = "yyyy-MM-dd hh:mm:ss";
    private DateFormat foram = new SimpleDateFormat(pattern);

    @Override
    public String print(Date date, Locale local) {
        // TODO Auto-generated method stub
        return foram.format(date);
    }

    @Override
    public Date parse(String dateStr, Locale local) throws ParseException {
        // TODO Auto-generated method stub
        return foram.parse(dateStr);//返回日期对象
    }

}

控制类：

import java.util.Date;

import org.springframework.web.bind.annotation.RequestMapping;

@org.springframework.stereotype.Controller
public class ControllerDateFormat {
    @RequestMapping("/dateConvert")
    public String dataConvert(Date date) {
        System.out.println(date);
        return "success";
    }
}

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans     xmlns="http://www.springframework.org/schema/beans"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="
             http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd">
       <!-- 开启扫描 -->
       <context:component-scan base-package = "com.springmvc.*"></context:component-scan>
       <!-- 配置处理器（Handle），映射/firstController请求 (Controller类),已由注解完成-->
       <!-- <bean name = "/firstController" class = "com.springmvc.firstmvc.FirstController"/> -->
       <!-- 配置映射处理器（handlerMapping) 将处理器（Handle）的name作为url进行查找(Spirng4.0以后无需配置) -->
       <!-- 配置适配处理器(HandlerAdapter) 适配处理器会调用处理器（Handle)即FirstController类(Spirng4.0以后无需配置) -->
       <!-- 处理器会返回一个ModelAndView,适配处理器将返回的ModelAndView交给前端控制器去处理了 -->
       <!-- 前端控制器根据ModelAndView中的View选择一个视图解析器（ViewReslover) -->
       <!-- 前端控制器将Model（msg "hello SpringMVC"）填充进视图解析器返回的视图，用户看到最后页面 -->

       <!-- 设置视图处理器及其前缀后缀 -->
       <bean id = "viewResolver" class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="prefix" value = "/WEB-INF/jsp/"></property>
           <property name="suffix" value = ".jsp"></property>
       </bean> 

       <!-- 视图处理器解析后会将视图传递给前端控制器，前端控制对View进行渲染（将模型数据填入视图） -->
       <!-- 渲染结果会返回客户端浏览器显示 -->

       <!-- 配置自定义转换器 -->
       <mvc:annotation-driven conversion-service="formatService"/> 

       <!-- 自定义转换器(Convert) -->
       <!-- <bean id = "conversionService" class = "org.springframework.context.support.ConversionServiceFactoryBean">
           converters属性用于指定所有自定义的Convert
           <property name="converters">
               <set>
                   <bean class = "com.springmvc.convert.DataConvert"></bean>
               </set>
           </property>
       </bean>  -->

       <!-- 自定义转换器（Format） -->
       <bean id = "formatService" class = "org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="formatters">
            <set>
                <bean class = "com.springmvc.formatter.DataFormatter"></bean>
            </set>
        </property>
       </bean>

</beans>

　　2.2绑定复杂数据类型

　　　　2.2.1绑定数组，绑定数组与前面直接绑定参数类型，

　　　　但要求数组名和<input>中name属性的值相同。

　　　　如果名称不同可通过@RequestParam注解绑定。

控制类　　　

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TestArrayBinderControl {
    @RequestMapping("/success")
    public String bingderArray(String[] ids , HttpServletRequest request) {
        request.setAttribute("ids", ids);
        System.out.println("into bingderArray");
        return "success";
    }

    @RequestMapping("/toSelect")
    public String toSelect() {
        return "select";
    }
}

select.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action = "${pageContext.request.contextPath}/success" method = "post">
        篮球:<input type = "checkBox" name = "ids" value = "basketball"/>
        足球:<input type = "checkBox" name = "ids" value = "football"/>
        网球:<input type = "checkBox" name = "ids" value = "tennis"/>
        <input type = "submit" value = "提交"/>
    </form>
</body>
</html>

success.jsp(用于展示成功页面，并输出选择数据)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<%! %>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
     success <br/>
     <%
         String[] ids = (String[])request.getAttribute("ids");
         if(ids !=null){
             for(String temp: ids){
     %>
                 <%=temp%>
     <%
             }
         }else{
             response.getWriter().println("null");
         };
     %>
</body>
</html>

　　　　2.2.2绑定集合

　　　　集合不能绑定，需要将集合作为POJO类的一个参数，通过传递POJO类进行间接绑定。

　　　　类似前面的POJO绑定，只不过将POJO中的属性变成了集合。

POJO类　　　　

import java.util.List;

public class POJO<T> {
    public List<T> list;

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }
}

控制类

@Controller
public class TestListBinderControl {
    @RequestMapping("/success")
    public String bingderArray(POJO<String> p , HttpServletRequest request) {
        request.setAttribute("ids", p);
        return "success";
    }

    @RequestMapping("/toSelect")
    public String toSelect() {
        return "select";
    }
}

select.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action = "${pageContext.request.contextPath}/success" method = "post">
        篮球:<input type = "checkBox" name = "list[0]" value = "basketball"/>
        足球:<input type = "checkBox" name = "list[1]" value = "football"/>
        网球:<input type = "checkBox" name = "list[2]" value = "tennis"/>
        <input type = "submit" value = "提交"/>
    </form>
</body>
</html>

由于控制类中方法的形参是POJO类型，只需name与POJO中属性名称一致即可完成POJO绑定。

绑定后通过POJO获取集合。

success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="com.springmvc.binderList.*" %>  <!--使用的类要导入-->
<!DOCTYPE html>
<%! %>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
     success <br/>
     <%
         POJO<String> p = (POJO<String>)request.getAttribute("ids");
         if(p !=null){
             for(String temp: p.getList()){
     %>
                 <%=temp%>
     <%
             }
         }else{
             response.getWriter().println("null");
         };
     %>
</body>
</html>

效果与之前绑定数组效果一致。

如果POJO中的集合是不基本类型而是自定义的类。

例如User中两个属性id和name。POJO中是 List<User> list.

则<input>中name属性的值对应即可。

例如以上述假设为例：

<input name = list[0].id> 即可，list[0]看做一个User对象，直接指定对象中属性即可。

多个类包含以此类推。