Android使用XML全攻略(2)


Android 是针对移动设备的一种新兴的开源操作系统和 SDK。借助它，您可以创建功能强大的移动应用程序。当您的应用程序可以访问 Web 服务时，其吸引力会大大增加，这意味着您需要使用 Web 语言：XML。在本文中，您将了解在 Android 上使用 XML 的不同方法，以及如何使用它们构建自己的 Android 应用程序。

更加简单的 SAX 解析

Android SDK 提供了一个名称为android.util.Xml的实用类。清单 7 展示了如何使用这个相同的实用类来设置一个 SAX 解析器。

清单 7.Android SAX 解析器

                
                        
  1. publicclassAndroidSaxFeedParserextendsBaseFeedParser{
    2.                     
  2. publicAndroidSaxFeedParser(StringfeedUrl){
    3.                     
  3. super(feedUrl);
    4.                     
  4. }
    5.                     
  5. publicList<Message>parse(){
    6.                     
  6. RssHandlerhandler=newRssHandler();
    7.                     
  7. try{
    8.                     
  8. Xml.parse(this.getInputStream(),Xml.Encoding.UTF_8,handler);
    9.                     
  9. }catch(Exceptione){
    10.                     
  10. thrownewRuntimeException(e);
    11.                     
  11. }
    12.                     
  12. returnhandler.getMessages();
    13.                     
  13. }
    14.                     
  14. }
    15.

注意，这个类仍然使用了一个标准的 SAX 处理程序，因此您仅仅重用了 清单 7 中所示的 RssHandler。能够重用 SAX 处理程序是非常不错的，但其代码稍微有些复杂。您可以想像，如果需要解析一个更加复杂的 XML 文档，则处理程序可能会带来各种各样的 bug。举例来说，回头看看 清单 6 中的 endElement 方法。注意，在尝试设置属性之前，它检查了 currentMessage 是否为 null。现在，再回头看看 清单 4 中的示例 XML。 注意，ITEM 标记外部有一些 TITLE 和 LINK 标记。这就是使用 null 检查的原因。否则，每一个 TITLE标记 会导致一个 NullPointerException。Android 提供了自己独有的 SAX API（参见 清单 8），它排除了您编写自己的 SAX 处理程序的需要。

清单 8.经过简化的 Android SAX 解析器

                
                        
  1. publicclassAndroidSaxFeedParserextendsBaseFeedParser{
    2.                     
  2. publicAndroidSaxFeedParser(StringfeedUrl){
    3.                     
  3. super(feedUrl);
    4.                     
  4. }
    5.                     
  5. publicList<Message>parse(){
    6.                     
  6. finalMessagecurrentMessage=newMessage();
    7.                     
  7. RootElementroot=newRootElement("rss");
    8.                     
  8. finalList<Message>messages=newArrayList<Message>();
    9.                     
  9. Elementchannel=root.getChild("channel");
    10.                     
  10. Elementitem=channel.getChild(ITEM);
    11.                     
  11. item.setEndElementListener(newEndElementListener(){
    12.                     
  12. publicvoidend(){
    13.                     
  13. messages.add(currentMessage.copy());
    14.                     
  14. }
    15.                     
  15. });
    16.                     
  16. item.getChild(TITLE).setEndTextElementListener(newEndTextElementListener(){
    17.                     
  17. publicvoidend(Stringbody){
    18.                     
  18. currentMessage.setTitle(body);
    19.                     
  19. }
    20.                     
  20. });
    21.                     
  21. item.getChild(LINK).setEndTextElementListener(newEndTextElementListener(){
    22.                     
  22. publicvoidend(Stringbody){
    23.                     
  23. currentMessage.setLink(body);
    24.                     
  24. }
    25.                     
  25. });
    26.                     
  26. item.getChild(DESCRIPTION).setEndTextElementListener(new
    27.                     
  27. EndTextElementListener(){
    28.                     
  28. publicvoidend(Stringbody){
    29.                     
  29. currentMessage.setDescription(body);
    30.                     
  30. }
    31.                     
  31. });
    32.                     
  32. item.getChild(PUB_DATE).setEndTextElementListener(newEndTextElementListener(){
    33.                     
  33. publicvoidend(Stringbody){
    34.                     
  34. currentMessage.setDate(body);
    35.                     
  35. }
    36.                     
  36. });
    37.                     
  37. try{
    38.                     
  38. Xml.parse(this.getInputStream(),Xml.Encoding.UTF_8,
    39.                     
  39. root.getContentHandler());
    40.                     
  40. }catch(Exceptione){
    41.                     
  41. thrownewRuntimeException(e);
    42.                     
  42. }
    43.                     
  43. returnmessages;
    44.                     
  44. }
    45.                     
  45. }
    46.

新的SAX 解析代码并未使用 SAX 处理程序，而是使用了 SDK 中的 android.sax 包中的类。这些类允许您构建 XML 文档的结构，并根据需要添加事件监听程序。在以上代码中，您声明文档将有一个 rss 根元素，并且它有一个 channel 子元素。然后，您声明channel 将有一个 ITEM 子元素，并且开始添加监听程序。对于每个监听程序，您都使用了一个实现了特定接口（EndElementListner或 EndTextElementListener）的匿名内部类。注意，您不需要跟踪字符数据。不仅仅因为这样会更加简单，更重要的是更加高效。最后，在调 用 Xml.parse 实用方法时，您将传递一个通过根元素生成的处理程序。

清单 8 中的所有代码都是可选的。如果您习惯 Java 环境中的标准 SAX 解析代码，那么您可以坚持使用它。如果您希望尝试 Android SDK 所提供的便捷的包装器，那么也可以使用它。如果您完全不希望使用 SAX 会怎样呢？可以使用一些备选方案。其中的首选方法就是 DOM。

使用 DOM

Android 完全支持 DOM 解析，就像在桌面机器或服务器上使用 Java 代码运行它一样。清单 9 显示了一个基于 DOM 的解析器接口实现。

清单 9.基于 DOM 的提要解析器实现

                
                        
  1. publicclassDomFeedParserextendsBaseFeedParser{
    2.                     
  2. protectedDomFeedParser(StringfeedUrl){
    3.                     
  3. super(feedUrl);
    4.                     
  4. }
    5.                     
  5. publicList<Message>parse(){
    6.                     
  6. DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
    7.                     
  7. List<Message>messages=newArrayList<Message>();
    8.                     
  8. try{
    9.                     
  9. DocumentBuilderbuilder=factory.newDocumentBuilder();
    10.                     
  10. Documentdom=builder.parse(this.getInputStream());
    11.                     
  11. Elementroot=dom.getDocumentElement();
    12.                     
  12. NodeListitems=root.getElementsByTagName(ITEM);
    13.                     
  13. for(inti=0;i<items.getLength();i++){
    14.                     
  14. Messagemessage=newMessage();
    15.                     
  15. Nodeitem=items.item(i);
    16.                     
  16. NodeListproperties=item.getChildNodes();
    17.                     
  17. for(intj=0;j<properties.getLength();j++){
    18.                     
  18. Nodeproperty=properties.item(j);
    19.                     
  19. Stringname=property.getNodeName();
    20.                     
  20. if(name.equalsIgnoreCase(TITLE)){
    21.                     
  21. message.setTitle(property.getFirstChild().getNodeValue());
    22.                     
  22. }elseif(name.equalsIgnoreCase(LINK)){
    23.                     
  23. message.setLink(property.getFirstChild().getNodeValue());
    24.                     
  24. }elseif(name.equalsIgnoreCase(DESCRIPTION)){
    25.                     
  25. StringBuildertext=newStringBuilder();
    26.                     
  26. NodeListchars=property.getChildNodes();
    27.                     
  27. for(intk=0;k<chars.getLength();k++){
    28.                     
  28. text.append(chars.item(k).getNodeValue());
    29.                     
  29. }
    30.                     
  30. message.setDescription(text.toString());
    31.                     
  31. }elseif(name.equalsIgnoreCase(PUB_DATE)){
    32.                     
  32. message.setDate(property.getFirstChild().getNodeValue());
    33.                     
  33. }
    34.                     
  34. }
    35.                     
  35. messages.add(message);
    36.                     
  36. }
    37.                     
  37. }catch(Exceptione){
    38.                     
  38. thrownewRuntimeException(e);
    39.                     
  39. }
    40.                     
  40. returnmessages;
    41.                     
  41. }
    42.                     
  42. }
    43.

与第一个 SAX 示例类似，以上代码完全没有特定于 Android 的地方。DOM 解析器将所有 XML 文档读取到内存中，然后允许您使用 DOM API 遍历 XML 树、检索所需的数据。这是非常直观的代码，并且，在某些方面比基于 SAX 的实现更加简单。但是，DOM 通常更加占用内存，因为一切内容都会先读取到内存中。这对于运行 Android 的移动设备来说是一个问题，但是当 XML 文档始终保持很小的大小时是可行的。这可能意味着，Android 的开发人员会认为 SAX 解析在 Android 应用程序上更加常见，因此为它提供了额外的实用工具。Android 还提供了另一种类型的 XML 解析器，它就是 pull 解析器。

XML pull 解析器

如前所述，Android 并未提供对 Java StAX API 的支持。但是，Android 确实附带了一个 pull 解析器，其工作方式类似于 StAX。它允许您的应用程序代码从解析器中获取事件，这与 SAX 解析器自动将事件推入处理程序相反。清单 10 显示了提要解析接口的一个 pull 解析器实现。

清单 10.基于 Pull 解析器的实现

                
                        
  1. publicclassXmlPullFeedParserextendsBaseFeedParser{
    2.                     
  2. publicXmlPullFeedParser(StringfeedUrl){
    3.                     
  3. super(feedUrl);
    4.                     
  4. }
    5.                     
  5. publicList<Message>parse(){
    6.                     
  6. List<Message>messages=null;
    7.                     
  7. XmlPullParserparser=Xml.newPullParser();
    8.                     
  8. try{
    9.                     
  9. //auto-detecttheencodingfromthestream
    10.                     
  10. parser.setInput(this.getInputStream(),null);
    11.                     
  11. inteventType=parser.getEventType();
    12.                     
  12. MessagecurrentMessage=null;
    13.                     
  13. booleandone=false;
    14.                     
  14. while(eventType!=XmlPullParser.END_DOCUMENT&&!done){
    15.                     
  15. Stringname=null;
    16.                     
  16. switch(eventType){
    17.                     
  17. caseXmlPullParser.START_DOCUMENT:
    18.                     
  18. messages=newArrayList<Message>();
    19.                     
  19. break;
    20.                     
  20. caseXmlPullParser.START_TAG:
    21.                     
  21. name=parser.getName();
    22.                     
  22. if(name.equalsIgnoreCase(ITEM)){
    23.                     
  23. currentMessage=newMessage();
    24.                     
  24. }elseif(currentMessage!=null){
    25.                     
  25. if(name.equalsIgnoreCase(LINK)){
    26.                     
  26. currentMessage.setLink(parser.nextText());
    27.                     
  27. }elseif(name.equalsIgnoreCase(DESCRIPTION)){
    28.                     
  28. currentMessage.setDescription(parser.nextText());
    29.                     
  29. }elseif(name.equalsIgnoreCase(PUB_DATE)){
    30.                     
  30. currentMessage.setDate(parser.nextText());
    31.                     
  31. }elseif(name.equalsIgnoreCase(TITLE)){
    32.                     
  32. currentMessage.setTitle(parser.nextText());
    33.                     
  33. }
    34.                     
  34. }
    35.                     
  35. break;
    36.                     
  36. caseXmlPullParser.END_TAG:
    37.                     
  37. name=parser.getName();
    38.                     
  38. if(name.equalsIgnoreCase(ITEM)&&
    39.                     
  39. currentMessage!=null){
    40.                     
  40. messages.add(currentMessage);
    41.                     
  41. }elseif(name.equalsIgnoreCase(CHANNEL)){
    42.                     
  42. done=true;
    43.                     
  43. }
    44.                     
  44. break;
    45.                     
  45. }
    46.                     
  46. eventType=parser.next();
    47.                     
  47. }
    48.                     
  48. }catch(Exceptione){
    49.                     
  49. thrownewRuntimeException(e);
    50.                     
  50. }
    51.                     
  51. returnmessages;
    52.                     
  52. }
    53.                     
  53. }
    54.

pull 解析器的运行方式与 SAX 解析器相似。它提供了类似的事件（开始元素和结束元素），但您需要使用 (parser.next() 提取它们。事件将作为数值代码被发送，因此您可以使用一个简单 case-switch。注意，解析并未像 SAX 解析那样监听元素的结束，而是在开始处完成了大部分处理。在 清单 10 的代码中，当某个元素开始时，您可以调用 parser.nextText() 从 XML 文档中提取所有字符数据。还需注意，您设置了一个标记（布尔变量 done）来确定何时到达感兴趣内容的结束部分。这允许您提早停止读取 XML 文档，因为您知道代码将不会关心文档的其余部分。这有时非常实用，特别是当您只需要访问一小部分 XML 文档时。通过尽快停止解析，您可以极大地减少解析时间。这种优化对于连接速度较慢的移动设备尤为重要。pull 解析器可以提供一些性能优势以及易用性。它还可以用于编写 XML。

创建 XML

目前为止，我一直专注于通过 Internet 解析 XML。但是，有时您的应用程序可能需要将 XML 发送到远程服务器。显然，您可以只使用一个 StringBuilder 来创建 XML 字符串。另一种备选方法来自 清单 11 中的 Pull 解析器。

清单 11.使用 pull 解析器编写 XML

                
                        
  1. privateStringwriteXml(List<Message>messages){
    2.                     
  2. XmlSerializerserializer=Xml.newSerializer();
    3.                     
  3. StringWriterwriter=newStringWriter();
    4.                     
  4. try{
    5.                     
  5. serializer.setOutput(writer);
    6.                     
  6. serializer.startDocument("UTF-8",true);
    7.                     
  7. serializer.startTag("","messages");
    8.                     
  8. serializer.attribute("","number",String.valueOf(messages.size()));
    9.                     
  9. for(Messagemsg:messages){
    10.                     
  10. serializer.startTag("","message");
    11.                     
  11. serializer.attribute("","date",msg.getDate());
    12.                     
  12. serializer.startTag("","title");
    13.                     
  13. serializer.text(msg.getTitle());
    14.                     
  14. serializer.endTag("","title");
    15.                     
  15. serializer.startTag("","url");
    16.                     
  16. serializer.text(msg.getLink().toExternalForm());
    17.                     
  17. serializer.endTag("","url");
    18.                     
  18. serializer.startTag("","body");
    19.                     
  19. serializer.text(msg.getDescription());
    20.                     
  20. serializer.endTag("","body");
    21.                     
  21. serializer.endTag("","message");
    22.                     
  22. }
    23.                     
  23. serializer.endTag("","messages");
    24.                     
  24. serializer.endDocument();
    25.                     
  25. returnwriter.toString();
    26.                     
  26. }catch(Exceptione){
    27.                     
  27. thrownewRuntimeException(e);
    28.                     
  28. }
    29.                     
  29. }
    30.

XmlSerializer 类是 前一部分 所使用的 XmlPullParser 包的一部分。它没有提取事件，而是将它们推出到数据流或编写程序中。在本例中，它仅仅将事件推送到了一个 java.io.StringWriter 实例中。它提供了一个直观的 API，通过各种方法开始和结束文档、处理元素以及添加文本或属性。这是StringBuilder的一种出色的替换方案，因为它可以更加轻松地确保您的 XML 具有良好结构。

结束语

您希望为Android设备构建何种类型的应用程序？无论如何，如果它需要通过 Internet 使用数据，那么都可能需要使用XML。在本文中，您看到 Android 提供了大量用于处理XML的工具。您可以选择其中之一作为自己的工具，或者您可以根据用例来进行选择。大多数时间，使用SAX是比较安全的，并且Android提供了一种传统的SAX 使用方法，以及一个便捷的SAX包装器。如果您的文档比较小，那么DOM可能是一种比较简单的方法。如果您的文档比较大，但您只需要文档的一部分，则XML Pull解析器可能是更为有效的方法。最后，对于编写XML，Pull解析器包也提供了一种便捷的方法。因此，无论您的XML需求如何，Android都能在一定程度上满足它们。

更多相关文章

  1. 第一行代码笔记1
  2. 第一行代码:AlertDialog
  3. Android 自动更新代码
  4. Android 自制一个工作日历 原代码
  5. android 网络视频代码
  6. android版本更新代码
  7. Google Android 文档笔记-Training-Getting started [2]
  8. Google Android 文档笔记-Training-Getting started [4]
  9. 系出名门 Android源代码

随机推荐

  1. android坐标
  2. Android日语输入法Simeji使用示例
  3. Android 在桌面创建一个快捷方式
  4. android之Notification的使用
  5. Android 购物车（精仿）可删可全选与反选
  6. android 上下左右手势判断 根据别人的改
  7. Android EditText 密码输入框可见性设置
  8. android监听手机网络连接状态改变的后台
  9. Android Media Server - MediaPlayer - s
  10. Android Studio sync 失败解决方法