Jason总结

一、Json理论知识

Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率. 
从结构上看，所有的数据（data）最终都可以分解成三种类型： 
第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"北京"这个单独的词。 
第二种类型是序列（sequence），也就是若干个相关的数据按照一定顺序并列在一起，又叫做数组（array）或列表（List），比如"北京，上海"。 
第三种类型是映射（mapping），也就是一个名/值对（Name/value），即数据有一个名称，还有一个与之相对应的值，这又称作散列（hash）或字典（dictionary），比如"首都：北京"。
Json的规格非常简单，只用一个页面几百个字就能说清楚，而且Douglas Crockford声称这个规格永远不必升级，因为该规定的都规定了。 
1） 并列的数据之间用逗号（"，"）分隔。 
2） 映射用冒号（"："）表示。 
3） 并列数据的集合（数组）用方括号("[]")表示。 
4） 映射的集合（对象）用大括号（"{}"）表示。 

我们以http://apistore.baidu.com/astore/serviceinfo/2003.html为例，官方给出的json数据如下例：

二、Json实例

[html]  view plain copy

1. JSON返回示例：  
2. {  
3.     "errNum": 0,  
4.     "errMsg": "success",  
5.     "retData": {  
6.         "from": "en",  
7.         "to": "zh",  
8.         "dict_result": {  
9.             "word_name": "hello",  
10.             "symbols": [  
11.                 {  
12.                     "ph_am": "hɛˈlo, hə-",  
13.                     "ph_en": "hə'ləʊ",  
14.                     "parts": [  
15.                         {  
16.                             "part": "int.",  
17.                             "means": [  
18.                                 "哈喽，喂",  
19.                                 "你好，您好",  
20.                                 "表示问候",  
21.                                 "打招呼"  
22.                             ]  
23.                         },  
24.                         {  
25.                             "part": "n.",  
26.                             "means": [  
27.                                 "“喂”的招呼声或问候声"  
28.                             ]  
29.                         },  
30.                         {  
31.                             "part": "vi.",  
32.                             "means": [  
33.                                 "喊“喂”"  
34.                             ]  
35.                         }  
36.                     ]  
37.                 }  
38.             ]  
39.         }  
40.     }  
41. }  

看起来比较蛋疼吧，这玩意估计你用原始的JSONObject和JSONArray解析会让你蛋碎而且不利于以后维护，所以没办法，研究一下更科学的办法吧。

 

首先我们要定义bean:

分析一下有多少层：

最后一层是个字符串数组，就不要写bean了，所以应该有五个。这里要注意哪个是对象，哪个是数组，不然肯定会报错：

类似这种啊，提示IllegalStateException,话说怎么区分哪个是对象，哪个是数组呢？就这么理解打箭头的这些元素后面直接跟“[”(中括号)的就是数组，当然不直接跟中括号的就是对象，再定义bean的时候就有不同了，具体看下面的代码：

第一个bean:

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.List;  
4.   
5. public class Status1 {  
6.     private int errNum;  
7.     private String errMsg;  
8.     RetData2 retData;//保证变量名与返回JSON的标签名一致，注意！！！！！！！！  
9.     @Override  
10.     public String toString() {  
11.         return "Status [errNum=" + errNum + ", errMsg=" + errMsg + ", retData="  
12.                 + retData + "]";  
13.     }  
14.     public int getErrNum() {  
15.         return errNum;  
16.     }  
17.     public void setErrNum(int errNum) {  
18.         this.errNum = errNum;  
19.     }  
20.     public String getErrMsg() {  
21.         return errMsg;  
22.     }  
23.     public void setErrMsg(String errMsg) {  
24.         this.errMsg = errMsg;  
25.     }  
26.     public RetData2 getRetData() {  
27.         return retData;  
28.     }  
29.     public void setRetData(RetData2 retData) {  
30.         this.retData = retData;  
31.     }  
32.       
33.   
34.       
35.       
36.   
37.   
38. }  

第二个bean:

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.List;  
4.   
5. public class RetData2 {  
6.     private String from;  
7.     private String to;  
8.     DictResult3 dict_result;  
9.     public String getFrom() {  
10.         return from;  
11.     }  
12.     public void setFrom(String from) {  
13.         this.from = from;  
14.     }  
15.     public String getTo() {  
16.         return to;  
17.     }  
18.     public void setTo(String to) {  
19.         this.to = to;  
20.     }  
21.     public DictResult3 getDictResult() {  
22.         return dict_result;  
23.     }  
24.     public void setDictResult(DictResult3 dictResult) {  
25.         this.dict_result = dictResult;  
26.     }  
27.     @Override  
28.     public String toString() {  
29.         return "RetData [from=" + from + ", to=" + to + ", dictResult="  
30.                 + dict_result + "]";  
31.     }  
32.       
33.   
34.       
35. }  

第3个bean：

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.List;  
4.   
5. public class DictResult3 {  
6.     private String word_name;  
7.   
8.     private List<Symbols> symbols;  
9.   
10.     public String getWord_name() {  
11.         return word_name;  
12.     }  
13.   
14.     public void setWord_name(String word_name) {  
15.         this.word_name = word_name;  
16.     }  
17.   
18.     public List<Symbols> getSymbols() {  
19.         return symbols;  
20.     }  
21.   
22.     public void setSymbols(List<Symbols> symbols) {  
23.         this.symbols = symbols;  
24.     }  
25.   
26.     @Override  
27.     public String toString() {  
28.         return "DictResult [word_name=" + word_name + ", symbols=" + symbols  
29.                 + "]";  
30.     }  
31.   
32. }  

第4个bean:

 

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.List;  
4.   
5. public class Symbols {  
6.     private String ph_am;  
7.     private String ph_en;  
8.     private List<Parts> parts;  
9.       
10.     public String getPh_am() {  
11.         return ph_am;  
12.     }  
13.     public void setPh_am(String ph_am) {  
14.         this.ph_am = ph_am;  
15.     }  
16.     public String getPh_en() {  
17.         return ph_en;  
18.     }  
19.     public void setPh_en(String ph_en) {  
20.         this.ph_en = ph_en;  
21.     }  
22.     public List<Parts> getParts() {  
23.         return parts;  
24.     }  
25.     public void setParts(List<Parts> parts) {  
26.         this.parts = parts;  
27.     }  
28.     @Override  
29.     public String toString() {  
30.         return "Symbols [ph_am=" + ph_am + ", ph_en=" + ph_en + ", parts="  
31.                 + parts + "]";  
32.     }  
33.       
34.   
35. }  

第5个：

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.Arrays;  
4. import java.util.List;  
5.   
6. public class Parts {  
7.     private String part;  
8.     public String getParts() {  
9.         return part;  
10.     }  
11.     public void setParts(String parts) {  
12.         this.part = parts;  
13.     }  
14.     public String[] getMeans() {  
15.         return means;  
16.     }  
17.     public void setMeans(String[] means) {  
18.         this.means = means;  
19.     }  
20.     @Override  
21.     public String toString() {  
22.         return "Parts [parts=" + part + ", means=" + Arrays.toString(means)  
23.                 + "]";  
24.     }  
25.     String[] means;  
26.       
27.       
28.       
29.   
30. }  

 

以上写bean的时候又快捷方式，你不会不知道吧，你要是一个一个打，会把你累傻，什么快捷方式呢？比如第一个bean:

我们只要写：

[java]  view plain copy

1. private int errNum;  

[java]  view plain copy

1. private String errMsg;  

[java]  view plain copy

1. RetData2 retData;  

这三行，然后选中他们点右键，选择Source 然后你就看到.....getter和setter方法,和什么什么tostring()了吧，这些都是可以帮你自动生成的。

上面写bean时最最重要的地方就是，定义的变量名，对象名和数组名一定要和json数据里的标签一模一样，不然一会解析数据的时候会因为找不到标签而返回null，那不就白忙活了。

接下面就是MainActivity了。

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import java.util.List;  
4.   
5. import android.app.Activity;  
6. import android.os.Bundle;  
7. import android.util.Log;  
8. import android.view.View;  
9. import android.view.View.OnClickListener;  
10. import android.widget.Button;  
11.   
12. import com.android.volley.RequestQueue;  
13. import com.android.volley.Response;  
14. import com.android.volley.VolleyError;  
15. import com.android.volley.toolbox.StringRequest;  
16. import com.android.volley.toolbox.Volley;  
17. import com.google.gson.Gson;  
18.   
19. public class MainActivity extends Activity {  
20.     private Button tojson;  
21.     RequestQueue mQueue;  
22.     StringRequest stringRequest;  
23.     Gson gson;  
24.     String str;  
25.   
26.     @Override  
27.     protected void onCreate(Bundle savedInstanceState) {  
28.         super.onCreate(savedInstanceState);  
29.         setContentView(R.layout.main);  
30.   
31.         tojson = (Button) findViewById(R.id.toJson);  
32.         gson = new Gson();  
33.   
34.         mQueue = Volley.newRequestQueue(MainActivity.this);  
35.         // http://10.19.20.12/upgrade/test.txt是测试使用的json数据  
36.         stringRequest = new StringRequest(  
37.                 "http://apistore.baidu.com/microservice/dictionary?query=hello&from=en&to=zh",  
38.                 new Response.Listener<String>() {  
39.                     public void onResponse(String response) {  
40.                         Log.d("TAG", response);  
41.                         System.out.println("response=" + response);  
42.                         Status1 status = gson.fromJson(response, Status1.class);  
43.   
44.                         System.out.println("错误码：" + status.getErrNum());  
45.                         System.out.println("错误信息" + status.getErrMsg());  
46.                         System.out.println("status=" + status);  
47.                         System.out  
48.                                 .println("-------------------------------------");  
49.   
50.                         RetData2 retData2 = status.getRetData();  
51.   
52.                         System.out.println("from=" + retData2.getFrom());  
53.                         DictResult3 dictResult3;  
54.                         dictResult3 = retData2.getDictResult();  
55.                         System.out.println("word_name="  
56.                                 + dictResult3.getWord_name());  
57.   
58.                     }  
59.                 }, new Response.ErrorListener() {  
60.                     public void onErrorResponse(VolleyError error) {  
61.                         Log.e("TAG", error.getMessage(), error);  
62.                     }  
63.   
64.                 });  
65.   
66.         tojson.setOnClickListener(new OnClickListener() {  
67.             public void onClick(View v) {  
68.                 mQueue.add(stringRequest);  
69.             }  
70.         });  
71.     }  
72.   
73. }  

 

运行一下实例：看log窗口：

注释：只是象征性的取了几个数啊，没有全部取出来，只是讲一下方法，你要那些数据，自己按照这个方法解析就好了。好了上面你还看到用到了Volley类，那么什么是Volley?

这里也顺便介绍一下吧：（下面介绍的文字是参考的）

三、Volley理论知识

我们平时在开发Android应用的时候不可避免地都需要用到网络技术，而多数情况下应用程序都会使用HTTP协议来发送和接收网络数据。Android系统中主要提供了两种方式来进行HTTP通信，HttpURLConnection和HttpClient，几乎在任何项目的代码中我们都能看到这两个类的身影，使用率非常高。

不过HttpURLConnection和HttpClient的用法还是稍微有些复杂的，如果不进行适当封装的话，很容易就会写出不少重复代码。于是乎，一些Android网络通信框架也就应运而生，比如说AsyncHttpClient，它把HTTP所有的通信细节全部封装在了内部，我们只需要简单调用几行代码就可以完成通信操作了。再比如Universal-Image-Loader，它使得在界面上显示网络图片的操作变得极度简单，开发者不用关心如何从网络上获取图片，也不用关心开启线程、回收图片资源等细节，Universal-Image-Loader已经把一切都做好了。

Android开发团队也是意识到了有必要将HTTP的通信操作再进行简单化，于是在2013年Google I/O大会上推出了一个新的网络通信框架——Volley。Volley可是说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕。

四、怎么用Volley

首先要下载一个jar包：

看名字百度下载吧。然后把包导进去，怎么导进去？百度吧，应该不难。

直接看代码你就知道怎么用了：

[java]  view plain copy

1. package org.lxh.demo;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.util.Log;  
6.   
7. import com.android.volley.RequestQueue;  
8. import com.android.volley.Response;  
9. import com.android.volley.VolleyError;  
10. import com.android.volley.toolbox.StringRequest;  
11. import com.android.volley.toolbox.Volley;  
12.   
13. public class Hello extends Activity {  
14.        
15.     public void onCreate(Bundle savedInstanceState) {  
16.         super.onCreate(savedInstanceState); // 生命周期方法  
17.         super.setContentView(R.layout.main); // 设置要使用的布局管理器  
18.         RequestQueue mQueue = Volley.newRequestQueue(Hello.this); //获取一个RequestQueue对象  
19.         StringRequest stringRequest = new StringRequest("http://www.baidu.com",  //创建一个StringRequest对象  
20.                 new Response.Listener<String>() {    
21.                     public void onResponse(String response) {    
22.                         Log.d("TAG", response);    
23.                     }    
24.                 }, new Response.ErrorListener() {    
25.                     public void onErrorResponse(VolleyError error) {    
26.                         Log.e("TAG", error.getMessage(), error);    
27.                     }  
28.   
29.                       
30.                 });    
31.         mQueue.add(stringRequest); // 将这个StringRequest对象添加到RequestQueue里面  
32.   
33.     }  
34. }  

运行实例看Log窗口：

 

返回的就是一个百度的Html数据。上面代码你就懂得了怎么获取Json数据的吧。