Android] Android XML解析学习——方式比较

 [Android] Android XML解析学习——方式比较 (ZT) 

分类： 嵌入式

 

(From：http://blog.csdn.net/ichliebephone/article/details/5981913）

 

一．基础知识

经过这段时间的学习，我们已经了解了Android平台上用于解析XML的三种方式：SAX、DOM和Pull。并且在学习的过程中也介绍了这三种方式各自的特点及适合的使用场合，简单的来说，DOM方式最直观和容易理解，但是只适合XML文档较小的时候使用，而SAX方式更适合在Android系统中使用，因为相比DOM占用内存少，适合处理比较大的XML文档，最后的Pull方式使用场合和SAX类似，但是更适合需要提前结束XML文档解析的场合。

在这部分的学习中，我们将对以上三种方式解析XML的性能进行一下简单的比较，通过记录比较他们读取相同XML文档的时间来更好的理解他们的性能，从而使你在不同的场合更好的选择使用那一种XML的解析方式。

 

下面我们就用上面介绍的几种方式来实现解析XML形式的USGS地震数据的Demo例子以作比较。

二．实例开发

我们要完成的效果图如下图1所示：

 

图1 各种方式解析花费的时间比较

 

 

我们分别使用Java SAX，Android SAX，DOM和Pull方式解析相同的XML地震数据，并记录他们完成解析所花费的时间，结果如上图所示。

新建一个Android工程AndroidXMLDemoCompare。

添加进之前Demo工程AndroidXMLDemoSax中的EarthquakeEntry.java和SaxEarthquakeHandler.java文件，工程AndroidXMLDemoSaxII中的AndroidSaxEarthquakeHandler.java文件，工程AndroidXMLDemoDom中的DomEarthquakeHandler.java文件，和工程AndroidXMLDemoPull中的PullEarthquakeHandler.java文件。

如果需要从本地读取xml数据的话，同时在assets文件夹下添加保存为xml格式了的USGS地震数据USGS_Earthquake_1M2_5.xml和USGS_Earthquake_7M2_5.xml，如果需要联网读取的话，在manifest.xml文件中添加权限：

 

 

view plain
  1. <uses-permission android:name="android.permission.INTERNET" />  

并修改res/layout下的main.xml为：

view plain
  1. xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:orientation="vertical"  
  4.     android:layout_width="fill_parent"  
  5.     android:layout_height="fill_parent"  
  6.     >  
  7.   <Button   
  8.     android:id="@+id/javaSaxBtn"  
  9.     android:layout_width="fill_parent"  
  10.     android:layout_height="wrap_content"  
  11.     android:text="Java SAX Parse"  
  12.     >  
  13.   Button>  
  14.   <Button   
  15.     android:id="@+id/androidSaxBtn"  
  16.     android:layout_width="fill_parent"  
  17.     android:layout_height="wrap_content"  
  18.     android:text="Android SAX Parse"  
  19.     >  
  20.   Button>  
  21.   <Button   
  22.     android:id="@+id/domBtn"  
  23.     android:layout_width="fill_parent"  
  24.     android:layout_height="wrap_content"  
  25.     android:text="DOM Parse"  
  26.     >  
  27.   Button>  
  28.   <Button   
  29.     android:id="@+id/pullBtn"  
  30.     android:layout_width="fill_parent"  
  31.     android:layout_height="wrap_content"  
  32.     android:text="PULL Parse"  
  33.     >  
  34.   Button>    
  35.   <TextView  
  36.     android:id="@+id/javaSaxText"  
  37.     android:layout_width="fill_parent"  
  38.     android:layout_height="wrap_content"  
  39.     android:text="Java SAX Parse Time:">  
  40.   TextView>  
  41.   <TextView  
  42.     android:id="@+id/androidSaxText"  
  43.     android:layout_width="fill_parent"  
  44.     android:layout_height="wrap_content"  
  45.     android:text="Android SAX Parse Time:">  
  46.   TextView>    
  47.   <TextView  
  48.     android:id="@+id/domText"  
  49.     android:layout_width="fill_parent"  
  50.     android:layout_height="wrap_content"  
  51.     android:text="DOM Parse Time:">  
  52.   TextView>  
  53.   <TextView  
  54.     android:id="@+id/pullText"  
  55.     android:layout_width="fill_parent"  
  56.     android:layout_height="wrap_content"  
  57.     android:text="PULL Parse Time:">  
  58.   TextView>     
  59. LinearLayout>  

主要定义了4个分别启动Java SAX、Android SAX、DOM和Pull方式解析的按钮Button，和4个显示解析所花费时间的TextView。

接着修改AndroidXMLDemoCompare.java文件的内容为：

view plain
  1. public class AndroidXMLDemoCompare extends Activity {  
  2.     /** Called when the activity is first created. */  
  3.     //定义变量  
  4.     Button javaSaxBtn, androidSaxBtn, domBtn, pullBtn;  
  5.     TextView javaSaxText, androidSaxText, domText, pullText;  
  6.     ArrayList earthquakeEntryList;  
  7.     @Override  
  8.     public void onCreate(Bundle savedInstanceState) {  
  9.         super.onCreate(savedInstanceState);  
  10.         setContentView(R.layout.main);  
  11.           
  12.         //测试各个xml解析方法的速度  
  13.       javaSaxBtn = (Button)findViewById(R.id.javaSaxBtn);  
  14.       androidSaxBtn = (Button)findViewById(R.id.androidSaxBtn);  
  15.       domBtn = (Button)findViewById(R.id.domBtn);  
  16.       pullBtn = (Button)findViewById(R.id.pullBtn);  
  17.       javaSaxText = (TextView)findViewById(R.id.javaSaxText);  
  18.       androidSaxText = (TextView)findViewById(R.id.androidSaxText);  
  19.       domText = (TextView)findViewById(R.id.domText);  
  20.       pullText = (TextView)findViewById(R.id.pullText);  
  21.       javaSaxBtn.setOnClickListener(new OnClickListener() {  
  22.           @Override  
  23.             public void onClick(View v) {  
  24.                 // TODO Auto-generated method stub  
  25.                 javaSaxBtn.setEnabled(false);  
  26.                 androidSaxBtn.setEnabled(false);  
  27.                 domBtn.setEnabled(false);  
  28.                 pullBtn.setEnabled(false);  
  29.                 //获取地震数据流  
  30.                 InputStream earthquakeStream = readEarthquakeDataFromFile();  
  31.                 String saxTime = "Java SAX Parse Time: 正在解析，请稍后...";  
  32.                 javaSaxText.setText(saxTime);  
  33.                 long beforeTime = System.currentTimeMillis();  
  34.                 //Java Sax方式进行xml解析  
  35.                 SAXParserFactory factory = SAXParserFactory.newInstance();  
  36.                 try {  
  37.                     SAXParser parser = factory.newSAXParser();  
  38.                     SaxEarthquakeHandler saxHandler = new SaxEarthquakeHandler();  
  39.                     parser.parse(earthquakeStream, saxHandler);  
  40.                     //获取解析后的列表数据  
  41.                     earthquakeEntryList = saxHandler.getEarthquakeEntryList();  
  42.                 } catch (Exception e) {  
  43.                     // TODO Auto-generated catch block  
  44.                     e.printStackTrace();  
  45.                 }  
  46.                 //解析完毕  
  47.                 long afterTime = System.currentTimeMillis();  
  48.                 long parseTime = (afterTime - beforeTime);  
  49.                 saxTime = "Java SAX Parse Time: " + String.valueOf(parseTime) + "毫秒";  
  50.                 javaSaxText.setText(saxTime);  
  51.                 javaSaxBtn.setEnabled(true);  
  52.                 androidSaxBtn.setEnabled(true);  
  53.                 domBtn.setEnabled(true);  
  54.                 pullBtn.setEnabled(true);  
  55.             }  
  56.         });  
  57.       androidSaxBtn.setOnClickListener(new OnClickListener() {  
  58.         @Override  
  59.         public void onClick(View v) {  
  60.             // TODO Auto-generated method stub  
  61.             javaSaxBtn.setEnabled(false);  
  62.             androidSaxBtn.setEnabled(false);  
  63.             domBtn.setEnabled(false);  
  64.             pullBtn.setEnabled(false);  
  65.             //获取地震数据流  
  66.             InputStream earthquakeStream = readEarthquakeDataFromFile();  
  67.             String saxTime = "Android SAX Parse Time: 正在解析，请稍后...";  
  68.             androidSaxText.setText(saxTime);  
  69.             long beforeTime = System.currentTimeMillis();  
  70.             //Android Sax方式进行解析  
  71.             AndroidSaxEarthquakeHandler androidSaxHandler = new AndroidSaxEarthquakeHandler();  
  72.             earthquakeEntryList = androidSaxHandler.parse(earthquakeStream);  
  73.             //解析完毕  
  74.             long afterTime = System.currentTimeMillis();  
  75.             long parseTime = (afterTime - beforeTime);  
  76.             saxTime = "Android SAX Parse Time: " + String.valueOf(parseTime) + "毫秒";  
  77.             androidSaxText.setText(saxTime);  
  78.             javaSaxBtn.setEnabled(true);  
  79.             androidSaxBtn.setEnabled(true);  
  80.             domBtn.setEnabled(true);  
  81.             pullBtn.setEnabled(true);             
  82.         }  
  83.     });  
  84.       domBtn.setOnClickListener(new OnClickListener() {  
  85.             @Override  
  86.             public void onClick(View v) {  
  87.                 // TODO Auto-generated method stub  
  88.                 javaSaxBtn.setEnabled(false);  
  89.                 androidSaxBtn.setEnabled(false);  
  90.                 domBtn.setEnabled(false);  
  91.                 pullBtn.setEnabled(false);  
  92.                 //获取地震数据流  
  93.                 InputStream earthquakeStream = readEarthquakeDataFromFile();          
  94.                 String domTime = "DOM Parse Time: 正在解析，请稍后...";  
  95.                 domText.setText(domTime);  
  96.                 long beforeTime = System.currentTimeMillis();  
  97.                 //Dom方式进行xml解析  
  98.                 DomEarthquakeHandler domHandler = new DomEarthquakeHandler();  
  99.                 earthquakeEntryList = domHandler.parse(earthquakeStream);                 
  100.                 //解析完毕  
  101.                 long afterTime = System.currentTimeMillis();  
  102.                 long parseTime = (afterTime - beforeTime);  
  103.                 domTime = "DOM Parse Time: " + String.valueOf(parseTime) + "毫秒";  
  104.                 domText.setText(domTime);  
  105.                 javaSaxBtn.setEnabled(true);  
  106.                 androidSaxBtn.setEnabled(true);  
  107.                 domBtn.setEnabled(true);  
  108.                 pullBtn.setEnabled(true);  
  109.             }  
  110.         });  
  111.       pullBtn.setOnClickListener(new OnClickListener() {  
  112.             @Override  
  113.             public void onClick(View v) {  
  114.                 // TODO Auto-generated method stub  
  115.                 javaSaxBtn.setEnabled(false);  
  116.                 androidSaxBtn.setEnabled(false);  
  117.                 domBtn.setEnabled(false);  
  118.                 pullBtn.setEnabled(false);  
  119.                 //获取地震数据流  
  120.                 InputStream earthquakeStream = readEarthquakeDataFromFile();  
  121.                 String pullTime = "PULL Parse Time: 正在解析，请稍后...";  
  122.                 pullText.setText(pullTime);  
  123.                 long beforeTime = System.currentTimeMillis();  
  124.                 //Pull方式进行xml解析  
  125.                 PullEarthquakeHandler pullHandler = new PullEarthquakeHandler();  
  126.                 earthquakeEntryList = pullHandler.parse(earthquakeStream);  
  127.                 //解析完毕  
  128.                 long afterTime = System.currentTimeMillis();  
  129.                 long parseTime = (afterTime - beforeTime);  
  130.                 pullTime = "PULL Parse Time: " + String.valueOf(parseTime) + "毫秒";  
  131.                 pullText.setText(pullTime);  
  132.                 javaSaxBtn.setEnabled(true);  
  133.                 androidSaxBtn.setEnabled(true);  
  134.                 domBtn.setEnabled(true);  
  135.                 pullBtn.setEnabled(true);                 
  136.             }  
  137.         });  
  138.     }  
  139.       
  140.     private InputStream readEarthquakeDataFromFile()  
  141.     {  
  142.         //从本地获取地震数据  
  143.         InputStream inStream = null;  
  144.         try {  
  145.             //1天内2.5级以上的地震数据，约20来条地震信息  
  146. //          inStream = this.getAssets().open("USGS_Earthquake_1M2_5.xml");  
  147.             //7天内2.5级以上的地震数据，约200来条地震信息  
  148.             inStream = this.getAssets().open("USGS_Earthquake_7M2_5.xml");  
  149.               
  150.         } catch (IOException e) {  
  151.             // TODO Auto-generated catch block  
  152.             e.printStackTrace();  
  153.         }  
  154.         return inStream;  
  155.     }  
  156.     private InputStream readEarthquakeDataFromInternet()  
  157.     {  
  158.         //从网络上获取实时地震数据  
  159.         URL infoUrl = null;  
  160.         InputStream inStream = null;  
  161.         try {  
  162.             //1天内2.5级以上的地震数据，约20来条地震信息  
  163.             infoUrl = new URL("http://earthquake.usgs.gov/earthquakes/catalogs/1day-M2.5.xml");  
  164.             //7天内2.5级以上的地震数据，约200来条地震信息  
  165. //          infoUrl = new URL("http://earthquake.usgs.gov/earthquakes/catalogs/7day-M2.5.xml");  
  166.             URLConnection connection = infoUrl.openConnection();  
  167.             HttpURLConnection httpConnection = (HttpURLConnection)connection;  
  168.             int responseCode = httpConnection.getResponseCode();  
  169.             if(responseCode == HttpURLConnection.HTTP_OK)  
  170.             {  
  171.                 inStream = httpConnection.getInputStream();  
  172.             }  
  173.         } catch (MalformedURLException e) {  
  174.             // TODO Auto-generated catch block  
  175.             e.printStackTrace();  
  176.         } catch (IOException e) {  
  177.             // TODO Auto-generated catch block  
  178.             e.printStackTrace();  
  179.         }  
  180.         return inStream;  
  181.     }  
  182. }  

首先也是定义各个Button和TextView控件，接着为各个Button注册单击事件处理器，在单击事件处理的回调函数中，主要就是运行对应XML解析方式的解析过程，并且分别记录解析前和解析后的系统时间来计算解析所花费的时间，

 

view plain
  1.       long beforeTime = System.currentTimeMillis();  
  2.       //Android Sax方式进行解析  
  3.       AndroidSaxEarthquakeHandler androidSaxHandler = new AndroidSaxEarthquakeHandler();  
  4.       earthquakeEntryList = androidSaxHandler.parse(earthquakeStream);  
  5.       //解析完毕  
  6. long afterTime = System.currentTimeMillis();  
  7. long parseTime = (afterTime - beforeTime);  

 

 

完成了，可以保存运行看下效果。

 

 

 

图2 解析时间比较

 

左图是解析1天内2.5级以上的地震数据，约20来条地震信息时各个解析方式所花费的时间，右图是解析7天内2.5级以上的地震数据，约180来条地震信息时各个解析方式所花费的时间。从上图我们可以看到Java SAX、Android SAX和Pull方式花费的时间基本差不多，因为他们都是基于事件处理的方式，并且Java SAX和Android SAX底层调用的都是相同的org.xml.sax包中XMLReader解析器。而DOM方式相对来说所花费的时间就会长点，在地震数据条数较少和较多时都比较长。因此不管是从内存的消耗角度或者解析使用的时间角度来考虑，在Android平台上的应用程序中都不太推荐使用DOM方式来解析XML数据。但是Java SAX、Android SAX和Pull就看你喜欢使用哪个和你具体的使用场合了，性能上他们基本相同。

 

三．总结

在这部分内容中我们学习了各个解析方式的性能比较，即解析同一个XML文档时所花费时间的比较，并且从结果可以看出DOM方式的性能相对来说差点，而Java SAX、Android SAX和Pull方式的性能基本相同。

这样我们就比较全面的学习了Android平台上对XML文档进行解析的各种方式，但目前我们只是使用现成的XML文档来解析，实际上在使用过程中我们可能还会需要构造XML文档，比如可能会有需要向服务器发送XML，或者把一份数据以XML的形式保存在本地，这块内容就是写XML，我们以后接着学习。

posted on 2015-07-01 16:52  qingchen1984  阅读(477)  评论(0)  编辑  收藏  举报

导航