• Android XML文件结构 和 用XmlPullParser 来解析xml文件

    1. 背景

            在工作中，不管是写app代码，还是阅读framework中的源码，涉及到解析xml的代码片段非常多，本篇文章从两个点来讲解一下，第一个点：xml文件结构  第二个点：怎么用XmlPullParser去解析。掌握这些知识后，对在阅读分析PMS解析包安装管理xml文件的源码，就会比较清晰明了。

    2. XML文件结构

    2.1 XML 定义

            XML: Extentsible Markup Language(可扩展标记语言)的缩写，它的格式与HTML文件的格式类似，xml是使用自定义标记来定义对象和每个对象中的数据，xml文件可以被认为是基于文本的数据库。

    2.2 XML文件结构和基本语法

            一个XML文档由两部分构成：第一部分是文档声明，第二部分是文档元素（节点）

            文档声明通常位于XML文档的顶端，根元素之前出现，它是一个特定的包含XML 文档设定信息的部分

            XML 文档由如下几个部分组成：

    • XML 声明：用来设置XML文档解析时所需的基本参数。
    • 处理指令：为某个特定类型的软件反馈一条特殊的指令。
    • 文档类型定义：用来设置更多高级的信息，如实体、属性及有效性相关的信息。
    • 注释：用于提醒XML文档作者或临时标注出文档中不完善的部分。

    接下来介绍几个重要的概念： 

    xml文档声明 

            XML 文档声明是为XML 解析器进行文档处理时提供相关信息的一个很小的配置信息集合。每一个XML 文档应当包含一个XML 声明，并且XML 声明必须放在文档的第一行。如下：

    "1.0" encoding="utf-8" standalone="no"?>

            XML 声明中包括三个属性，每个属性设置的具体形式为：属性名称="属性值"。其中属性值需要是使用双引号或者单引号括起来，多个属性之间使用空格进行分隔。XML 声明中的三个属性的名称分别是：version、encoding和standalone。

            version：  此属性用来声明XML 文档所遵循的XML 标准版本。现在通常情况下该属性的值都是1.0，尽管 XML 1.1 已经称为 W3C 的推荐标准，但是大部分的 XML 解析器还是采用 XML 1.0 标准。version 是 XML 声明中必须包含的一个属性。

           encoding:   encoding 属性用来告诉 XML 解析程序当前 XML 文档使用什么样的字符编码。该属性是可选的。当 XML 声明中没有明确给出字符编码方式时，XML 解析程序将默认为 XML 文档采用的是 UTF-8 字符编码。

           standalone : standalone 属性定义了是否可以在不读取任何其他文件的情况下处理该文档。例如，XML 文档没有引用任何其他文件，则可以指定属性值为 yes。如果 XML 文档引用其他描述该文档可以包含的文件，则可以指定属性值为 no。因为 no 是 standalone 属性默认的属性值，所以较少会在 XML 声明中看到 standalone 属性。

            注意点：如果同时设置了 encoding 和 standalone 属性，standalone 属性必须位于 encoding 属性之后。

    元素

           XML元素指XML文件中出现的标签，一个标签分为起始和结束标签（不能省略），一个标签有如下几种书写形式

    ---- 包含标签主体:    some content

    ----不含标签主体：

            一个标签中可以嵌套若干个子标签，但所有标签必须合理的嵌套，不允许有交叉嵌套

    ----      错误 

            一个XML文档必须有且仅有一个根标签。其他标签都是这个根标签的子标签或孙标签

            

    属性：

            一个元素可以有多个属性，每个属性都有它自己的名称和取值，例如：

            属性值一定要用引号“单引号或双引号”引用起来

            元素中的属性是不允许重复的

            在XML技术中，标签属性所代表的信息也可以用子元素的形式来描述。

        语法格式如下：

    <tagName attribute1="value1" attribute2="value2"......>tagData</tagName>

    注释:

            XML 注释的语法格式：

           注意点：XML声明前不能有注释，也就是第一行之前不能有注释，否则报错

                         注释不能嵌套

    2.3 XML实例

    demo.xml代码如下：

    1. "1.0" encoding="utf-8"?>   
    2. <resources> 
    3.     这里是资源文本
    4.  
    5.     
    6.     <color value="#FF0000" name="红色">color>
    7.  
    8.     
    9.     <color value="#00FF00" name="绿色"/>
    10. resources>

    代码解读：

             第一行为文档声明

             为根元素   

            为子元素，其内部有2个属性 value 和 name 

            

    第二个xml例子： 标签属性所代表的信息也可以用子元素的形式来描述，比如name 和age 就是用子元素形式表示的，但是不提倡这么写，这样子在解析的时候，代码就会比较难写。推荐上面的那种写法。

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <students>
    3.     <person id="1111">
    4.         <name>李四</name>   <!--标签属性所代表的信息也可以用子元素的形式来描述-->
    5.         <age>30</age>
    6.     </person>
    7.  
    8.     <person id="2222" name="张三" age="20"></person >
    9.  
    10.     <person id="3333" name="王五" age="10"/>
    11. </students>

    第一行  就是XML声明，当前面版本号为1， 使用的是UTF-8编码

     students 为根元素： 文件体的最顶层元素称为根元素，根元素只能有一对，其名字可以自定义。所有其他元素均以子元素的形式存在于根元素内。子元素是可以重复出现的。

    子元素： person

    上面的xml中 子元素 person，定义了三个属性值 id   name  age  上面的三种写法都是等价的

    好了，理解上面xml各标签的定义后，接下来开始解析内容。

    3. XmlPullPaser 解析

    先看看第一个Demo：

    1.  import java.io.IOException;
    2.  import java.io.StringReader;
    3.  
    4.  import org.xmlpull.v1.XmlPullParser;
    5.  import org.xmlpull.v1.XmlPullParserException;
    6.  import org.xmlpull.v1.XmlPullParserFactory;
    7.  
    8.  public class SimpleXmlPullApp
    9.  {
    10.  
    11.      public static void main (String args[])
    12.          throws XmlPullParserException, IOException
    13.      {
    14.          XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    15.          factory.setNamespaceAware(true);
    16.          XmlPullParser xpp = factory.newPullParser();
    17.  
    18.          xpp.setInput( new StringReader ( "Hello World!" ) );
    19.          int eventType = xpp.getEventType();
    20.          while (eventType != XmlPullParser.END_DOCUMENT) {
    21.           if(eventType == XmlPullParser.START_DOCUMENT) {
    22.               System.out.println("Start document");
    23.           } else if(eventType == XmlPullParser.START_TAG) {
    24.               System.out.println("Start tag "+xpp.getName());
    25.           } else if(eventType == XmlPullParser.END_TAG) {
    26.               System.out.println("End tag "+xpp.getName());
    27.           } else if(eventType == XmlPullParser.TEXT) {
    28.               System.out.println("Text "+xpp.getText());
    29.           }
    30.           eventType = xpp.next();
    31.          }
    32.          System.out.println("End document");
    33.      }
    34.  }

    终端输出如下：

    1.  Start document
    2.  Start tag foo
    3.  Text Hello World!
    4.  End tag foo
    5.  End document

    代码解读：

    eventType 有五种解析类型：

    int值事件名事件定义
    0START_DOCUMENT开始读取文档
    1END_DOCUMENT结束文档
    2START_TAG读取标签
    3END_TAG结束标签
    4TEXT标签中的数据内容

    然后根据获取标签数值，做对应的逻辑处理，xmlpullparser是一行一行的从上到下解析文件的。

    XmlPullParser相关的API

    方法说明
    getEventType()

    获取当前解析的事件类型，有5种：START_DOCUMENT 

    END_DOCUMENT   

    START_TAG

    END_TAG

    TEXT

    getName()
    		获取元素的标签名  在 START_TAG事件中使用
    getText()获取文本内容， 在TEXT 事件中使用
    getAttributeValue(String namespace,
                                String name);
    		类似于通过key值来获取value值， 第一个参数为default值， 第二个参数为 key   返回：一个字符串

    如果上个例子不是很明白，我们接下来继续这个Demo：

    1. public class MainActivity extends AppCompatActivity {
    2.  
    3.     @Override
    4.     protected void onCreate(Bundle savedInstanceState) {
    5.         super.onCreate(savedInstanceState);
    6.         setContentView(R.layout.activity_main);
    7.  
    8.         try {
    9.             //解析本地assets下的 xml资源文件
    10.             parserAssetXml();
    11.         } catch (XmlPullParserException e) {
    12.             e.printStackTrace();
    13.         } catch (IOException e) {
    14.             e.printStackTrace();
    15.         }
    16.     }
    17.  
    18.     private void parserAssetXml()throws XmlPullParserException, IOException {
    19.         //获取XmlPullParserFactory实例
    20.         XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    21.         //通过XmlPullParserFactory 来获取 xmlPullParser对象
    22.         XmlPullParser pullParser = factory.newPullParser();
    23.  
    24.         //通过此API来获取输入流，作为pullParser的参数
    25.         InputStream inputStream = getAssets().open("demo.xml");
    26.  
    27.         //pullParser.setInput(输入流,"编码类型");
    28.         pullParser.setInput(inputStream, "UTF-8");
    29.  
    30.         //获取解析的类型, eventType有五种类型：START_DOCUMENT  END_DOCUMENT  START_TAG  END_TAG  TEXT
    31.         int eventType = pullParser.getEventType();
    32.         Log.e("test", "=====第一次打印的eventType值为 ：" + eventType);
    33.  
    34.         // 开始解析
    35.         while (eventType != XmlPullParser.END_DOCUMENT) {
    36.             eventType = pullParser.getEventType();
    37.             Log.e("test", "=====解析过程中eventType值为 ：" + eventType);
    38.             switch (eventType) {
    39.                 case XmlPullParser.START_DOCUMENT:
    40.                     Log.e("test", "=====这里是文档声明====1.0\" encoding=\"UTF-8\"?>====");
    41.                     break;
    42.  
    43.                 case XmlPullParser.START_TAG:
    44.                     String tagName = pullParser.getName();
    45.                     Log.e("test", "=====解析过程中tagName值为 ：" + tagName);
    46.                     //如果 子元素的tagName为 color，就开始打印其内容
    47.                     if (tagName != null && tagName.equals("color")) {
    48.                         String colorValue = pullParser.getAttributeValue("", "value");
    49.                         Log.e("test", "=====解析过程中colorValue值为 ：" + colorValue);
    50.                         String colorName = pullParser.getAttributeValue("", "name");
    51.                         Log.e("test", "=====解析过程中colorName值为 ：" + colorName);
    52.                     }
    53.                     break;
    54.  
    55.                 case XmlPullParser.END_TAG:
    56.                     Log.e("test", "====这里是元素的结束标签==="+pullParser.getName());
    57.                     break;
    58.  
    59.                 case XmlPullParser.TEXT:
    60.                     Log.e("test", "====解析文本内容==="+pullParser.getText());
    61.                     break;
    62.                 default:
    63.                     break;
    64.  
    65.  
    66.             }
    67.             //继续解析下一个子元素
    68.             eventType = pullParser.next();
    69.         }
    70.     }
    71. }

    注意Android studio工程中的assets的资源路径，不要放错位置了，否则会提示资源找不到

    打印log内容如下：

    1. 17:30:33.903 29787 29787 E test    : =====第一次打印的eventType值为 ：0 
    2.  
    3. 17:30:33.903 29787 29787 E test    : =====解析过程中eventType值为 ：0 
    4. 17:30:33.903 29787 29787 E test    : =====这里是文档声明====<?xml version="1.0" encoding="UTF-8"?>====
    5. 17:30:33.903 29787 29787 E test    : =====解析过程中eventType值为 ：2
    6. 17:30:33.903 29787 29787 E test    : =====解析过程中tagName值为 ：resources
    7. 17:30:33.903 29787 29787 E test    : =====解析过程中eventType值为 ：4
    8. 17:30:33.903 29787 29787 E test    : ====解析文本内容===
    9. 17:30:33.903 29787 29787 E test    :     这里是资源文本
    10. 17:30:33.903 29787 29787 E test    :
    11. 17:30:33.903 29787 29787 E test    :
    12. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：2
    13. 17:30:33.904 29787 29787 E test    : =====解析过程中tagName值为 ：color
    14. 17:30:33.904 29787 29787 E test    : =====解析过程中colorValue值为 ：#FF0000
    15. 17:30:33.904 29787 29787 E test    : =====解析过程中colorName值为 ：红色
    16. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：3
    17. 17:30:33.904 29787 29787 E test    : ====这里是元素的结束标签===color
    18. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：4
    19. 17:30:33.904 29787 29787 E test    : ====解析文本内容===
    20. 17:30:33.904 29787 29787 E test    :
    21. 17:30:33.904 29787 29787 E test    :
    22. 17:30:33.904 29787 29787 E test    :
    23. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：2
    24. 17:30:33.904 29787 29787 E test    : =====解析过程中tagName值为 ：color
    25. 17:30:33.904 29787 29787 E test    : =====解析过程中colorValue值为 ：#00FF00
    26. 17:30:33.904 29787 29787 E test    : =====解析过程中colorName值为 ：绿色
    27. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：3
    28. 17:30:33.904 29787 29787 E test    : ====这里是元素的结束标签===color
    29. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：4
    30. 17:30:33.904 29787 29787 E test    : ====解析文本内容===
    31. 17:30:33.904 29787 29787 E test    : =====解析过程中eventType值为 ：3
    32. 17:30:33.904 29787 29787 E test    : ====这里是元素的结束标签===resources

    把代码结合log一起看：

    其中 0 表示 START_DOCUMENT ，开始解析文档

    每次解析一个元素的标签时，事件类型为2  START_TAG，

    接下来都会走 打印 4   TEXT ， 你从log中看出，只有第一次解析根元素resources标签时打印了“

    这里是资源文本       接下来解析子元素color时，打印都是为空  这是为什么？

     接下来打印 3  END_TAG 事件  这个元素就解析完毕

    接下来就 调用 next()方法，继续解析下一个元素，重复打印 2   3   4事件。

    好了，我们回答上面提出的问题？解释如下：

    就是不管你有没有在 元素的标签后面添加文本内容，代码解析的时候都会走4  TEXT事件。

    而且test.xml 文件你用浏览器查看的时候也是ok的，说明格式是正确的，如下：

     好了，到这里，我们就把解析流程梳理完成了。 把这些理解清楚后，我们可以看看PMS中解析AndroidManifest.xml的代码片段，后续会在framework中的文章中会介绍，这里先提前说明一下

     4. PMS源码片段

    在PackageParser.java中，有解析AndroidManifest.xml的片段代码，如下：

    1.  private boolean parseSplitApplication(Package owner, Resources res, XmlResourceParser parser,
    2.             int flags, int splitIndex, String[] outError)
    3.             throws XmlPullParserException, IOException {
    4.         TypedArray sa = res.obtainAttributes(parser,
    5.                 com.android.internal.R.styleable.AndroidManifestApplication);
    6.  
    7.         if (sa.getBoolean(
    8.                 com.android.internal.R.styleable.AndroidManifestApplication_hasCode, true)) {
    9.             owner.splitFlags[splitIndex] |= ApplicationInfo.FLAG_HAS_CODE;
    10.         }
    11.  
    12.         final String classLoaderName = sa.getString(
    13.                 com.android.internal.R.styleable.AndroidManifestApplication_classLoader);
    14.         if (classLoaderName == null || ClassLoaderFactory.isValidClassLoaderName(classLoaderName)) {
    15.             owner.applicationInfo.splitClassLoaderNames[splitIndex] = classLoaderName;
    16.         } else {
    17.             outError[0] = "Invalid class loader name: " + classLoaderName;
    18.             mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
    19.             return false;
    20.         }
    21.  
    22.         final int innerDepth = parser.getDepth();
    23.         int type;
    24.         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
    25.                 && (type != XmlPullParser.END_TAG || parser.getDepth() > innerDepth)) {
    26.             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
    27.                 continue;
    28.             }
    29.  
    30.             ComponentInfo parsedComponent = null;
    31.  
    32.             // IMPORTANT: These must only be cached for a single <application> to avoid components
    33.             // getting added to the wrong package.
    34.             final CachedComponentArgs cachedArgs = new CachedComponentArgs();
    35.             String tagName = parser.getName();
    36. //解析清单文件中的activity信息
    37.             if (tagName.equals("activity")) {
    38.                 Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs, false,
    39.                         owner.baseHardwareAccelerated);
    40.                 if (a == null) {
    41.                     mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
    42.                     return false;
    43.                 }
    44.  
    45.                 owner.activities.add(a);
    46.                 parsedComponent = a.info;
    47. //解析清单文件中的广播信息
    48.             } else if (tagName.equals("receiver")) {
    49.                 Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs,
    50.                         true, false);
    51.                 if (a == null) {
    52.                     mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
    53.                     return false;
    54.                 }
    55.  
    56.                 owner.receivers.add(a);
    57.                 parsedComponent = a.info;
    58. //解析清单文件中的服务信息
    59.             } else if (tagName.equals("service")) {
    60.                 Service s = parseService(owner, res, parser, flags, outError, cachedArgs);
    61.                 if (s == null) {
    62.                     mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
    63.                     return false;
    64.                 }
    65.  
    66.                 owner.services.add(s);
    67.                 parsedComponent = s.info;
    68.  
    69.             } else if (tagName.equals("provider")) {
    70.                 Provider p = parseProvider(owner, res, parser, flags, outError, cachedArgs);
    71.                 if (p == null) {
    72.                     mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
    73.                     return false;
    74.                 }
    75.  
    76.                 owner.providers.add(p);
    77.                 parsedComponent = p.info;
    78.  
    79.             }

  • 相关阅读:
    【C++练级之路】【Lv.22】C++11——右值引用和移动语义
    SpringMVC之前端增删改查实现
    【Java----String类详解】
    Golang 数组基础
    七、函数-存储过程-触发器
    React原理
    寒假训练——第一周（二分）
    华为数通方向HCIP-DataCom H12-831题库(单选题：281-300）
    Java设计模式之解释器模式
    【物理应用】基于matlab GUI气象参数计算综合指标和IAQI【含Matlab源码 2116期】
  • 原文地址：https://blog.csdn.net/u012514113/article/details/126807779