android学习二十三（解析json格式数据）

前面我们已经掌握了xml格式数据的解析方式，那么接下来我们学习下如何解析json格式的数据。比起xml，json的主要优势在于它体积更小，在网络上传输的时候可以更省流量。但缺点在于，它的语义性差，看起来不如xml直观。

    开始之前，先在自己的电脑apache-tomcat-6.0.39\webapps\ROOT路径目录下新建一个get_data.json的文件，然后编辑这个文件，并加入如下json格式的内容：

[{"id":"5","version":"5.5","name":"angelababy"},
{"id":"6","version":"7.0","name":"clash of clans"},
{"id":"7","version":"3.5","name":"hey day"}]

这时候在浏览器访问的结果如下：




这样就把json格式的数据准备好了，下面我们在Android程序中解析这些数据吧。



使用JSONObject解析json格式的数据

        解析json格式的数据有很多种方式，可以使用官方提供的JSONObject，也可以用谷歌的开源库GSON。
 还有一些第三方的开源库，比如Jackson，FastSON等。目前只讲解JSONObject和GSON。
      修改MainActivity中的代码，如下所示:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. package com.jack.networktest;  
  2. import java.io.BufferedReader;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.InputStreamReader;  
  6. import java.io.StringReader;  
  7. import java.net.HttpURLConnection;  
  8. import java.net.MalformedURLException;  
  9. import java.net.URL;  
  10.   
  11. import javax.xml.parsers.SAXParserFactory;  
  12.   
  13. import org.apache.http.HttpEntity;  
  14. import org.apache.http.HttpHost;  
  15. import org.apache.http.HttpRequest;  
  16. import org.apache.http.HttpResponse;  
  17. import org.apache.http.client.ClientProtocolException;  
  18. import org.apache.http.client.HttpClient;  
  19. import org.apache.http.client.ResponseHandler;  
  20. import org.apache.http.client.methods.HttpGet;  
  21. import org.apache.http.client.methods.HttpUriRequest;  
  22. import org.apache.http.conn.ClientConnectionManager;  
  23. import org.apache.http.impl.client.DefaultHttpClient;  
  24. import org.apache.http.params.HttpParams;  
  25. import org.apache.http.protocol.HttpContext;  
  26. import org.apache.http.util.EntityUtils;  
  27. import org.json.JSONArray;  
  28. import org.json.JSONObject;  
  29. import org.xml.sax.InputSource;  
  30. import org.xml.sax.XMLReader;  
  31. import org.xmlpull.v1.XmlPullParser;  
  32. import org.xmlpull.v1.XmlPullParserFactory;  
  33.   
  34. import android.annotation.SuppressLint;  
  35. import android.app.Activity;  
  36. import android.os.Bundle;  
  37. import android.os.Handler;  
  38. import android.os.Message;  
  39. import android.util.Log;  
  40. import android.view.Menu;  
  41. import android.view.View;  
  42. import android.view.View.OnClickListener;  
  43. import android.widget.Button;  
  44. import android.widget.TextView;  
  45.   
  46. public class MainActivity extends Activity implements OnClickListener{  
  47.   
  48.     public static final int SHOW_RESPONSE=0;  
  49.     private Button sendRequest=null;  
  50.     private TextView responseText=null;  
  51.       
  52.     private Handler handler=new Handler(){  
  53.   
  54.         @Override  
  55.         public void handleMessage(Message msg) {  
  56.             // TODO Auto-generated method stub  
  57.             super.handleMessage(msg);  
  58.             switch(msg.what){  
  59.             case SHOW_RESPONSE:  
  60.                 String response=(String) msg.obj;  
  61.                 //在这里进行UI操作，将结果显示到界面上  
  62.                 responseText.setText(response);  
  63.                 break;  
  64.             default:  
  65.                 break;  
  66.             }  
  67.               
  68.         }  
  69.           
  70.     };  
  71.       
  72.       
  73.     @Override  
  74.     protected void onCreate(Bundle savedInstanceState) {  
  75.         super.onCreate(savedInstanceState);  
  76.         setContentView(R.layout.activity_main);  
  77.         sendRequest=(Button) findViewById(R.id.send_request);  
  78.         responseText=(TextView) findViewById(R.id.response_text);  
  79.         sendRequest.setOnClickListener(this);  
  80.           
  81.     }  
  82.   
  83.     @Override  
  84.     public boolean onCreateOptionsMenu(Menu menu) {  
  85.         // Inflate the menu; this adds items to the action bar if it is present.  
  86.         getMenuInflater().inflate(R.menu.main, menu);  
  87.         return true;  
  88.     }  
  89.   
  90.     @Override  
  91.     public void onClick(View v) {  
  92.         // TODO Auto-generated method stub  
  93.         if(v.getId()==R.id.send_request){  
  94.             //sendRequestWithHttpURLConnection();  
  95.             sendRequestWithHttpClient();  
  96.         }  
  97.           
  98.     }  
  99.       
  100.       
  101.     private void sendRequestWithHttpURLConnection(){  
  102.         //开启线程来发起网络请求  
  103.         new Thread(new Runnable(){  
  104.   
  105.             @Override  
  106.             public void run() {  
  107.                 // TODO Auto-generated method stub  
  108.                 HttpURLConnection connection=null;  
  109.                   
  110.                 try {  
  111.                     URL url=new URL("http://www.baidu.com");  
  112.                     connection =(HttpURLConnection) url.openConnection();  
  113.                     connection.setRequestMethod("GET");  
  114.                     connection.setConnectTimeout(8000);  
  115.                     connection.setReadTimeout(8000);  
  116.                     InputStream in=connection.getInputStream();  
  117.                     //下面对获取到的输入流进行读取  
  118.                     BufferedReader reader=new BufferedReader(new InputStreamReader(in));  
  119.                     StringBuilder response=new StringBuilder();  
  120.                     String line;  
  121.                     while((line=reader.readLine())!=null){  
  122.                         response.append(line);  
  123.                     }  
  124.                     Message message=new Message();  
  125.                     message.what=SHOW_RESPONSE;  
  126.                     //将服务器返回的结果存放到Message中  
  127.                     message.obj=response.toString();  
  128.                     handler.sendMessage(message);  
  129.                       
  130.                       
  131.                 } catch (MalformedURLException e) {  
  132.                     // TODO Auto-generated catch block  
  133.                     e.printStackTrace();  
  134.                 }catch(Exception e){  
  135.                     e.printStackTrace();  
  136.                 }finally{  
  137.                     if(connection!=null){  
  138.                         connection.disconnect();  
  139.                     }  
  140.                 }  
  141.             }  
  142.               
  143.         }).start();  
  144.           
  145.           
  146.     }  
  147.       
  148.       
  149.     private void sendRequestWithHttpClient(){  
  150.         new Thread(new Runnable(){  
  151.   
  152.             @Override  
  153.             public void run() {  
  154.                 // TODO Auto-generated method stub  
  155.                 try{  
  156.                     HttpClient httpClient=new DefaultHttpClient() ;  
  157.                     //HttpGet httpGet=new HttpGet("http://www.baidu.com");  
  158.                     //指定访问的服务器地址是电脑本机，10.0.2.2对模拟器来说就是电脑本机的ip地址  
  159.                     //8080为端口号  
  160.                     //HttpGet httpGet=new HttpGet("http://10.0.2.2:8080/get_data.xml");  
  161.                     HttpGet httpGet=new HttpGet("http://10.0.2.2:8080/get_data.json");  
  162.                     HttpResponse httpResponse=httpClient.execute(httpGet);  
  163.                     if(httpResponse.getStatusLine().getStatusCode()==200){  
  164.                         //请求和响应都成功了  
  165.                         HttpEntity entity=httpResponse.getEntity();  
  166.                         String response=EntityUtils.toString(entity,"utf-8");  
  167.                         //调用parseXMLWithPull方法解析服务器返回的数据  
  168.                         //parseXMLWithPull(response);  
  169.                           
  170.                         //调用parseXMLWithSAX方法解析服务器返回的数据  
  171.                         parseXMLWithSAX(response);  
  172.                           
  173.                         //调用parseJSONWithJSONObject方法解析服务器返回的数据  
  174.                         parseJSONWithJSONObject(response);  
  175.                           
  176.                           
  177.                           
  178.                         Message message=new Message();  
  179.                         message.what=SHOW_RESPONSE;  
  180.                         //将服务器返回的结果存放到Message中  
  181.                         message.obj=response.toString();  
  182.                         handler.sendMessage(message);  
  183.                     }  
  184.                 }catch(Exception e){  
  185.                     e.printStackTrace();  
  186.                 }  
  187.             }  
  188.               
  189.         }).start();  
  190.           
  191.     }  
  192.       
  193.     //使用Pull解析xml  
  194.     private void parseXMLWithPull(String xmlData){  
  195.         //Log.d("MainActivity", "parseXMLWithPull(String xmlData)");  
  196.         try{  
  197.             //获取到XmlPullParserFactory的实例，并借助这个实例得到XmlPullParser对象  
  198.             XmlPullParserFactory factory=XmlPullParserFactory.newInstance();  
  199.             XmlPullParser xmlPullParser=factory.newPullParser();  
  200.             //调用XmlPullParser的setInput方法将服务器返回的xml数据设置进去开始解析  
  201.             xmlPullParser.setInput(new StringReader(xmlData));  
  202.             //通过getEventType()方法得到当前解析事件  
  203.             int eventType=xmlPullParser.getEventType();  
  204.             String id="";  
  205.             String name="";  
  206.             String version="";  
  207.             while(eventType!=XmlPullParser.END_DOCUMENT){  
  208.                 //通过getName()方法得到当前节点的名字，如果发现节点名等于id、name、或version  
  209.                 //就调用nextText()方法来获取结点具体的内容，每当解析完一个app结点就将获取到的内容打印出来  
  210.                 String nodeName=xmlPullParser.getName();  
  211.                 //Log.d("MainActivity",""+eventType+ " nodeName= "+nodeName);  
  212.                 switch(eventType){  
  213.                 //开始解析某个节点  
  214.                 case XmlPullParser.START_TAG:{  
  215.                     if("id".equals(nodeName)){  
  216.                         id=xmlPullParser.nextText();  
  217.                     }else if("name".equals(nodeName)){  
  218.                         name=xmlPullParser.nextText();  
  219.                     }else if("version".equals(nodeName)){  
  220.                         version=xmlPullParser.nextText();  
  221.                     }  
  222.                     break;  
  223.                 }  
  224.                 case XmlPullParser.END_TAG:{  
  225.                     if("app".equals(nodeName)){  
  226.                         Log.d("MainActivity", "id is "+id);  
  227.                         Log.d("MainActivity", "name is "+name);  
  228.                         Log.d("MainActivity", "version is "+version);  
  229.                     }  
  230.                     break;  
  231.                 }  
  232.                 default:  
  233.                     break;  
  234.                 }  
  235.                 //调用next()方法获取到下一个解析事件  
  236.                 eventType=xmlPullParser.next();  
  237.             }  
  238.         }catch(Exception e){  
  239.             e.printStackTrace();  
  240.         }  
  241.     }  
  242.       
  243.       
  244.     //进行SAX解析的函数  
  245.     private void parseXMLWithSAX(String xmlData){  
  246.         /* 
  247.          * parseXMLWithSAX方法中先创建一个SAXParserFactory的对象，然后再获取到 
  248.          * XMLReader对象，接着将我们编写的ContentHandler的实例设置到XMLReader中， 
  249.          * 最后调用parse()方法开始执行解析。 
  250.          * */  
  251.         try{  
  252.             SAXParserFactory factory=SAXParserFactory.newInstance();  
  253.             XMLReader xmlReader=factory.newSAXParser().getXMLReader();  
  254.             ContentHandler handler=new ContentHandler();  
  255.             //将ContentHandler的实例设置到XMLReader中  
  256.             xmlReader.setContentHandler(handler);  
  257.             //开始执行解析  
  258.             xmlReader.parse(new InputSource(new StringReader(xmlData)));  
  259.               
  260.         }catch(Exception e){  
  261.             e.printStackTrace();  
  262.         }  
  263.     }  
  264.       
  265.       
  266.       
  267.     //使用JSONObject解析json格式的数据  
  268.     private void parseJSONWithJSONObject(String jsonData){  
  269.         /* 
  270.          * 首先把http请求的地址改成http://localhost:8080/get_data.json，然后在得到服务器返回 
  271.          * 的数据后调用parseJSONWithJSONObject()方法来解析数据。由于我们在服务器中定义的是一个json数组， 
  272.          * 因此解析的时候首先是将服务器返回的数据传入到一个JSONArray对象中。然后循环遍历这个JSONArray，从 
  273.          * 中取出的每一个元素都是一个JSONObject对象，每个JSONObject对象中又包含了id,name和version这些 
  274.          * 数据。接下来只需要调用getString()方法将这些数据取出，并打印出来即可。 
  275.          * */  
  276.         try{  
  277.             JSONArray jsonArray=new JSONArray(jsonData);  
  278.             for(int i=0;i<jsonArray.length();i++){  
  279.                 JSONObject jsonObject=jsonArray.getJSONObject(i);  
  280.                 String id=jsonObject.getString("id");  
  281.                 String name=jsonObject.getString("name");  
  282.                 String version=jsonObject.getString("version");  
  283.                 Log.d("MainActivity", "id is "+id);  
  284.                 Log.d("MainActivity", "name is "+name);  
  285.                 Log.d("MainActivity", "version is "+version);  
  286.             }  
  287.         }catch(Exception e){  
  288.             e.printStackTrace();  
  289.         }  
  290.     }  
  291.       
  292.       
  293.       
  294.       
  295.       
  296.       
  297.       
  298. }  


现在重新运行下程序，点击send request按钮，结果如下所示：






使用GSON

  谷歌提供的GSON开源库可以让解析JSON数据的工作简单到不敢想象的地步。要使用GSON必须要在项目中添加一个 GSON的jar包。首先需要将GSON的资源压缩包下载下来，下载地址是：htt://code.google.com/p/google-gson/downloads/list
   然后把下载下来的gson-x.x.x.jar包拷贝到NetworkTest项目的libs目录下，GSON库就自动添加到项目了。
   GSON的强大之处，在于可以将一段json格式的字符串自动映射成一个对象，从而不需要我们再动手去编写代码进行解析了。比如说一段json格式的数据如下所示：
   {"name":"tom","age":"20"}
   那么我们就可以定义一个Person类，并加入name和age这两个字段，然后只需简单地调用如下代码就可以将json数据自动解析成一个Person对象了：
   Gson gson=new Gson();
   Person person=gson.fromJson(jsonData,Person.class);
   如果需要解析的是一段json数组会稍微麻烦点，我们需要借助TypeToken将期望解析的数据类型传入到fromJson()方法，如下所示：
   List<Person> people=gson.fromJson(jsonData,new TypeToken<List<Person>>(){}.getType());
   好了，基本的用法就是这样了，下面我们来试试，首先新增一个App类，并加入id，name和version这三个字段，如下所示： 

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. package com.jack.networktest;  
  2.   
  3. public class App {  
  4.   
  5.     private String id;  
  6.     private String name;  
  7.     private String version;  
  8.     public String getId() {  
  9.         return id;  
  10.     }  
  11.     public void setId(String id) {  
  12.         this.id = id;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public String getVersion() {  
  21.         return version;  
  22.     }  
  23.     public void setVersion(String version) {  
  24.         this.version = version;  
  25.     }  
  26.       
  27.       
  28. }  


然后修改MainActivity中的代码，如下所示：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. package com.jack.networktest;  
  2. import java.io.BufferedReader;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.InputStreamReader;  
  6. import java.io.StringReader;  
  7. import java.net.HttpURLConnection;  
  8. import java.net.MalformedURLException;  
  9. import java.net.URL;  
  10. import java.util.List;  
  11.   
  12. import javax.xml.parsers.SAXParserFactory;  
  13.   
  14. import org.apache.http.HttpEntity;  
  15. import org.apache.http.HttpHost;  
  16. import org.apache.http.HttpRequest;  
  17. import org.apache.http.HttpResponse;  
  18. import org.apache.http.client.ClientProtocolException;  
  19. import org.apache.http.client.HttpClient;  
  20. import org.apache.http.client.ResponseHandler;  
  21. import org.apache.http.client.methods.HttpGet;  
  22. import org.apache.http.client.methods.HttpUriRequest;  
  23. import org.apache.http.conn.ClientConnectionManager;  
  24. import org.apache.http.impl.client.DefaultHttpClient;  
  25. import org.apache.http.params.HttpParams;  
  26. import org.apache.http.protocol.HttpContext;  
  27. import org.apache.http.util.EntityUtils;  
  28. import org.json.JSONArray;  
  29. import org.json.JSONObject;  
  30. import org.xml.sax.InputSource;  
  31. import org.xml.sax.XMLReader;  
  32. import org.xmlpull.v1.XmlPullParser;  
  33. import org.xmlpull.v1.XmlPullParserFactory;  
  34.   
  35. import com.google.gson.Gson;  
  36. import com.google.gson.reflect.TypeToken;  
  37.   
  38. import android.annotation.SuppressLint;  
  39. import android.app.Activity;  
  40. import android.os.Bundle;  
  41. import android.os.Handler;  
  42. import android.os.Message;  
  43. import android.util.Log;  
  44. import android.view.Menu;  
  45. import android.view.View;  
  46. import android.view.View.OnClickListener;  
  47. import android.widget.Button;  
  48. import android.widget.TextView;  
  49.   
  50. public class MainActivity extends Activity implements OnClickListener{  
  51.   
  52.     public static final int SHOW_RESPONSE=0;  
  53.     private Button sendRequest=null;  
  54.     private TextView responseText=null;  
  55.       
  56.     private Handler handler=new Handler(){  
  57.   
  58.         @Override  
  59.         public void handleMessage(Message msg) {  
  60.             // TODO Auto-generated method stub  
  61.             super.handleMessage(msg);  
  62.             switch(msg.what){  
  63.             case SHOW_RESPONSE:  
  64.                 String response=(String) msg.obj;  
  65.                 //在这里进行UI操作，将结果显示到界面上  
  66.                 responseText.setText(response);  
  67.                 break;  
  68.             default:  
  69.                 break;  
  70.             }  
  71.               
  72.         }  
  73.           
  74.     };  
  75.       
  76.       
  77.     @Override  
  78.     protected void onCreate(Bundle savedInstanceState) {  
  79.         super.onCreate(savedInstanceState);  
  80.         setContentView(R.layout.activity_main);  
  81.         sendRequest=(Button) findViewById(R.id.send_request);  
  82.         responseText=(TextView) findViewById(R.id.response_text);  
  83.         sendRequest.setOnClickListener(this);  
  84.           
  85.     }  
  86.   
  87.     @Override  
  88.     public boolean onCreateOptionsMenu(Menu menu) {  
  89.         // Inflate the menu; this adds items to the action bar if it is present.  
  90.         getMenuInflater().inflate(R.menu.main, menu);  
  91.         return true;  
  92.     }  
  93.   
  94.     @Override  
  95.     public void onClick(View v) {  
  96.         // TODO Auto-generated method stub  
  97.         if(v.getId()==R.id.send_request){  
  98.             //sendRequestWithHttpURLConnection();  
  99.             sendRequestWithHttpClient();  
  100.         }  
  101.           
  102.     }  
  103.       
  104.       
  105.     private void sendRequestWithHttpURLConnection(){  
  106.         //开启线程来发起网络请求  
  107.         new Thread(new Runnable(){  
  108.   
  109.             @Override  
  110.             public void run() {  
  111.                 // TODO Auto-generated method stub  
  112.                 HttpURLConnection connection=null;  
  113.                   
  114.                 try {  
  115.                     URL url=new URL("http://www.baidu.com");  
  116.                     connection =(HttpURLConnection) url.openConnection();  
  117.                     connection.setRequestMethod("GET");  
  118.                     connection.setConnectTimeout(8000);  
  119.                     connection.setReadTimeout(8000);  
  120.                     InputStream in=connection.getInputStream();  
  121.                     //下面对获取到的输入流进行读取  
  122.                     BufferedReader reader=new BufferedReader(new InputStreamReader(in));  
  123.                     StringBuilder response=new StringBuilder();  
  124.                     String line;  
  125.                     while((line=reader.readLine())!=null){  
  126.                         response.append(line);  
  127.                     }  
  128.                     Message message=new Message();  
  129.                     message.what=SHOW_RESPONSE;  
  130.                     //将服务器返回的结果存放到Message中  
  131.                     message.obj=response.toString();  
  132.                     handler.sendMessage(message);  
  133.                       
  134.                       
  135.                 } catch (MalformedURLException e) {  
  136.                     // TODO Auto-generated catch block  
  137.                     e.printStackTrace();  
  138.                 }catch(Exception e){  
  139.                     e.printStackTrace();  
  140.                 }finally{  
  141.                     if(connection!=null){  
  142.                         connection.disconnect();  
  143.                     }  
  144.                 }  
  145.             }  
  146.               
  147.         }).start();  
  148.           
  149.           
  150.     }  
  151.       
  152.       
  153.     private void sendRequestWithHttpClient(){  
  154.         new Thread(new Runnable(){  
  155.   
  156.             @Override  
  157.             public void run() {  
  158.                 // TODO Auto-generated method stub  
  159.                 try{  
  160.                     HttpClient httpClient=new DefaultHttpClient() ;  
  161.                     //HttpGet httpGet=new HttpGet("http://www.baidu.com");  
  162.                     //指定访问的服务器地址是电脑本机，10.0.2.2对模拟器来说就是电脑本机的ip地址  
  163.                     //8080为端口号  
  164.                     //HttpGet httpGet=new HttpGet("http://10.0.2.2:8080/get_data.xml");  
  165.                     HttpGet httpGet=new HttpGet("http://10.0.2.2:8080/get_data.json");  
  166.                     HttpResponse httpResponse=httpClient.execute(httpGet);  
  167.                     if(httpResponse.getStatusLine().getStatusCode()==200){  
  168.                         //请求和响应都成功了  
  169.                         HttpEntity entity=httpResponse.getEntity();  
  170.                         String response=EntityUtils.toString(entity,"utf-8");  
  171.                         //调用parseXMLWithPull方法解析服务器返回的数据  
  172.                         //parseXMLWithPull(response);  
  173.                           
  174.                         //调用parseXMLWithSAX方法解析服务器返回的数据  
  175.                         //parseXMLWithSAX(response);  
  176.                           
  177.                         //调用parseJSONWithJSONObject方法解析服务器返回的数据  
  178.                         //parseJSONWithJSONObject(response);  
  179.                           
  180.                           
  181.                           
  182.                         //调用parseJSONWithGSON方法解析服务器返回的数据  
  183.                         parseJSONWithGSON(response);  
  184.                           
  185.                         Message message=new Message();  
  186.                         message.what=SHOW_RESPONSE;  
  187.                         //将服务器返回的结果存放到Message中  
  188.                         message.obj=response.toString();  
  189.                         handler.sendMessage(message);  
  190.                     }  
  191.                 }catch(Exception e){  
  192.                     e.printStackTrace();  
  193.                 }  
  194.             }  
  195.               
  196.         }).start();  
  197.           
  198.     }  
  199.       
  200.     //使用Pull解析xml  
  201.     private void parseXMLWithPull(String xmlData){  
  202.         //Log.d("MainActivity", "parseXMLWithPull(String xmlData)");  
  203.         try{  
  204.             //获取到XmlPullParserFactory的实例，并借助这个实例得到XmlPullParser对象  
  205.             XmlPullParserFactory factory=XmlPullParserFactory.newInstance();  
  206.             XmlPullParser xmlPullParser=factory.newPullParser();  
  207.             //调用XmlPullParser的setInput方法将服务器返回的xml数据设置进去开始解析  
  208.             xmlPullParser.setInput(new StringReader(xmlData));  
  209.             //通过getEventType()方法得到当前解析事件  
  210.             int eventType=xmlPullParser.getEventType();  
  211.             String id="";  
  212.             String name="";  
  213.             String version="";  
  214.             while(eventType!=XmlPullParser.END_DOCUMENT){  
  215.                 //通过getName()方法得到当前节点的名字，如果发现节点名等于id、name、或version  
  216.                 //就调用nextText()方法来获取结点具体的内容，每当解析完一个app结点就将获取到的内容打印出来  
  217.                 String nodeName=xmlPullParser.getName();  
  218.                 //Log.d("MainActivity",""+eventType+ " nodeName= "+nodeName);  
  219.                 switch(eventType){  
  220.                 //开始解析某个节点  
  221.                 case XmlPullParser.START_TAG:{  
  222.                     if("id".equals(nodeName)){  
  223.                         id=xmlPullParser.nextText();  
  224.                     }else if("name".equals(nodeName)){  
  225.                         name=xmlPullParser.nextText();  
  226.                     }else if("version".equals(nodeName)){  
  227.                         version=xmlPullParser.nextText();  
  228.                     }  
  229.                     break;  
  230.                 }  
  231.                 case XmlPullParser.END_TAG:{  
  232.                     if("app".equals(nodeName)){  
  233.                         Log.d("MainActivity", "id is "+id);  
  234.                         Log.d("MainActivity", "name is "+name);  
  235.                         Log.d("MainActivity", "version is "+version);  
  236.                     }  
  237.                     break;  
  238.                 }  
  239.                 default:  
  240.                     break;  
  241.                 }  
  242.                 //调用next()方法获取到下一个解析事件  
  243.                 eventType=xmlPullParser.next();  
  244.             }  
  245.         }catch(Exception e){  
  246.             e.printStackTrace();  
  247.         }  
  248.     }  
  249.       
  250.       
  251.     //进行SAX解析的函数  
  252.     private void parseXMLWithSAX(String xmlData){  
  253.         /* 
  254.          * parseXMLWithSAX方法中先创建一个SAXParserFactory的对象，然后再获取到 
  255.          * XMLReader对象，接着将我们编写的ContentHandler的实例设置到XMLReader中， 
  256.          * 最后调用parse()方法开始执行解析。 
  257.          * */  
  258.         try{  
  259.             SAXParserFactory factory=SAXParserFactory.newInstance();  
  260.             XMLReader xmlReader=factory.newSAXParser().getXMLReader();  
  261.             ContentHandler handler=new ContentHandler();  
  262.             //将ContentHandler的实例设置到XMLReader中  
  263.             xmlReader.setContentHandler(handler);  
  264.             //开始执行解析  
  265.             xmlReader.parse(new InputSource(new StringReader(xmlData)));  
  266.               
  267.         }catch(Exception e){  
  268.             e.printStackTrace();  
  269.         }  
  270.     }  
  271.       
  272.       
  273.       
  274.     //使用JSONObject解析json格式的数据  
  275.     private void parseJSONWithJSONObject(String jsonData){  
  276.         /* 
  277.          * 首先把http请求的地址改成http://localhost:8080/get_data.json，然后在得到服务器返回 
  278.          * 的数据后调用parseJSONWithJSONObject()方法来解析数据。由于我们在服务器中定义的是一个json数组， 
  279.          * 因此解析的时候首先是将服务器返回的数据传入到一个JSONArray对象中。然后循环遍历这个JSONArray，从 
  280.          * 中取出的每一个元素都是一个JSONObject对象，每个JSONObject对象中又包含了id,name和version这些 
  281.          * 数据。接下来只需要调用getString()方法将这些数据取出，并打印出来即可。 
  282.          * */  
  283.         try{  
  284.             JSONArray jsonArray=new JSONArray(jsonData);  
  285.             for(int i=0;i<jsonArray.length();i++){  
  286.                 JSONObject jsonObject=jsonArray.getJSONObject(i);  
  287.                 String id=jsonObject.getString("id");  
  288.                 String name=jsonObject.getString("name");  
  289.                 String version=jsonObject.getString("version");  
  290.                 Log.d("MainActivity", "id is "+id);  
  291.                 Log.d("MainActivity", "name is "+name);  
  292.                 Log.d("MainActivity", "version is "+version);  
  293.             }  
  294.         }catch(Exception e){  
  295.             e.printStackTrace();  
  296.         }  
  297.     }  
  298.       
  299.       
  300.       
  301.     //使用JSONWithGSON(String jsonData)方法解析json格式的数据  
  302.     private void parseJSONWithGSON(String jsonData){  
  303.         Gson gson=new Gson();  
  304.         List<App> appList=gson.fromJson(jsonData, new   
  305.                 TypeToken<List<App>>() {}.getType());  
  306.         for(App app: appList){  
  307.             Log.d("MainActivity", "id is "+app.getId());  
  308.             Log.d("MainActivity", "name is "+app.getName());  
  309.             Log.d("MainActivity", "version is "+app.getVersion());  
  310.         }  
  311.     }  
  312.       
  313.       
  314.       
  315. }  


运行程序，结果如下所示：




        经过上面两种方法对json格式的数据进行解析，相信对json格式的数据应该不再陌生了。




http://blog.csdn.net/j903829182/article/details/42503583

posted on 2016-09-08 13:39  miaozhenzhong  阅读(193)  评论(0)  编辑  收藏  举报

导航