springMVC前后端各种类型数据绑定

最新推荐文章于 2022-04-14 12:56:33 发布

xiaomifeng1010

最新推荐文章于 2022-04-14 12:56:33 发布

阅读量538

点赞数

本文链接：https://blog.csdn.net/u011174699/article/details/105141598

版权

Spring MVC 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

springmvc使用中，经常需要将用户界面的元素（参数值）传递到controller控制器中进行逻辑处理，即将前端参数值绑定到后端实例（对象）属性上，进行逻辑处理。可以称之为数据绑定。

数据绑定会涉及到各种数据类型，如基本数据类型int，long，double，boolean等，以及包装类型Integer,long,Double等，或者自定义的对象类型，以及使用集合形式，数组形式的作为数据类型的情况，在数据传递中需要注意一些问题。

1.测试第一种数据类型：基本数据类型

2.测试第二种数据类型：基本数据类型的包装类型

3.测试第三种数据类型：数组类型

4.测试第四种数据类型：传递的数据类型为集合类型（List，Set和Map）

5.测试第五种数据类型：传递的数据类型为json或者xml

实例演示

在idea中创建一个maven项目springmvcDataBind,将maven项目结构补全，添加上test目录，以及main目录下的java目录和resources目录。

然后在pom文件中加入需要使用到的jar包依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xiaomifeng.cn</groupId>
  <artifactId>springmvc-databind</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-databind Maven Webapp</name>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-servlet-api</artifactId>
      <version>7.0.64</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.3.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.4</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>springmvc-databind</finalName>
  </build>
</project>

接下来配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         id="WebApp_ID" version="2.5">

  <display-name>Archetype Created Web Application</display-name>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:applicationContext.xml
    </param-value>
  </context-param>

  <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
  </listener>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <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>

  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

以及其他的配置文件dispatcher-servelt.xml(和web.xml)位于同一目录下，以及resources目录下的applicationContext.xml配置文件

如下是：dispatcher-servelt.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com" annotation-config="true"/>
    <mvc:annotation-driven conversion-service="myDateConverter"/>

      <bean id ="myDateConverter" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.xiaomifeng1010.common.MyDateConverter"></bean>
                <bean class="org.springframework.core.convert.support.StringToBooleanConverter"></bean>
            </set>
        </property>
    </bean>
</beans>

和applicationContext.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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com" annotation-config="true"/>


</beans>

然后配置项目的服务器为tomcat,将该项目的war包部署到tomcat

在项目目录中创建controller包，建立DataBindTestController类，启动tomcat，

1.测试第一种数据类型：基本数据类型

 @RequestMapping("baseType")
    @ResponseBody
    public String baseType(long price) {
        return "价格是："+price;
    }

注意上边这样的请求，因为返回值中有中文，在浏览器中，中文会显示为"？？"

因此需要处理中文转码的问题（在@RequestMapping注解中加上produces="text/plain;charset=UTF-8"）

 @RequestMapping(value="baseType",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String baseType(double price) {
        return "价格是："+price;
    }

再次请求，返回值就正常显示了

注意，因为数据类型是基本数据类型，因此出入的参数值也必须是基本数据类型，不能不传值，也不能传入其他类型值。

如果不传值，会报500错误

如果传入其他类型的值(price类型是long，赋值字符串），则报400错误

2.测试第二种数据类型：基本数据类型的包装类型

 @RequestMapping(value="baseTypeWrapper",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String baseTypeWrapper(Double price){
        return "价格："+price;
    }

引用类型和基本数据类型的区别在于，引用类型的值可以为null,所以不给参数赋值也可以

3.测试第三种数据类型：数组类型

@RequestMapping(value = "arrayType")
    @ResponseBody
    public String arrayType(String[] name) {
//        List<String> list=Stream.of(names).distinct().sorted((x, y) -> x.length()-y.length()).collect(Collectors.toList());
        StringBuilder sbf = new StringBuilder();
        for(String item : name){
            sbf.append(item).append(" ");
        }
        return sbf.toString();

    }

为name赋予多个值

3.测试第三种数据类型：自定义的具有相同属性的类

创建实体类包，包下创建Product类和Address类及Corporation类

Product类(多层级对象，包含了Address对象）

package com.xiaomifeng1010.entity;
import	java.util.Optional;

import lombok.Data;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 14:15
 */

@Data
public class Product {
    /**
     * 产品名
     */
    String name;
    /**
     * 产品数量
     */
    Integer amount;
    /**
     * 地址
     */
    Address address;
}

Address类

package com.xiaomifeng1010.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 14:20
 */
@Data
public class Address implements Serializable {
    private static final long serialVersionUID = -6389423477748597401L;

    /**
     * 省份
     */
    private String province;
    /**
     * 市
     */
    private String city;
    /**
     * 区
     */
    private String district;
    /**
     * 乡镇
     */
    private String town;
    /**
     * 村
     */
    private String village;
}

Corporation类

package com.xiaomifeng1010.entity;

import lombok.Data;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 14:33
 */
@Data
public class Corporation {
    /**
     * 公司名
     */
    String name;
    /**
     * 公司数量
     */
    Integer amount;
}

进行测试

  /**
     * 测试自定义的类
     * Product类和Corporation类中都有nmae和amount属性
     */
    @RequestMapping(value = "object")
    @ResponseBody
    public String object(Product product, Corporation corporation){
        return product.toString() +"/"+corporation.toString();

    }

因为两个类中都有name属性和amount属性，所以同时传递给两个对象相同的名字和数量

注意给 Product类中包含的Address对象赋值，只需要用address点出address的属性名

注意：如果想要Product类与Corporation的名字和数量分别赋予不同的值，还需要数据绑定的方法（给每个类设置一个绑定的前缀）

@InitBinder("product")
    public void initUser(WebDataBinder binder){
        binder.setFieldDefaultPrefix("product.");
    }
    @InitBinder("corporation")
    public void initAdmin(WebDataBinder binder){
        binder.setFieldDefaultPrefix("corporation.");
    }

设置好之后需要重启一下项目（即使tomcat热部署也需要重新启动一下项目，因为这两个方法需要加载controller类的时候，先加载这连个方法，才去执行具体的请求方法）

如果没有设置数据绑定前缀，那么直接用product.name传入参数值，返回的name是null.

4.测试第四种数据类型：传递的数据类型为集合类型（List，Set和Map）

4.1关于List的数据绑定

在Product类基础上，将Product类作为List的元素，创建dto包，包下创建ProductList类(不要在controller中直接使用List<Product>，而是将List<Product>作为ProductList属性)

package com.xiaomifeng1010.dto;

import com.xiaomifeng1010.entity.Product;
import lombok.Data;

import java.util.List;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 17:25
 */
@Data
public class ProductList {
    private List<Product> products;
}

controller中请求方法，进行测试：

/**
     * 测试List类型
     * @param productList
     * @return
     */
    @RequestMapping(value = "list",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String list(ProductList productList){
       return "productList.size:"+productList.getProducts().size()+"\t第一组产品"+productList.getProducts().get(0).toString();
    }

使用ProductList中的属性products来传参 ,products是List类型，所以存在索引，用索引来传递多组值

可以发现，传入第一组产品的名字时候，直接报错了，为什么呢？根据错误提示，查询了一下，说是因为tomcat版本的问题，我用的tomcat版本是8.5.39，在url中输入特殊符号如中括号，是不被RFC7230和RFC3986定义的规范允许的，其实就是涉及到了urlEncode的问题，url编码问题，特殊字符对应的有特殊的编码，网络上的解决方案有更换tomcat版本，或者修改tomcat的配置文件，或者在后端处理一下urlencode问题。因为演示，最简单的方法就是直接用可以识别的字符替代，中括号的左边[用%5B,右边]用%5D替代，然后再次请求就可以了识别了

注意，在传参的时候，如果第一组即products[0]之后直接跳跃，传入products[20]，中间会有很多对象是null

4.2关于Set的数据绑定

set的应用主要在去除重复的方面

例如Product对象中，如果各属性值都一样，则是重复对象.实际只会保存一个

在dto包下新建ProductSet类

package com.xiaomifeng1010.dto;

import com.xiaomifeng1010.entity.Product;
import lombok.Data;

import java.util.Set;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 19:28
 */
@Data
public class ProductSet {
    private Set<Product> products;
}

controller中添加请求方法

  /**
     * 测试Set类型
     * @param productSet
     * @return
     */
    @RequestMapping(value = "set",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String set(ProductSet productSet){
        return  "productSet.size:"+productSet.getProducts().size()+productSet.toString();
    }

还是按照原先的方式，给两组参数，第一组和第二组，但是却报错了500，错误提示翻译了一下，就是说set的size是0，但是却传入了两个元素（所以无法从大小为0的Set中获取索引为0的元素）

所以代码需要修改一下，给set中添加几个元素对象（使其初始化的时候大小不为0）

package com.xiaomifeng1010.dto;

import com.xiaomifeng1010.entity.Product;
import lombok.Data;

import java.util.HashSet;
import java.util.Set;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 19:28
 */
@Data
public class ProductSet {
    private Set<Product> products;

    private ProductSet(){
        products = new HashSet<>();
        products.add(new Product());
        products.add(new Product());


    }
}

好了，再重新请求一下：

可以看到size是1，虽然hashset中添加了两个new Product()，但是两个new Product()对象相同(因为Product属性都是null）

所以如果再增加一组就又会报错500（真的是麻烦,springMVC对set的支持还不够友好，所以要接收多组数据，优先选用List）

4.3关于Map的数据绑定

在dto包下创建ProductMap类

package com.xiaomifeng1010.dto;

import com.xiaomifeng1010.entity.Product;
import lombok.Data;

import java.util.Map;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 20:07
 */
@Data
public class ProductMap {

    private Map<String, Product> products;
}

在controller中加上请求方法

  /**
     * 测试Map类型
     * @param productMap
     * @return
     */
    @RequestMapping(value = "map",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String map(ProductMap productMap){
        return  "productMap.size:"+productMap.getProducts().size()+"对象："+productMap.toString();
    }

在url请求中，使用的还是productMap的属性products,但是products是Map类型，传参的时候，每一对元素的key值是字符串类型，放在中括号中，类似于list和set的索引用法

key为xiaomifeng1010的product的产品名为iPad，数量为2

5.测试第五种数据类型：传递的数据类型为json或者xml

5.1 json格式

以json格式作为请求体

传入一个Product对象

 /**
     * 测试json类型
     * @param product
     * @return
     */
    @RequestMapping(value = "json",method = RequestMethod.POST,produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String json(@RequestBody Product product){
        return  product.toString();
    }

使用json格式的请求体，在请求方法中使用@RequestBody方法将json格式请求体传给product对象（json对象反序列化为product对象）

json数据：

{
    "name": "xiaomifeng1010",
    "amount": 233,
    "address": {
        "province": "hubei",
        "city": "xiangyang",
        "district": "xiangzhou",
        "town": "chenhe",
        "village": "wangwang"
    }
}

接下来使用chrome浏览器插件(叫API Tester)模拟发送报文（也可以使用独立的软件postman），API Tester在浏览器中无法截图完整：但是200，返回正常

postman截图：

注意，一开始发送请求的时候一直报415错误，提示格式不支持，后来查询了很久，发现是少了一些依赖包

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.10.2</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.10.2</version>
</dependency>

把这两个依赖包也加上

最初项目中只加了一个json相关的jar包

<dependency>
  <groupId>org.codehaus.jackson</groupId>
  <artifactId>jackson-mapper-asl</artifactId>
  <version>1.9.13</version>
</dependency>

完整的依赖为：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xiaomifeng.cn</groupId>
  <artifactId>springmvc-databind</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>springmvc-databind Maven Webapp</name>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-servlet-api</artifactId>
      <version>7.0.64</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.3.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.4</version>
    </dependency>
    <!--处理json的相关jar包依赖-->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.2</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.2</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>springmvc-databind</finalName>
  </build>
</project>

算是踩了一个坑。

5.2 xml格式

controller中添加新的请求方法：

  /**
     * 测试xml格式
     * @param address
     * @return
     */
    @RequestMapping(value = "xml",method = RequestMethod.POST,produces = "application/xml;charset=UTF-8")
    @ResponseBody
    public String xml(@RequestBody Address address){
        return  address.toString();

    }

为了方便测试，还用刚才的json数据，使用工具网站，将json格式转为xml格式，工具网址：http://www.bejson.com/xml2json/

使用工具很轻易转换成了xml格式：

<?xml version="1.0" encoding="UTF-8" ?>
	<name>xiaomifeng1010</name>
	<amount>233</amount>
	<address>
		<province>hubei</province>
		<city>xiangyang</city>
		<district>xiangzhou</district>
		<town>chenhe</town>
		<village>wangwang</village>
	</address>

使用这个jar包处理xml

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-oxm</artifactId>
  <version>5.2.2.RELEASE</version>
</dependency>

同时Address类也需要修改一下

package com.xiaomifeng1010.entity;

import lombok.Data;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.Serializable;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 14:20
 */
@XmlRootElement(name="address")
public class Address implements Serializable {
    private static final long serialVersionUID = -6389423477748597401L;

    /**
     * 省份
     */
    private String province;
    /**
     * 市
     */
    private String city;
    /**
     * 区
     */
    private String district;
    /**
     * 乡镇
     */
    private String town;
    /**
     * 村
     */
    private String village;

    @XmlElement(name="province")
    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    @XmlElement(name="city")
    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @XmlElement(name="district")
    public String getDistrict() {
        return district;
    }

    public void setDistrict(String district) {
        this.district = district;
    }

    @XmlElement(name="town")
    public String getTown() {
        return town;
    }

    public void setTown(String town) {
        this.town = town;
    }

    @XmlElement(name="village")
    public String getVillage() {
        return village;
    }

    public void setVillage(String village) {
        this.village = village;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                ", district='" + district + '\'' +
                ", town='" + town + '\'' +
                ", village='" + village + '\'' +
                '}';
    }
}

类上添加注解@XmlRootElement,同时属性的get方法上添加@XmlElement注解

然后在postman中发请求

<?xml version="1.0" encoding="UTF-8" ?>
   <address>
       <province>hubei</province>
       <city>xiangyang</city>
       <district>xiangzhou</district>
       <town>chenhe</town>
       <village>wangwang</village>
   </address>

只要address那一部分的xml

请求头中content-type中设置application/xml

最后放上controller类中完整的请求方法代码：

package com.xiaomifeng1010.controller;

import com.xiaomifeng1010.dto.ProductList;
import com.xiaomifeng1010.dto.ProductMap;
import com.xiaomifeng1010.dto.ProductSet;
import com.xiaomifeng1010.entity.Address;
import com.xiaomifeng1010.entity.Corporation;
import com.xiaomifeng1010.entity.Product;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 2020/3/27 14:41
 */
@Controller
public class DataBindTestController {

    /**
     * 测试基本数据类型
     * @param price
     * @return
     */
    @RequestMapping(value="baseType",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String baseType(double price) {
        return "价格是："+price;
    }

    /**
     * 测试基本数据类型的包装类（引用类型）
     * @param price
     * @return
     */
    @RequestMapping(value="baseTypeWrapper",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String baseTypeWrapper(Double price){
        return "价格："+price;
    }

    /**
     * 测试数组类型
     * @param name
     * @return
     */
    @RequestMapping(value = "arrayType")
    @ResponseBody
    public String arrayType(String[] name) {
//        List<String> list=Stream.of(names).distinct().sorted((x, y) -> x.length()-y.length()).collect(Collectors.toList());
        StringBuilder sbf = new StringBuilder();
        for(String item : name){
            sbf.append(item).append(" ");
        }
        return sbf.toString();

    }

    /**
     * 测试自定义的类
     * Product类和Corporation类中都有nmae和amount属性
     */
    @RequestMapping(value = "object")
    @ResponseBody
    public String object(Product product, Corporation corporation){
        return product.toString() +"/"+corporation.toString();

    }

    @InitBinder("product")
    public void initUser(WebDataBinder binder){
        binder.setFieldDefaultPrefix("product.");
    }
    @InitBinder("corporation")
    public void initAdmin(WebDataBinder binder){
        binder.setFieldDefaultPrefix("corporation.");
    }

    /**
     * 测试List类型
     * @param productList
     * @return
     */
    @RequestMapping(value = "list",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String list(ProductList productList){
//       return "productList.size:"+productList.getProducts().size()+"\t第一组产品"+productList.getProducts().get(0).toString();
        return  "productList.size:"+productList.getProducts().size()+productList.toString();
    }


    /**
     * 测试Map类型
     * @param productMap
     * @return
     */
    @RequestMapping(value = "map",produces="text/plain;charset=UTF-8")
    @ResponseBody
    public String map(ProductMap productMap){
        return  "productMap.size:"+productMap.getProducts().size()+"对象："+productMap.toString();
    }

    /**
     * 测试json类型
     * @param product
     * @return
     */
    @RequestMapping(value = "json",method = RequestMethod.POST,produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String json(@RequestBody Product product){
        return  product.toString();
    }

    /**
     * 测试xml格式
     * @param address
     * @return
     */
    @RequestMapping(value = "xml",method = RequestMethod.POST,produces = "application/xml;charset=UTF-8")
    @ResponseBody
    public String xml(@RequestBody Address address){
        return  address.toString();

    }

    /**
     * 测试xml格式
     * @param product
     * @return
     */
//    @RequestMapping(value = "xml",method = RequestMethod.POST,produces = "application/xml;charset=UTF-8")
//    @ResponseBody
//    public String xml(@RequestBody Product product){
//        return  product.toString();
//
//    }


}

xiaomifeng1010

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springMVC前后端各种类型数据绑定

springmvc使用中，经常需要将用户界面的元素（参数值）传递到controller控制器中进行逻辑处理，即将前端参数值绑定到后端实例（对象）属性上，进行逻辑处理。可以称之为数据绑定。数据绑定会涉及到各种数据类型，如基本数据类型int，long，double，boolean等，以及包装类型Integer,long,Double等，或者自定义的对象类型，以及使用集合形式，数组形式的作为数据类型...
复制链接

扫一扫

专栏目录