xml

2019独角兽企业重金招聘Python工程师标准>>>

1. 通过Dom4j解析XML文档

 

 

 

1. xml基本使用

 

1. 1. XML简介 (*****了解*****)

 

XML全称为Extensible Markup Language，意思是可扩展的标记语言。

标记 -> 用标记来修饰文本信息.

可扩展 -> 标记可随意定义.

 

XML技术 : 与数据相关技术, 在企业中xml技术常用来存储数据和传输数据, xml之所以流行的原因在于xml语言与任何编程语言无关, xml可用于 php, java, .net任何编程语言.

 

xml 语言就是使用标签来标记数据.

 

XML 技术主要企业应用 :

1. 存储和传输数据.
2. 作为框架的配置文件.

 

 

 

 

1.2 如何去写一个XML (*****重点*****)

XML的编写 : 根据实际的业务场景自行编写`有意义`的标签和属性，创建一个以.xml为后缀名的文件，编写描述一个网上商城的商品信息的xml.

 

 

 

 

 

xml编写时也要符合一定的规则：

1. xml文件的后缀名是.xml
2. xml有且只有一个根标签
3. xml的标签是尖括号包裹关键字成对出现的，有开始标签有结束标签，关键字是自定义的, xml也可以有空标签/自关闭标签
4. xml允许有属性，属性也是根据需要自定义的，属性格式：属性名=“属性值”，多个属性之间使用空格隔开
5. xml是区分大小写的

 

product.xml

 

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <store>
3.        <product category="手机数码">
4.               <pid>100</pid>
5.               <pname>华为手机</pname>
6.               <price>300</price>
7.        </product>
8.        <product category="电脑办公">
9.               <pid>200</pid>
10.               <pname>三星笔记本</pname>
11.               <price>5000</price>
12.        </product>
13.        <product category="大型家电">
14.               <pid>300</pid>
15.               <pname>海尔洗衣机</pname>
16.               <price>4000</price>
17.        </product>
18. </store>

 

 

xml的组成：

1. 文档声明：
2. 根标签，例如：<store>
3. 其他标签，例如：<pname>
4. 属性，例如：
5. 文本，例如：
6. 注释，例如：

 

 

1.3 转义字符 (*****了解*****)

1. 转义字符 (语法规则)

因为很多符号已经被XML文档结构所使用，所以在元素体或属性值中想使用这些符号就必须使用转义字符，例如：“<”、“>”、“’”、“””、“&”。

      

 

exam.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <exams>
3.        <exam>
4.               <subject>测试Java基础</subject>
5.               <category>判断题</category>
6.               <question>&lt;活着&gt;书籍是否为Java高级程序员必读书籍?</question>
7.        </exam>
8. </exams>

 

 

 

1.4 CDATA区 (*****了解*****)

所有 XML 文档中的文本均会被解析器解析,只有 CDATA 区段（CDATA section）中的文本会被解析器忽略。

1. CDATA区             Character Data 字符数据

<![CDATA[

    任意内容

]]>

 

在编写XML文件时, 有些内容可能不想让解析引擎解析执行, 而是当做原始内容处理.

遇到这种情况, 可以把这些内容放在CDATA 区里, 对于CDATA区域内的内容, XML解析程序不会处理, 而是直接原封不动的输出.

 

当元素内容包含大量转义字符时，可读性下降。可以使用CDATA区原样存储，提高可读性。

 

        char c = 'a';

        if( c >= '0' && c <= '9'){

           System.out.println("找到：" + c);

        }else{

           System.out.println("没找到：" + c);

        }

 

转义字符 :

 

        char c = &apos;a&apos;;

        if( c &gt;=  &apos;0&apos; &amp;&amp; c &lt;= &apos;9&apos;){

           System.out.println(&quot;找到：&quot; + c);

        }else{

           System.out.println(&quot;没找到：&quot; + c);

        }

 

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <exams>
3.        <exam>
4.               <subject>测试Java基础</subject>
5.               <category>判断题</category>
6.               <question>&lt;活着&gt;书籍是否为Java高级程序员必读书籍?</question>
7.        </exam>
8.        <exam>
9.               <subject>测试Java基础</subject>
10.               <category>判断题</category>
11.               <question>
12.                     char c = &apos;a&apos;;
13.                     if( c &gt;=  &apos;0&apos; &amp;&amp; c &lt;= &apos;9&apos;){
14.                            System.out.println(&quot;找到：&quot; + c);
15.                     }else{
16.                            System.out.println(&quot;没找到：&quot; + c);
17.                     }
18.               </question>
19.        </exam><exam>
20.               <subject>测试Java基础</subject>
21.               <category>判断题</category>
22.               <question><![CDATA[
23.                     char c = 'a';
24.                     if( c >= '0' && c <= '9'){
25.                            System.out.println("找到：" + c);
26.                     }else{
27.                            System.out.println("没找到：" + c);
28.                     }
29.               ]]></question>
30.        </exam>
31. </exams>

 

 

 

 

 

 

 

1. 1. 如何去约束一个XML - DTD (*****了解*****)

 

 

提到约束一个XML，必须要理解为什么对XML要进行约束？

因为XML的标签都是自定义的，xml在作为框架配置时不能很好的规范开发者书写，所以要使用约束告知开发者怎去配置一个xml.

 

XML的约束有两种：

1. DTD约束

文档类型定义(Document Type Definition)是一套为了进行程序间的数据交换而建立的关于标记符的语法规则。它是标准通用标记语言和[1]  可扩展标记语言1.0版规格的一部分，文档可根据某种DTD语法规则验证格式是否符合此规则。

1. Schema约束

可扩展标记语言架构是以可扩展标记语言为基础的，它用于可替代文档类型定义（外语缩写： DTD）；一份XML schema文件描述了可扩展标记语言文档的结构。

 

1. 1. 1. xml文件内部引用DTD约束 :

(DTD简介)

说明 : 开发中，我们很少自己编写DTD约束文档，通常情况我们都是通过框架提供的DTD约束文档，编写对应的XML文档。

 

 

1. 内部DTD，在XML文档内部嵌入DTD，只对当前XML有效。

<?xml version="1.0" encoding="utf-8" ?>

<!DOCTYPE 根元素名 [

    ... //具体的语法

]>

 

 

CDATA -> Character Date 文本 / 字符数据                                      属性

PCDATA -> Parse Character Date 解析文本 / 字符数据                    元素

 

books.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!-- 内部 DTD 约束 -->
3. <!DOCTYPE books[
4.        <!ELEMENT books (book+)>
5.        <!ELEMENT book (name, price)>
6.        <!ELEMENT name (#PCDATA)>
7.        <!ELEMENT price (#PCDATA)>
8.        <!ATTLIST book author CDATA #REQUIRED>    <!-- #IMPLIED 可选 -->
9. ]>
10.  
11. <books>
12.        <book author="张三丰">
13.               <name>Java从入门到放弃</name>
14.               <price>998</price>
15.        </book>
16.        <book author="灭绝师太">
17.               <name>Java编程思想</name>
18.               <price>99</price>
19.        </book>
20. </books>

 

 

1. 1. 1. xml文件引用外部DTD约束 :

(DTD简介)

 

1. 外部DTD—本地DTD，DTD文档在本地系统上，公司内部自己项目使用。

<?xml version="1.0" encoding="utf-8" ?>

<!DOCTYPE 根元素名 SYSTEM "文件名.dtd">

 

books.dtd

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!ELEMENT books (book+)>
3. <!ELEMENT book (name, price)>
4. <!ELEMENT name (#PCDATA)>
5. <!ELEMENT price (#PCDATA)>
6. <!ATTLIST book author CDATA #REQUIRED>    <!-- #IMPLIED 可选 -->

 

 

books.xml

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!-- 引入外部 DTD 约束 -->
3. <!DOCTYPE books SYSTEM "books.dtd">
4. <books>
5.        <book author="张三丰">
6.               <name>Java从入门到放弃</name>
7.               <price>998</price>
8.        </book>
9.        <book author="灭绝师太">
10.               <name>Java编程思想</name>
11.               <price>99</price>
12.        </book>
13. </books>

 

 

 

 

1.5.3 xml文件引用公共DTD约束 :

1. 外部DTD—公共DTD，DTD文档在网络上，一般都由框架提供。

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE 根元素名 PUBLIC "-//SPRING//DTD BEAN 2.0//EN"

"http://www.springframework.org/dtd/spring-beans-2.0.dtd">

 

 

 

 

 

 

 

 

 

 

 

1. 1. 1. 课堂练习 : 针对给出的DTD约束,写出相应的xml文件

servlet.dtd

<?xml version="1.0" encoding="UTF-8"?>

<!ELEMENT servlets (servlet*, servlet-mapping*)>

<!ELEMENT servlet (servlet-name, servlet-class)>

<!ELEMENT servlet-name (#PCDATA)>

<!ELEMENT servlet-class (#PCDATA)>

<!ELEMENT servlet-mapping (servlet-name, url-pattern)>

<!ELEMENT url-pattern (#PCDATA)>

 

 

servlet.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE servlets SYSTEM "servlet.dtd">

<servlets>

    <servlet>

       <servlet-name>servlet1</servlet-name>

       <servlet-class>cn.itcast.MyServlet1</servlet-class>

    </servlet>

    <servlet>

       <servlet-name>servlet2</servlet-name>

       <servlet-class>cn.itcast.MyServlet2</servlet-class>

    </servlet>

    <servlet-mapping>

       <servlet-name>servlet1</servlet-name>

       <url-pattern>/s1</url-pattern>

    </servlet-mapping>

    <servlet-mapping>

       <servlet-name>servlet2</servlet-name>

       <url-pattern>/s2</url-pattern>

    </servlet-mapping>

</servlets>

 

 

 

 

 

1.6 如何去约束一个XML - Schema (*****了解*****)

与DTD一样，可以通过schema约束xml文档的编写规范。常见框架使用schema的有：Spring等

       通过提供“bean-schema.xsd”编写xml文档

 

XML Schema 简介 :

 

如何使用 XSD ? (XML Schema Difinition)

 

 

XSD - <schema> 元素

 

例如：我们要约束上述编写的books.xml,相应 的Schema约束如下

 

Schema中分为简单元素和复杂元素

简单元素和复杂元素指 的是xml中的标签是简单标签还是复杂标签

简单元素：标签仅仅包含文本标签体的元素

复杂元素：标签包括子标签或属性的元素

 

 

books.xsd

 

 

<?xml version="1.0" encoding="UTF-8"?>

<schema xmlns="http://www.w3.org/2001/XMLSchema"

    targetNamespace="http://www.example.org/book"

    xmlns:tns="http://www.example.org/book"

    elementFormDefault="qualified">

    <!-- 每一个元素对应一个element标签 -->

    <element name="books">

       <!-- 包含子元素或属性的元素被称为 `复杂元素` -->

       <complexType>

           <!-- 强调子元素出现的顺序 -->

           <sequence>

              <element name="book" minOccurs="1" maxOccurs="unbounded">

                  <complexType>

                     <sequence>

                         <!-- 对于拥有内容的元素, 需要编写 type 属性 -->

                         <element name="name" type="string"></element>

                         <element name="price" type="string"></element>

                     </sequence>

                  <!-- book 标签有 author 属性, 类型是字符串, 该属性必须填写 -->

                  <attribute name="author" type="string" use="required"></attribute>                 

                  </complexType>

              </element>       

           </sequence>

       </complexType>

    </element>

</schema>

 

books.xml

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <books xmlns="http://www.example.org/books"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xsi:schemaLocation="http://www.example.org/books books.xsd">
5.        <book author="张三丰">
6.               <name>Java从入门到放弃</name>
7.               <price>998</price>
8.        </book>
9.        <book author="灭绝师太">
10.               <name>Java编程思想</name>
11.               <price>99</price>
12.        </book>
13. </books>

 

 

1.6.2 练习 : 根据Schema约束编写xml文档

bean-schema.xsd

 

<?xml version="1.0" encoding="UTF-8"?>

<!--

    传智播客 Schema 教学实例文档 :

    模拟 spring 框架规范 : 如果开发人员需要在 xml 使用当前 schema 约束, 必须包含指定命名空间.

    格式如下 :

    <beans xmlns="http://www.example.org/bean-schema"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xsi:schemaLocation="http://www.example.org/bean-schema bean-schema.xsd">

 -->

 

<schema xmlns="http://www.w3.org/2001/XMLSchema"

    targetNamespace="http://www.example.org/bean-schema"

    xmlns:tns="http://www.example.org/bean-schema"

    elementFormDefault="qualified">

    <!-- 声明根标签 -->

    <element name="beans">

        <complexType>

            <sequence>

                <element name="bean" minOccurs="0" maxOccurs="unbounded">

                    <complexType>

                        <sequence>

                            <element name="property" minOccurs="0" maxOccurs="unbounded">

                                <complexType>

                                    <attribute name="name" type="string" use="required"></attribute>

                                    <attribute name="value" type="string" use="required"></attribute>

                                </complexType>

                            </element>

                        </sequence>

                        <attribute name="id" type="string" use="required"></attribute>

                        <attribute name="className" type="string" use="required"></attribute>

                    </complexType>

                </element>

            </sequence>

        </complexType>

    </element>

</schema>

 

 

 

bean.xml

 

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.itcast.cn/bean"
3.           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.           xsi:schemaLocation="http://www.itcast.cn/bean bean-schema.xsd"
5.        >
6.        <bean id="001" className="cn.itcast.User">
7.               <property name="userName" value="Jack"></property>
8.               <property name="password" value="123456"></property>
9.        </bean>
10.        <bean id="002" className="cn.itcast.User">
11.               <property name="userName" value="Peter"></property>
12.               <property name="password" value="654321"></property>
13.        </bean>
14. </beans>

 

 

 

 

 

 

1.7 XML解析概述 (*****了解*****)

XML的实际应用场景

实际开发中，我们一般会使用各种各样的框架进行企业开发，而这些框架一般都会将某些公共的功能都已经写好，我们需要做的只需要按照框架提供的约束进行框架的配置就可以了，当我们使用XML配置好框架后，再运行时，框架底层会解析我们配置XML文档获取有用的信息，从而根据我们的需求实现某些功能。

 

所以，实际开发中我们很少会自己编写XML约束和解析XML.

 

 

1.7.1 解析方式和解析器

1. 开发中比较常见的解析方式 (仅仅是思想) 有三种，如下：

1. DOM：要求解析器把整个XML文档装载到内存，并解析成一个Document对象。
   1. 优点：元素与元素之间保留结构关系，故可以进行增删改查操作。
   2. 缺点：XML文档过大，可能出现内存溢出现象。
2. SAX：是一种速度更快，更有效的方法。它逐行扫描文档，一边扫描一边解析。并以事件驱动的方式进行具体解析，每执行一行，都将触发对应的事件。
   1. 优点：处理速度快，可以处理大文件
   2. 缺点：只能读，逐行后将释放资源。
3. PULL：Android内置的XML解析方式，类似SAX。

 

1. 解析器：就是根据不同的解析方式的思想提供的具体实现代码。有的解析器操作过于繁琐，为了方便开发人员，又提供易于操作的解析开发包。

 

1. 常见的解析开发包：
   1. JAXP DOM：sun公司提供支持DOM和SAX开发包
   2. dom4j：比较常用的解析开发包，hibernate底层采用。      4 for     2 to 
   3. 其它开发包 : Jdom, Jsoup …

 

 

1.7.2 dom4j解析 (*****练习*****)

 

链接 : https://dom4j.github.io/

 

如果需要使用dom4j，必须导入jar包。

dom4j 必须使用核心类SaxReader加载xml文档获得Document，通过Document对象获得文档的根元素，然后就可以操作了。

常用API如下：

1. SaxReader对象
   1. read(…) 加载执行xml文档
2. Document对象
   1. getRootElement() 获得根元素
3. Element对象
   1. elements(…) 获得指定名称的所有子元素。可以不指定名称
   2. attributeValue(…) 获得指定属性名的属性值

 

 

 

1. package cn.itcast.dom4j;
2.  
3. import java.util.List;
4.  
5. import org.dom4j.Document;
6. import org.dom4j.Element;
7. import org.dom4j.io.SAXReader;
8.  
9. public class XMLDom4jDemo {
10.        public static void main(String[] args) throws Exception {
11.              
12.               /*
13.                * dom4j 工具类的使用 :
14.                *     核心类 :
15.                *     SAXReader 读取指定的 xml 文档, 生成一个 Document(接口) 对象.
16.                *     方法 : Document read("文档名称");
17.                *
18.                *     Document 文档对象, 解析 xml
19.                *     方法 : Element(标签元素对象) getRootElement() 获取根标签元素, 返回 Element 接口对象
20.                *    
21.                *     Element 标签元素对象
22.                *     方法 : List<Element> elements() 获取标签中的所有子标签
23.                */
24.              
25.               // 1. 创建一个 saxReader 对象
26.               SAXReader saxReader = new SAXReader();
27.              
28.               // 2. 将数据读取到 document 对象中
29.               Document document = saxReader.read("bean.xml");
30.              
31.               // 3. 使用 document 对象调用 getRootElement 方法获取根标签, 返回 Element 接口实现类对象
32.               Element rootElement = document.getRootElement();
33.              
34.               // 4. 在根据根标签对象调用 elements 方法获取子标签数组对象
35.               List<Element> beanElements = rootElement.elements();
36.              
37.               // 5. 遍历, 获取子标签
38.               for (Element beanElement : beanElements) {
39.                     // 5.2 获取 bean 标签中的两个属性值
40.                     String id = beanElement.attributeValue("id");
41.                     String className = beanElement.attributeValue("className");
42.                     System.out.println(id + " : " + className);
43.                    
44.                     // 5.3 再获取 bean 标签下的 property 标签
45.                     List<Element> propElements = beanElement.elements();
46.                     // 5.4 遍历, 获取子标签
47.                     for (Element propElement : propElements) {
48.                            String name = propElement.attributeValue("name");
49.                            String value = propElement.attributeValue("value");
50.                            System.out.println("\t" + name + " = " + value);
51.                     }
52.               }
53.        }
54. }

 

 

 

 

1.7.3 课堂练习 (解析xml数据)

 

servlet.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE servlets SYSTEM "servlet.dtd">

<servlets>

    <servlet>

       <servlet-name>servlet1</servlet-name>

       <servlet-class>cn.itcast.MyServlet1</servlet-class>

    </servlet>

    <servlet>

       <servlet-name>servlet2</servlet-name>

       <servlet-class>cn.itcast.MyServlet2</servlet-class>

    </servlet>

    <servlet-mapping>

       <servlet-name>servlet1</servlet-name>

       <url-pattern>/s1</url-pattern>

    </servlet-mapping>

    <servlet-mapping>

       <servlet-name>servlet2</servlet-name>

       <url-pattern>/s2</url-pattern>

    </servlet-mapping>

</servlets>

 

 

1. package cn.itcast.xml;
2.  
3. import java.util.List;
4.  
5. import org.dom4j.Document;
6. import org.dom4j.Element;
7. import org.dom4j.io.SAXReader;
8.  
9. public class ParseXMLDemo01 {
10.        public static void main(String[] args) throws Exception {
11.               // 1. 创建一个 saxReader 对象
12.               SAXReader saxReader = new SAXReader();
13.               // 2. 将数据读取到 document 对象中
14.               Document document = saxReader.read("servlet.xml");
15.               // 3. 使用 document 对象调用 getRootElement 方法获取根标签, 返回 Element 接口实现类对象
16.               Element rootElement = document.getRootElement();
17.               // 4. 使用 rootElement 根标签对象调用 elements 方法, 传入 servlet, 获取servlet标签对象
18.               List<Element> servletElements = rootElement.elements("servlet");
19.               // 5. 遍历, 并获取该标签下的子标签数据内容, 使用父标签对象调用elementText方法, 传入子标签名称获取数据
20.               for (Element servlet : servletElements) {
21.                     String name = servlet.elementText("servlet-name");
22.                     String cls = servlet.elementText("servlet-class");
23.                     System.out.println(name + " : " + cls);
24.               }
25.              
26.               // 使用 rootElement 根标签对象调用 elements 方法, 传入 servlet-mapping, 获取servlet-mapping标签对象
27.               List<Element> mappingElements = rootElement.elements("servlet-mapping");
28.               for (Element mapping : mappingElements) {
29.                     String name = mapping.elementText("servlet-name");
30.                     String url = mapping.elementText("url-pattern");
31.                     System.out.println(name + " = " + url);
32.               }
33.        }
34. }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/u/3892666/blog/2248998