前端发送复杂JSON数据，后端接收方式

例子1：

* JSON属性如下
 * loginName: "jay"
 * password : "3333"
 * roles    : { id : 4 }
 * user     : { name:"username" , officeName : "java"}
 * ---------------------------------------------------------
 * Java实体如下
 * MyEntity 
 * String loginName
 * String password
 * RoleEntity roles   RoleEntity中有一个id属性接收
 * UserEntity user    UserEntity中有name 、 officeName 属性接收
 *
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14

什么意思呢？

前端发送的JSON数据，除了普通的键值对，还有 键–对象 ， 比如 roles : { id : 4}。

那么，对应的后台Java实体，其属性应该持有一个，叫roles的对象引用，比如 private RoleEntity roles ;

这个RoleEntity对象，应该有id属性，从而接收 id:4这组键值对。

同理，后台Java实体，也应该有一个 UserEntity 来 接收 JSON数据中 { name:“username” , officeName : “java”}。

//后台Java实体类名
   class MyEntity {
          private String loginName;  //映射Json的loginName属性 
          private String password;   //映射Json的password属性
          private RoleEntity roles;  //映射Json的roles对象 , 引用要与JSON属性一致！
          private UserEntity user;   //映射Json的user对象  ，引用要与JSON属性一致！
         class  RoleEntity{
              private Long id;   
         }
 
        class UserEntity{ 
             private String name; 
             private String officeName; 
        }    
  }
  
  Controller中 
  @RequestMapping(value="url")
  public JsonResponse  handerSomething(@RequestBody MyEntity ref)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

例子2：

{
    "name": "研发部",
    "addr": "北京",
    "users": [
        {
            "name": "地瓜",
            "age": 18
        },
        {
            "name": "土豆",
            "age": 20
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

@RequestBody接收复杂一些的JSON数据

现在前端要向后端传一段application/json类型的JSON格式数据，SpringMVC可以@RequestBody进行接收，
根据分析得出，这是要接收一个部门的信息，部门里面有多个人，为其设计对应的JAVA实体：

public class Dept {
	private String name;
	private String addr;
	private List<User> users;
    /* Get/Set方法此处省略... */
}
1
2
3
4
5
6

public class User {
	private String name;
	private int age;
    /* Get/Set省略... */
}
1
2
3
4
5

使用@RequestBody接收：

@Controller
public class HelloController {
 
	@ResponseBody
	@RequestMapping("/test")
	public Object test2(@RequestBody Dept dept) {
		System.out.println("部门名称："+dept.getName());
		System.out.println("部门地址："+dept.getAddr());
		dept.getUsers().forEach(u->{
			System.out.println("---------------");
			System.out.println("成员姓名："+u.getName());
			System.out.println("成员年龄："+u.getAge());
		});
		return dept;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这样在访问时就可以在控制台输出结果：

部门名称：研发部
部门地址：北京
---------------
成员姓名：地瓜
成员年龄：18
---------------
成员姓名：土豆
成员年龄：20
1
2
3
4
5
6
7
8

由此可以看到，客户端传来的JSON字符串，已经变成了Java对象，自动解析已经成功。
例子3：

{
    "noumenonSoid": "123", 
    "individualName": "CT平扫", 
    "individualSoid":"2029",
    "status": "145", 
    "listKnwIndividualSoltVo": [
        {
            "slotSoid": "1", 
            "derailCodingSystemSoid": "1", 
            "basic": "2", 
            "dataType": "2", 
            "list": [
                {
                    "dataSetSoid": "1"
                }, 
                {
                    "dataSetSoid": "2"
                }
            ]
        }, 
        {
            "slotSoid": "2", 
            "derailCodingSystemSoid": "3", 
            "basic": "2", 
            "dataType": "2", 
            "list": [
                {
                    "dataSetSoid": "1"
                }, 
                {
                    "dataSetSoid": "2"
                }
            ]
        }, 
        {
            "slotSoid": "2", 
            "derailCodingSystemSoid": "", 
            "basic": "2", 
            "dataType": "2", 
            "list": [
                {
                    "dataValue": "1"
                }, 
                {
                    "dataValue": "2"
                }
            ]
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2、后台controller层接收数据

@RequestBody KnwIndividualVo t
1

3、json格式数据对应实体类关系

例子4：

{
    "name": "三班",
    "students": [
        {
            "age": 25,
            "gender": "female",
            "grades": "三班",
            "name": "露西",
            "score": {
                "网络协议": 98,
                "JavaEE": 92,
                "计算机基础": 93
            },
            "weight": 51.3
        },
        {
            "age": 26,
            "gender": "male",
            "grades": "三班",
            "name": "杰克",
            "score": {
                "网络安全": 75,
                "Linux操作系统": 81,
                "计算机基础": 92
            },
            "weight": 66.5
        },
        {
            "age": 25,
            "gender": "female",
            "grades": "三班",
            "name": "莉莉",
            "score": {
                "网络安全": 95,
                "Linux操作系统": 98,
                "SQL数据库": 88,
                "数据结构": 89
            },
            "weight": 55
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

解析这个Json字符串方法：

首先， 最外层由一个大括弧”{}”包裹，那么对应的可以建一个实体类来对应，内部有两个元素，元素name比较明显是字符串类型的，元素students的值是由一个中括弧”[]”包裹，那么它对应的应该是一个数组或者列表。

接下来， 我们分析一下中括弧”[]”内部内容格式，中括弧内有三个大括弧包裹着的内容，并且内容格式基本相同，那么我们可以再定义一个实体类来对应这些大括弧。但是我们发现三个大括弧中的内容还是有些区别的，元素score对应的值虽然都是由一个大括弧来包裹，但是里边key的名称和数量都不相同。这样的情况我们不能很好的定义一个实体类来对应这个大括弧内的内容，不过我们可以定义一个Map来对应这个大括弧内的内容。

最终， 定义出来的实体类如下。

Grades.Java

package com.bean;
 
import java.util.List;
 
public class Grades {
 
    private String name;//班级名称
    private List<Student> students;//班里的所有学生
 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Student> getStudents() {
        return students;
    }
    public void setStudents(List<Student> students) {
        this.students = students;
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Student.java

package com.bean;
 
import java.util.Map;
 
/**
 *  学生
 */
public class Student {
 
    private int age;//年龄
    private String gender;//性别，male/female
    private String grades;//班级
    private String name;//姓名
    private Map<String, Integer> score;//各科分数
    private float weight;//体重
 
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getGrades() {
        return grades;
    }
    public void setGrades(String grades) {
        this.grades = grades;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Map<String, Integer> getScore() {
        return score;
    }
    public void setScore(Map<String, Integer> score) {
        this.score = score;
    }
    public float getWeight() {
        return weight;
    }
    public void setWeight(float weight) {
        this.weight = weight;
    }
 
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

定义完之后，解析过程就非常简单了：

package com.test;
 
import net.sf.json.JSONObject;
 
import com.bean.Grades;
 
public class Domain {
 
    public static void main(String[] args) {
 
        String jsonStr = "{\"name\":\"三班\",\"students\":[{\"age\":25,\"gender\":\"female\",\"grades\":\"三班\",\"name\":\"露西\",\"score\":{\"网络协议\":98,\"JavaEE\":92,\"计算机基础\":93},\"weight\":51.3},{\"age\":26,\"gender\":\"male\",\"grades\":\"三班\",\"name\":\"杰克\",\"score\":{\"网络安全\":75,\"Linux操作系统\":81,\"计算机基础\":92},\"weight\":66.5},{\"age\":25,\"gender\":\"female\",\"grades\":\"三班\",\"name\":\"莉莉\",\"score\":{\"网络安全\":95,\"Linux操作系统\":98,\"SQL数据库\":88,\"数据结构\":89},\"weight\":55}]}";
 
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
 
        Grades grades = (Grades) JSONObject.toBean(jsonObject, Grades.class);
 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18