【转载】对Json进行处理的Google Gson API教程

来源：互联网发布：wampserver如何运行php 编辑：程序博客网时间：2024/04/29 10:54

对Json进行处理的Google Gson API教程

在上一篇文章中，我们已经接触了针对JSON处理的Java API，你很容易就会发现，它并不容易使用，无论你是否必须将JSON转换为Java对象，或者其他需求，你都需要写上很多与目标JSON结构高度耦合的代码。

这也是为什么我开始留意其他能做到自行转换格式的API，Gson映入了我的眼帘。Gson是开源的，并已被广泛应用于JSON和Java中，Gson使用Java反射API，提供了诸多易于使用的方式将JSON转换为Java，反之亦然。

你可以从google的代码站点下载到Gson的jar文件，或者如果你正在使用maven，那么你所需要做的所有事情仅仅是添加以下依赖。

1
2
3
4
5
6
7
8
<dependencies>
    <!--  Gson dependency -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.2.4</version>
    </dependency>
</dependencies>

Gson是非常强大的API，它支持Java泛型，支持现成的JSON与Java对象的转换，只要对象的成员名称与JSON中的一致即可。如果针对Java bean和JSON要使用不同的名称，那么可以使用@SerializedName注解来映射JSON和Java类中的变量。

我们来看一个复杂示例，在JSON中含有嵌套对象以及数组，我们要将其映射到Java bean的属性（List、Map、Array类型等）中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
  "empID": 100,
  "name":"David",
  "permanent":false,
  "address": {
    "street":"BTM 1st Stage",
    "city":"Bangalore",
    "zipcode": 560100
  },
  "phoneNumbers": [
    123456,
    987654
  ],
  "role":"Manager",
  "cities": [
    "Los Angeles",
    "New York"
  ],
  "properties": {
    "age":"28 years",
    "salary":"1000 Rs"
  }
}

建立Java bean类，将JSON转换为Java对象。

Employee.java

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
packagecom.journaldev.json.model;
 
importjava.util.Arrays;
importjava.util.List;
importjava.util.Map;
 
importcom.google.gson.annotations.SerializedName;
 
publicclass Employee {
 
    @SerializedName("empID")
    privateint id;
    privateString name;
    privateboolean permanent;
    privateAddress address;
    privatelong[] phoneNumbers;
    privateString role;
    privateList<String> cities;
    privateMap<String, String> properties;
 
    publicint getId() {
        returnid;
    }
    publicvoid setId(intid) {
        this.id = id;
    }
    publicString getName() {
        returnname;
    }
    publicvoid setName(String name) {
        this.name = name;
    }
    publicboolean isPermanent() {
        returnpermanent;
    }
    publicvoid setPermanent(booleanpermanent) {
        this.permanent = permanent;
    }
    publicAddress getAddress() {
        returnaddress;
    }
    publicvoid setAddress(Address address) {
        this.address = address;
    }
    publiclong[] getPhoneNumbers() {
        returnphoneNumbers;
    }
    publicvoid setPhoneNumbers(long[] phoneNumbers) {
        this.phoneNumbers = phoneNumbers;
    }
    publicString getRole() {
        returnrole;
    }
    publicvoid setRole(String role) {
        this.role = role;
    }
 
    @Override
    publicString toString(){
        StringBuilder sb = newStringBuilder();
        sb.append("***** Employee Details *****n");
        sb.append("ID="+getId()+"n");
        sb.append("Name="+getName()+"n");
        sb.append("Permanent="+isPermanent()+"n");
        sb.append("Role="+getRole()+"n");
        sb.append("Phone Numbers="+Arrays.toString(getPhoneNumbers())+"n");
        sb.append("Address="+getAddress()+"n");
        sb.append("Cities="+Arrays.toString(getCities().toArray())+"n");
        sb.append("Properties="+getProperties()+"n");
        sb.append("*****************************");
 
        returnsb.toString();
    }
    publicList<String> getCities() {
        returncities;
    }
    publicvoid setCities(List<String> cities) {
        this.cities = cities;
    }
    publicMap<String, String> getProperties() {
        returnproperties;
    }
    publicvoid setProperties(Map<String, String> properties) {
        this.properties = properties;
    }
}

Address.java

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
packagecom.journaldev.json.model;
 
publicclass Address {
 
    privateString street;
    privateString city;
    privateint zipcode;
 
    publicString getStreet() {
        returnstreet;
    }
    publicvoid setStreet(String street) {
        this.street = street;
    }
    publicString getCity() {
        returncity;
    }
    publicvoid setCity(String city) {
        this.city = city;
    }
    publicint getZipcode() {
        returnzipcode;
    }
    publicvoid setZipcode(intzipcode) {
        this.zipcode = zipcode;
    }
 
    @Override
    publicString toString(){
        returngetStreet() + ", "+getCity()+", "+getZipcode();
    }
}

下面是Java程序，展示了如何将JSON转换为Java对象，反之亦然。

EmployeeGsonExample.java

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
56
57
58
59
60
61
62
63
64
65
66
67
packagecom.journaldev.json.gson;
 
importjava.io.IOException;
importjava.nio.file.Files;
importjava.nio.file.Paths;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
 
importcom.google.gson.Gson;
importcom.google.gson.GsonBuilder;
importcom.journaldev.json.model.Address;
importcom.journaldev.json.model.Employee;
 
publicclass EmployeeGsonExample {
 
    publicstatic void main(String[] args) throwsIOException {
        Employee emp = createEmployee();
 
        // Get Gson object
        Gson gson = newGsonBuilder().setPrettyPrinting().create();
 
        // read JSON file data as String
        String fileData = newString(Files.readAllBytes(Paths
                .get("employee.txt")));
 
        // parse json string to object
        Employee emp1 = gson.fromJson(fileData, Employee.class);
 
        // print object data
        System.out.println("nnEmployee Objectnn" + emp1);
 
        // create JSON String from Object
        String jsonEmp = gson.toJson(emp);
        System.out.print(jsonEmp);
 
    }
 
    publicstatic Employee createEmployee() {
 
        Employee emp = newEmployee();
        emp.setId(100);
        emp.setName("David");
        emp.setPermanent(false);
        emp.setPhoneNumbers(newlong[] { 123456,987654});
        emp.setRole("Manager");
 
        Address add = newAddress();
        add.setCity("Bangalore");
        add.setStreet("BTM 1st Stage");
        add.setZipcode(560100);
        emp.setAddress(add);
 
        List<String> cities = newArrayList<String>();
        cities.add("Los Angeles");
        cities.add("New York");
        emp.setCities(cities);
 
        Map<String, String> props = newHashMap<String, String>();
        props.put("salary","1000 Rs");
        props.put("age","28 years");
        emp.setProperties(props);
 
        returnemp;
    }
}

Gson是主类，它暴露出fromJson()和toJson()方法进行转换工作，对于默认实现，可以直接创建对象，也可以使用GsonBuilder类提供的实用选项进行转换，比如整齐打印，字段命名转换，排除字段，日期格式化，等等。

当运行以上程序时，可以看到以下Java对象的输出。

1
2
3
4
5
6
7
8
9
10
11
12
Employee Object
 
***** Employee Details *****
ID=100
Name=David
Permanent=false
Role=Manager
Phone Numbers=[123456, 987654]
Address=BTM 1st Stage, Bangalore, 560100
Cities=[Los Angeles, New York]
Properties={age=28 years, salary=1000 Rs}
*****************************

你可以看到，使用Gson是多么的容易，这就是为什么它在JSON处理方面如此风靡。

以上的JSON处理方式是我们所熟知的对象模型，因为整个JSON被一次性的转换为对象了，在大多数情况下这足够了，然而如果JSON确实非常庞大，我们不想将其全部一次性置入内存，Gson也提供了Streaming API。

我们来看一个例子，它展示了如何使用Streaming API进行JSON到Java对象的转换。

EmployeeGsonReader.java

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
packagecom.journaldev.json.gson;
 
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
 
importcom.google.gson.stream.JsonReader;
importcom.google.gson.stream.JsonToken;
importcom.journaldev.json.model.Address;
importcom.journaldev.json.model.Employee;
 
publicclass EmployeeGsonReader {
 
    publicstatic void main(String[] args) throwsIOException {
        InputStream is = newFileInputStream("employee.txt");
        InputStreamReader isr = newInputStreamReader(is);
 
        //create JsonReader object
        JsonReader reader = newJsonReader(isr);
 
        //create objects
        Employee emp = newEmployee();
        Address add = newAddress();
        emp.setAddress(add);
        List<Long> phoneNums = newArrayList<Long>();
        emp.setCities(newArrayList<String>());
        emp.setProperties(newHashMap<String, String>());
        String key = null;
        booleaninsidePropertiesObj=false;
 
        key = parseJSON(reader, emp, phoneNums, key, insidePropertiesObj);
 
        long[] nums = newlong[phoneNums.size()];
        intindex = 0;
        for(Long l :phoneNums){
            nums[index++] = l;
        }
        emp.setPhoneNumbers(nums);
 
        reader.close();
        //print employee object
        System.out.println("Employee Objectnn"+emp);
    }
 
    privatestatic String parseJSON(JsonReader reader, Employee emp,
            List<Long> phoneNums, String key, booleaninsidePropertiesObj) throwsIOException {
 
        //loop to read all tokens
                while(reader.hasNext()){
                    //get next token
                    JsonToken token = reader.peek();
 
                    switch(token){
                    caseBEGIN_OBJECT:
                        reader.beginObject();
                        if("address".equals(key) || "properties".equals(key)){
                            while(reader.hasNext()){
                            parseJSON(reader, emp,phoneNums, key, insidePropertiesObj);
                            }
                            reader.endObject();
                        }
                        break;
                    caseEND_OBJECT:
                        reader.endObject();
                        if(insidePropertiesObj) insidePropertiesObj=false;
                        break;
                    caseBEGIN_ARRAY:
                        reader.beginArray();
                        if("phoneNumbers".equals(key) || "cities".equals(key)){
                            while(reader.hasNext()){
                                parseJSON(reader, emp,phoneNums, key, insidePropertiesObj);
                                }
                            reader.endArray();
                        }
                        break;
                    caseEND_ARRAY:
                        reader.endArray();
                        break;
                    caseNAME:
                        key = reader.nextName();
                        if("properties".equals(key)) insidePropertiesObj=true;
                        break;
                    caseBOOLEAN:
                        if("permanent".equals(key)) emp.setPermanent(reader.nextBoolean());
                        else{
                            System.out.println("Unknown item found with key="+key);
                            //skip value to ignore it
                            reader.skipValue();
                        }
                        break;
                    caseNUMBER:
                        if("empID".equals(key)) emp.setId(reader.nextInt());
                        elseif("phoneNumbers".equals(key)) phoneNums.add(reader.nextLong());
                        elseif("zipcode".equals(key)) emp.getAddress().setZipcode(reader.nextInt());
                        else{
                            System.out.println("Unknown item found with key="+key);
                            //skip value to ignore it
                            reader.skipValue();
                        }
                        break;
                    caseSTRING:
                        setStringValues(emp, key, reader.nextString(), insidePropertiesObj);
                        break;
                    caseNULL:
                        System.out.println("Null value for key"+key);
                        reader.nextNull();
                        break;
                    caseEND_DOCUMENT:
                        System.out.println("End of Document Reached");
                        break;
                    default:
                        System.out.println("This part will never execute");
                        break;
 
                    }
                }
                returnkey;
    }
 
    privatestatic void setStringValues(Employee emp, String key,
            String value, booleaninsidePropertiesObj) {
        if("name".equals(key)) emp.setName(value);
        elseif("role".equals(key)) emp.setRole(value);
        elseif("cities".equals(key)) emp.getCities().add(value);
        elseif ("street".equals(key)) emp.getAddress().setStreet(value);
        elseif("city".equals(key)) emp.getAddress().setCity(value);
        else{
            //add to emp properties map
            if(insidePropertiesObj){
                emp.getProperties().put(key, value);
            }else{
                System.out.println("Unknown data found with key="+key+" value="+value);
            }
 
        }
    }
 
}

由于JSON是一个递归语言（译注：JSON本身并不是“语言”，而是一种表示方法），我们也需要针对数组和嵌套对象递归地调用解析方法。JsonToken是JsonReader中next()方法所返回的Java枚举类型，我们可以用其配合条件逻辑或switch case语句进行转换工作。根据以上代码，你应该能够理解这不是一个简单的实现，如果JSON确实非常复杂，那么代码将会变得极难维护，所以要避免使用这种方式，除非没有其他出路。

我们来看一下如何使用Gson Streaming API写出Employee对象。

EmployeeGsonWriter.java

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
packagecom.journaldev.json.gson;
 
importjava.io.IOException;
importjava.io.OutputStreamWriter;
importjava.util.Set;
 
importcom.google.gson.stream.JsonWriter;
importcom.journaldev.json.model.Employee;
 
publicclass EmployeeGsonWriter {
 
    publicstatic void main(String[] args) throwsIOException {
        Employee emp = EmployeeGsonExample.createEmployee();
 
        //writing on console, we can initialize with FileOutputStream to write to file
        OutputStreamWriter out = newOutputStreamWriter(System.out);
        JsonWriter writer = newJsonWriter(out);
        //set indentation for pretty print
        writer.setIndent("t");
        //start writing
        writer.beginObject();//{
        writer.name("id").value(emp.getId());// "id": 123
        writer.name("name").value(emp.getName());// "name": "David"
        writer.name("permanent").value(emp.isPermanent());// "permanent": false
        writer.name("address").beginObject();// "address": {
            writer.name("street").value(emp.getAddress().getStreet());// "street": "BTM 1st Stage"
            writer.name("city").value(emp.getAddress().getCity());// "city": "Bangalore"
            writer.name("zipcode").value(emp.getAddress().getZipcode());// "zipcode": 560100
            writer.endObject();// }
        writer.name("phoneNumbers").beginArray();// "phoneNumbers": [
            for(longnum : emp.getPhoneNumbers()) writer.value(num); //123456,987654
            writer.endArray();// ]
        writer.name("role").value(emp.getRole());// "role": "Manager"
        writer.name("cities").beginArray();// "cities": [
            for(String c : emp.getCities()) writer.value(c); //"Los Angeles","New York"
            writer.endArray();// ]
        writer.name("properties").beginObject();//"properties": {
            Set<String> keySet = emp.getProperties().keySet();
            for(String key : keySet) writer.name("key").value(emp.getProperties().get(key));//"age": "28 years","salary": "1000 Rs"
            writer.endObject();// }
        writer.endObject();// }
 
        writer.flush();
 
        //close writer
        writer.close();
 
    }
 
}

从Java对象到JSON的转换，与使用streaming API解析相比，相对容易一些，默认情况下JsonWriter会以一种紧凑的格式写入JSON，但也可以设置缩进进行整齐打印。

这就是Gson API演示教程的所有内容，如果你遇到任何问题，请告诉我。以下链接可以下载项目，你可以玩一玩Gson提供的多种选项。

http://www.journaldev.com/?wpdmact=process&did=MzAuaG90bGluaw==

原文链接： Pankaj Kumar 翻译： ImportNew.com - Justin Wu
译文链接： http://www.importnew.com/14509.html
[ 转载请保留原文出处、译者和译文链接。]

0 0

【转载】对Json进行处理的Google Gson API教程

对Json进行处理的Google Gson API教程

关于作者： Justin Wu