使用Gson解析Json

1.Json介绍

JSON的全称是"JavaScript Object Notation",即JavaScript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式。XML也是一种数据交换格式。两者的区别：因为XML虽然可以作为跨平台的数据交换格式，但是在JS中处理XML非常不方便，同时XML标记比数据多，增加了交换产生的流量，而JSON没有附加的任何标记，在JS中可作为对象处理，所以我们倾向于选择JSON来交换数据。

2.Json的两种结构

JSON有两种表示结构，对象和数组。

对象结构：以{}为闭合，中间部分由","来分割的"key/value"对构成，关键字和值之间以"："分隔。其中关键字是字符串，而值可以使字符串，数值，true,false,null,对象或数组。语法结构如下：
　　{key1:value1,key2:value2,key3:value3,key4:value4......}
　　举例：{"UserID":11, "Name":"Truly", "Email":"zhuleipro@hotmail.com"};
　数组结构：以[]闭合，中间由","来分割的值列表组成，语法结构如下：
　　[
　　{
　　key1:value1,
　　key2:value2
　　},
　　{
　　key3:value3,
　　key4:value4
　　}]

3.区分JSON字符串和JSON对象

JSON字符串：使用""(双引号)或''(单引号)包括的符合JSON格式的字符串。例如：
var str = "{StudentID:'101',Name:‘mike',Age:15}";
JSON对象：指符合JSON格式的js对象，例如：

var jsonObj = {StudentID:'101',Name:‘mike',Age:15};

下面我们就Java使用Gson解析json数据举例说明，首先我们要导入Gson.jar包。网上可以下载，我这里用的是Gson-2.3.jar。

4.实例

实现：

使用Gson的API实现Json和javaBean的相互转换

使用Gson的API实现Map和Json字符串相互转换
List<Object>或List<JavaBean>与Json字符串相互转换

目录结构：

这里，我们主要对json字符串和各种对象之间转换进行了举例，实现方法在JsonUtil.java中，同时，针对config.properties配置文件中没有的字段信息，我们会进行更新。

代码清单【1】People.java

 1 package com.lxf.json;
 2 /**
 3  * javaBean
 4  * @author Administrator
 5  * 
 6  * 20170107
 7  */
 8 public class People
 9 {
10     //编号
11     private String id;
12     //姓名
13     private String name;
14     //邮箱地址
15     private String email;
16     //是否是vip  true:是  false:不是
17     private boolean vip;
18     
19     public People()
20     {
21         
22     }
23     public People(String id, String name, String email, boolean vip) {
24         super();
25         this.id = id;
26         this.name = name;
27         this.email = email;
28         this.vip = vip;
29     }
30     
31     public String getId()
32     {
33         return id;
34     }
35     public void setId(String id)
36     {
37         this.id = id;
38     }
39     public String getName() 
40     {
41         return name;
42     }
43     public void setName(String name) 
44     {
45         this.name = name;
46     }
47     public String getEmail() 
48     {
49         return email;
50     }
51     public void setEmail(String email) 
52     {
53         this.email = email;
54     }
55     public boolean isVip() 
56     {
57         return vip;
58     }
59     public void setVip(boolean vip)
60     {
61         this.vip = vip;
62     }
63     
64     @Override
65     public String toString() {
66         StringBuilder builder = new StringBuilder();
67         builder.append("People [id=");
68         builder.append(id);
69         builder.append(", name=");
70         builder.append(name);
71         builder.append(", email=");
72         builder.append(email);
73         builder.append(", vip=");
74         builder.append(vip);
75         builder.append("]");
76         return builder.toString();
77     }    
78 
79 }

代码清单【2】JsonUtil.java

  1 package com.lxf.json;
  2 
  3 import java.io.FileInputStream;
  4 import java.io.FileOutputStream;
  5 import java.io.OutputStream;
  6 import java.lang.reflect.Type;
  7 import java.util.ArrayList;
  8 import java.util.HashMap;
  9 import java.util.Iterator;
 10 import java.util.LinkedHashMap;
 11 import java.util.List;
 12 import java.util.Map;
 13 import java.util.Properties;
 14 import java.util.Set;
 15 
 16 import com.google.gson.Gson;
 17 import com.google.gson.JsonElement;
 18 import com.google.gson.JsonObject;
 19 import com.google.gson.JsonPrimitive;
 20 import com.google.gson.internal.LinkedHashTreeMap;
 21 import com.google.gson.internal.LinkedTreeMap;
 22 import com.google.gson.reflect.TypeToken;
 23 
 24 /**
 25  * Json工具类
 26  * @author Administrator
 27  *
 28  */
 29 public class JsonUtil 
 30 {
 31     private static String propertiesPath = "src/config.properties";
 32     
 33     private static Properties prop = new Properties(); 
 34     
 35     static 
 36     {
 37         try 
 38         {
 39             prop.load(new FileInputStream(propertiesPath));
 40         }
 41         catch (Exception e) 
 42         {
 43             e.printStackTrace();
 44         }
 45     }
 46     
 47     /**
 48      * 0.0读取配置文件的相应键的值
 49      * @param str  主键
 50      * @return
 51      */
 52     public static String readConfig(String str)
 53     {
 54     
 55         if(prop.containsKey(str))
 56         {
 57             return prop.getProperty(str);
 58         }
 59         else
 60         {
 61             throw new RuntimeException("the properties file don't contains "+ str + " key");
 62         }
 63         
 64     }
 65     
 66     /**
 67      * 0.1 更新（或插入）一对properties信息(主键及其键值)  
 68      * 如果该主键已经存在，更新该主键的值；  
 69      * 如果该主键不存在，则插件一对键值。 
 70      * @param str  键名
 71      * @param value  键值
 72      */
 73     public static void updateConfig(String str,String value) 
 74     {
 75         try
 76         {
 77             OutputStream fos = new FileOutputStream(propertiesPath);
 78             //如果该主键已经存在，更新该主键的值；  
 79             prop.setProperty(str, value);
 80             if(prop.containsKey(str))
 81             {
 82                 prop.store(fos, "Update ：" + str + "=" + value);
 83             }
 84             else
 85             {
 86                 prop.store(fos, "Insert : " + str + "=" + value);
 87             }
 88         } 
 89         catch (Exception e) 
 90         {
 91             System.out.println();
 92         }
 93         
 94     }
 95     /*
 96      * 1.1 json字符串--->JavaBean
 97      */
 98     public static void jsonToJavaBean()
 99     {
100         
101         String jsonStr = readConfig("huawei");
102         Gson gson = new Gson();
103         People people = gson.fromJson(jsonStr, People.class);
104         System.out.println(people.toString());
105     }
106     
107     /*
108      * 1.2 JavaBean--->json字符串
109      */
110     public static void javaBeanToJson() 
111     {
112         //创建javaBean
113         People p = new People();
114         p.setId("99");
115         p.setName("apple");
116         p.setEmail("110@163.com");
117         p.setVip(false);
118         //把javaBean转换为json字符串
119         Gson gson = new Gson();
120         String json = gson.toJson(p);
121         System.out.println(json);
122         
123         //查看配置文件中是否有该配置项，如果没有，添加到配置文件中，如果有，更新value值
124         String configKey = p.getName();
125         updateConfig(configKey,json);
126     }
127     
128     /*
129      * 1.3 json字符串---->Json对象 
130      */
131     public static void jsonToJsonObj()
132     {
133         String jsonStr = readConfig("huawei");
134         Gson gson = new Gson();
135         //json字符串转换为JsonObject
136         JsonObject jsonObject = (JsonObject) gson.fromJson(jsonStr, JsonElement.class);
137         System.out.println(jsonObject);
138         System.out.println(jsonObject.toString().equals(jsonStr));
139         //得到JsonObject的某个字段的值
140         JsonPrimitive namePrimitive = (JsonPrimitive) jsonObject.get("name");
141         //JsonPrimitive namePrimitive =  jsonObject.getAsJsonPrimitive("name");
142         System.out.println(namePrimitive);
143         String name = namePrimitive.getAsString();
144         System.out.println(name);
145     }
146     /**
147      * 总结:
148      *     --在json字符串转成JavaBean时，fromJson传入的第二个参数是Entity.class;
149      *     --在json字符串转成JsonObject时，fromJson传入的第二个参数是JsonElement.class,不能传入JsonObject.class,
150      *  否则返回的JsonObject是空的对象。
151      *  --如果想得到某个JsonObject对象的某个属性值，可以使用.get(String str).getAsString().
152      * 
153      */
154 
155 
156     /**
157      * 2.1Map--->json转换
158      */
159     public static void mapToJson()
160     {
161         Gson gson = new Gson();
162         Map<String, Object> map = new HashMap<String, Object>();
163         map.put("id", 1);
164         map.put("name", "xiaomi");
165         map.put("vip", true);
166         String json = gson.toJson(map);
167         System.out.println(json);
168         
169         //查看配置文件中是否有该配置项，如果没有，添加到配置文件中，如果有，更新value值
170         String configKey = (String) map.get("name");
171         updateConfig(configKey,json);
172     }
173     
174     /**
175      * 2.2 json---->Map转换
176      */
177     
178     public static void jsonToMap()
179     {
180         Gson gson = new Gson();
181         String json = prop.getProperty("xiaomi");
182         Map<String, Object> map = gson.fromJson(json, Map.class);
183         //这里原来map中id键对应的值类型是int，但是转成json字符串再转回来后，int类型变为Double类型了，这值得重视。
184         //如果需要int型，还需要利用double.intValue()方法转为int型。
185         System.out.println(map);
186         System.out.println(map.get("name"));
187         System.out.println(map.get("name").getClass());
188         System.out.println(map.get("name").getClass().getName());
189     }
190     
191     
192     /*
193      * 3.List与Json相互转换
194      */
195     /**
196      * 3.1 List<Object>与json字符串互换
197      */
198     public static void listObjectToJson()
199     {
200         List<Object> list = new ArrayList<Object>();
201         for(int i = 0; i < 2; i++ )
202         {
203             list.add(i);
204             list.add("element" + i);
205         }
206         System.out.println(list);
207         Gson gson = new Gson();
208         String json = gson.toJson(list);
209         System.out.println(json);
210         
211         list = gson.fromJson(json, List.class);
212         System.out.println(list);
213         for(int i = 0 ; i < list.size(); i++)
214         {
215             Object o = list.get(i);
216             System.out.println(o);
217             System.out.println(o.getClass().getName());
218         }
219     }
220     
221     /**
222      * List<Bean> 转化为json字符串
223      * 
224      * 1.不管是转换List<Object>,还是List<JavaBean>,当把字符串反序列化为list时，gson.fromJson(String json, Class<T> classOfT)
225      * 的第2个参数必须传入List.class.
226      * 2.转换List<JavaBean>，有2中方法：
227      * (1).gson.fromJson(String json, Class<T> classOfT)的第二个参数传入List.class.此时返回的额list中的元素不是JavaBean，而是Map
228      * 如果想得到一个个javaBean，还需要从map总去除键值对，然后利用构造器封装成javaBean.
229      * (2).gson.fromJson(String json, Class<T> classOfT)的第二个参数传入Type对象（Type type = new TypeToken<List<People>>(){}.getType();），
230      * 此时返回的list对象的元素就是一个个的javaBean对象。
231      */
232     public static void listBeanTojson()
233     {
234         List<People> personList = new ArrayList<People>();
235         People p1 = new People("1001", "三星", "1001@163.com", false);
236         People p2 = new People("1002", "诺基亚", "1002@163.com", false);
237         People p3 = new People("1003", "中兴", "1003@163.com", true);
238         personList.add(p1);
239         personList.add(p2);
240         personList.add(p3);
241         
242         //利用List.class与json字符串转换
243         Gson gson = new Gson();
244         String json = gson.toJson(personList) ;
245         System.out.println(json);
246         
247         //写入到配置文件中
248         String configKey = "info";
249         updateConfig(configKey,json);
250     }
251     
252     /**
253      * 使用List.class将json转换为List<JavaBean>
254      */
255     public static void jsonToListJavaBean()
256     {
257         System.out.println("*********");
258         Gson gson = new Gson();
259         String json = prop.getProperty("info");
260         List<LinkedTreeMap<String, Object>> list = gson.fromJson(json,List.class);
261         System.out.println(list);
262         for(LinkedTreeMap<String, Object> map : list)
263         {
264             System.out.println(map.getClass().getName());
265             System.out.println(map.toString());
266             Set<Map.Entry<String, Object>> set = map.entrySet();
267             for(Iterator<Map.Entry<String, Object>> it = set.iterator();it.hasNext();)
268             {
269                 Map.Entry<String, Object> entry = it.next();
270                 System.out.println(entry.getKey() + "--->" + entry.getValue());
271             }
272         }
273         
274     }
275     
276     /**
277      * 使用Type将json字符串转化为List<JavaBean>
278      */
279     public static void jsonToListJavaByType()
280     {    
281         Gson gson = new Gson();
282         String json = prop.getProperty("info");
283         List<People> personList = new ArrayList<People>();
284         People p1 = new People("1001", "三星", "1001@163.com", false);
285         People p2 = new People("1002", "诺基亚", "1002@163.com", false);
286         People p3 = new People("1003", "中兴", "1003@163.com", true);
287         personList.add(p1);
288         personList.add(p2);
289         personList.add(p3);
290         
291         //利用TypeToken,List<JavaBean>与Json互换
292         Type type = new TypeToken<List<People>>(){}.getType();
293         System.out.println("type :" + type);
294         String json2 = gson.toJson(personList, type);
295                 
296         System.out.println(json2.equals(json));
297         List<People> userList = gson.fromJson(json2, type);
298         
299         System.out.println(userList);
300         for(int i = 0; i < userList.size(); i++)
301         {
302             System.out.println(userList.get(i).getEmail());
303         }
304     }
305     
306 
307 }

代码清单【3】JsonMain.java

 1 package com.lxf.json;
 2 
 3 import org.junit.Test;
 4 
 5 import com.google.gson.Gson;
 6 
 7 public class JsonMain 
 8 {
 9     /**
10      * 1.1 json字符串--->JavaBean测试
11      */
12     @Test
13     public void testJsonToJavaBean()
14     {
15         JsonUtil.jsonToJavaBean(); 
16     }
17     
18     /**
19      * 1.2 JavaBean--->json字符串测试
20      */
21     @Test
22     public void testJavaBeanToJson() 
23     {
24         JsonUtil.javaBeanToJson();
25         
26     }
27     /**
28      * 1.3 json字符串---->JsonObject
29      */
30     @Test
31     public void testJsonToJsonObject()
32     {
33         JsonUtil.jsonToJsonObj();
34     }
35     
36     /**
37      * 2.1Map--->Json测试
38      */
39     @Test
40     public void testMapToJson()
41     {
42         JsonUtil.mapToJson();
43     }
44     
45     /**
46      *  json---->Map转换
47      */
48     @Test
49     public void testJsonToMap()
50     {
51         JsonUtil.jsonToMap();
52     }
53     
54     /**
55      * list<Object> <----> json测试
56      */
57     @Test
58     public void testListObjectToJson()
59     {
60         JsonUtil.listObjectToJson();
61     }
62     
63     /**
64      * List<Bean> 转化为json字符串 测试
65      */
66     @Test
67     public void testlistBeanTojson()
68     {
69         JsonUtil.listBeanTojson();
70     }
71 
72     /**
73      * 使用List.class将json转换为List<JavaBean> 测试
74      */
75     @Test
76     public void testJsonToListJavaBean()
77     {
78         JsonUtil.jsonToListJavaBean();
79     }
80     /**
81      * 使用Type将json字符串转化为List<JavaBean>
82      */
83     @Test
84     public void testJsonToListJavaByType()
85     {
86         JsonUtil.jsonToListJavaByType();
87     }
88 }

运行结果：

config.properties文件：

1 #Update \uFF1Ainfo=[{"id":"1001","name":"\u4E09\u661F","email":"1001@163.com","vip":false},{"id":"1002","name":"\u8BFA\u57FA\u4E9A","email":"1002@163.com","vip":false},{"id":"1003","name":"\u4E2D\u5174","email":"1003@163.com","vip":true}]
2 #Mon Jan 09 23:54:36 CST 2017
3 apple={"id"\:"99","name"\:"apple","email"\:"110@163.com","vip"\:false}
4 huawei={"id"\:101,"name"\:"huawei","email"\:"2582376681@qq.com","vip"\:true}
5 info=[{"id"\:"1001","name"\:"\u4E09\u661F","email"\:"1001@163.com","vip"\:false},{"id"\:"1002","name"\:"\u8BFA\u57FA\u4E9A","email"\:"1002@163.com","vip"\:false},{"id"\:"1003","name"\:"\u4E2D\u5174","email"\:"1003@163.com","vip"\:true}]
6 xiaomi={"id"\:1,"vip"\:true,"name"\:"xiaomi"}

5.拓展补充

posted on 2017-01-09 23:56 小李探花IU 阅读(514) 评论(0) 编辑收藏举报

刷新页面返回顶部

小李探花IU

导航