xml小结

最新推荐文章于 2020-05-07 16:21:55 发布
转载 最新推荐文章于 2020-05-07 16:21:55 发布 · 856 阅读 · 2

本文介绍XML的基本概念，包括文档结构、约束验证方法如DTD和Schema，以及常用的解析技术DOM、SAX等。提供了详细的示例代码。

一、XML入门
1.XML概述
   XML(Extensible Markup Language):可扩展标记语言.
   XML和HTML都是标准通用标记语言(Standard Generalized Markup Language,SGML)的衍生语言.
   XML没有预定义标签.
   XML的应用：存储和传输复杂的关系模型数据
    在软件系统中，作为配置文件使用.
2.XML语法
   * 文档声明
       格式：<?xml version="1.0"?> 
       encoding:设置当前xml文档内容使用的编码.
       standalone:说明文档是否独立.
   * 元素
       格式：<x></x> 或者 <x />
       名称自定义:严格区分大小写，<P>和<p>是不同的标记
           不能以数字或"_"开头，建议以字母开头
           不能以xml或XML或Xml等开头
           不能包含空格，例<a b>
           不能包含冒号，例<a:b>
           注意：不能交叉嵌套
            有且仅有一个根标签.
   * 属性
         前提：在某元素的基础上，确定相应的属性.
         格式：<x attribute="attrValue" />
         注意：一个标签可以有多个属性，属性值要用双引号或单引号括起来.
   * 注释
         格式：<!--注释内容-->
   * CDATA区、特殊字符
         在xml文档中存放任意内容的区域
         格式：<![CDATA[ 存放的cdata内容，会以原样输出 ]]>
         转义字符：对于一些单个字符，若想显示原始样式，除了cdata也可以用转移的形式
         例如： 特殊字符   替代符号
              &  &amp;
              <  &lt;
              >  &gt;
              "  &quot;
              '  &apos;
            具体可查文档
   * 处理指令(processing instruction，PI)
         它是用来指挥解析引擎如何解析XML文档内容.
         处理指令必须以 <? 开头，以  ?> 作为结尾，XML声明语句就是最常见的一种处理指令.
         例如：引入css文件等
         格式：<?xml-stylesheet type="text/css" href="uri" ?>
        type:类型，内容是MIME类型，例 image/jpeg
        href:确定引用文件的位置
         uri:统一资源标识符 1.html  news/m.html
         url:统一资源定位符 http://www.fengjie.com/news/m.html
二、XML约束
1.概述
    XML约束：编写一个文档来约束一个xml文档的书写规范.
    常用的约束技术：    XML DTD(Document Type Definition)
                                     XML Schema
2.DTD约束
   （1）文档 关联
       * 内部关联
             即在xml文件内部书写DTD规范
             格式：<!DOCTYPE 根元素  [..具体规范内容..]>
       * 外部关联
             即引用的文件不在xml文件内部，而是在本地
             格式：在xml文件内写  <!DOCTYPE 根元素  SYSTEM "DTD文件的URL">
             例如：<!DOCTYPE books SYSTEM "book.dtd">
      * 公共关联
            即引用的文件不在本地
            格式：<DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文件的URL">
  （2）DTD约束语法
      * 元素
            格式：<!ELEMENT 元素名称  元素内容声明>
            注意：其中元素内容声明包含符号和数据类型两部分！
            符号：？ 0次或1次
                       *  >=0次
                       +  >=1次
                       ()  分组
                        |  选择
                       ,  顺序出现
            类型：#PCDATA 只能书写字符，不能包含子元素.注意书写格式：(#PCDATA)
                       EMPTY 元素内容为空
                      AND  元素内容任意
    * 属性
         格式：<!ATTLIST 元素名称
                         属性名  属性类型  约束
                         属性名  属性类型  约束
                          ...
                   >
         属性类型：CDATA  值为字符数据
                            ID  值为唯一的id
                            ()  选择
                          ..其他具体查看文档
        约束的四种形式：
             #REQUIRED  必须填写
             #IMPLIED  可选
             #FIXED value 固定值（value为自己设置的一个固定值）
             DefaultValue 默认值
   *实体（内部实体与外部实体，它们与关联方式无关）
    内部实体
        引用实体
             格式：<!ENTITY 实体名称  "实体内容">
             引用方式：&实体名称;  用在xml中
       参数实体
             格式：<!ENTITY % 实体名称  "实体内容">
             引用方式：%实体名称;  留给DTD文件本身使用的.
    外部实体
            格式：<!ENTITY 实体名称  SYSTEM "URI/URL">
            引用方式：&实体名称;  用在xml中
  （3）DTD约束代码示例

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <!-- 文档内部关联DTD --> 
  3. <!DOCTYPE NEWSPAPER [  
  4.  
  5. <!ELEMENT NEWSPAPER (ARTICLE+)> 
  6. <!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)> 
  7. <!ELEMENT HEADLINE (#PCDATA)> 
  8. <!ELEMENT BYLINE (#PCDATA)> 
  9. <!ELEMENT LEAD (#PCDATA)> 
  10. <!ELEMENT BODY (#PCDATA)> 
  11. <!ELEMENT NOTES (#PCDATA)> 
  12.   
  13. <!--#REQUIRED必须填写，#IMPLIED可以写可以不写--> 
  14. <!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED> 
  15. <!ATTLIST ARTICLE EDITOR CDATA #IMPLIED> 
  16. <!ATTLIST ARTICLE DATE CDATA #IMPLIED> 
  17. <!ATTLIST ARTICLE EDITION CDATA #IMPLIED> 
  18.  
  19. <!--引用实体，用于xml文档中--> 
  20. <!ENTITY NEWSPAPER "Vervet Logic Times"> 
  21. <!ENTITY PUBLISHER "Vervet Logic Press"> 
  22. <!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press"> 
  23.  
  24. ]> 
  25. <NEWSPAPER> 
  26.     <ARTICLE AUTHOR="&PUBLISHER;" DATE="9.15"> 
  27.         <HEADLINE>&NEWSPAPER;</HEADLINE> 
  28.         <BYLINE>science fiction film</BYLINE> 
  29.         <LEAD>...</LEAD> 
  30.         <BODY>the file is very good</BODY> 
  31.         <NOTES>©RIGHT;</NOTES> 
  32.     </ARTICLE> 
  33. </NEWSPAPER>  
			<?xml version="1.0" encoding="UTF-8"?>
			<!-- 文档内部关联DTD -->
			<!DOCTYPE NEWSPAPER [ 
			
			<!ELEMENT NEWSPAPER (ARTICLE+)>
			<!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)>
			<!ELEMENT HEADLINE (#PCDATA)>
			<!ELEMENT BYLINE (#PCDATA)>
			<!ELEMENT LEAD (#PCDATA)>
			<!ELEMENT BODY (#PCDATA)>
			<!ELEMENT NOTES (#PCDATA)>
			 
			<!--#REQUIRED必须填写，#IMPLIED可以写可以不写-->
			<!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED>
			<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>
			<!ATTLIST ARTICLE DATE CDATA #IMPLIED>
			<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>
			
			<!--引用实体，用于xml文档中-->
			<!ENTITY NEWSPAPER "Vervet Logic Times">
			<!ENTITY PUBLISHER "Vervet Logic Press">
			<!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press">
			
			]>
			<NEWSPAPER>
				<ARTICLE AUTHOR="&PUBLISHER;" DATE="9.15">
					<HEADLINE>&NEWSPAPER;</HEADLINE>
					<BYLINE>science fiction film</BYLINE>
					<LEAD>...</LEAD>
					<BODY>the file is very good</BODY>
					<NOTES>©RIGHT;</NOTES>
				</ARTICLE>
			</NEWSPAPER>

3.Schema约束
  （1）在XML文档中引用Schema

[html] view plain copy print ?
  1. <!--books.xsd内容如下：--> 
  2. <?xml version="1.0" encoding="UTF-8"?> 
  3. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  
  4.     targetNamespace="http://www.example.org/books"  
  5.     xmlns:tns="http://www.example.org/books"  
  6.     elementFormDefault="qualified"> 
  7.     ... 
  8.     ... 
  9. </xs:schema>  
			<!--books.xsd内容如下：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
				targetNamespace="http://www.example.org/books" 
				xmlns:tns="http://www.example.org/books" 
				elementFormDefault="qualified">
				...
				...
			</xs:schema>

   解释：* xmlns（xml namespace）
      应用已有的命名空间，http://www.w3.org/2001/XMLSchema
          官方为自己的schema文档起的名称
      格式1：xmlns：别名
        xmlns：xs
        使用:xs:schema,从当前别名xs所代表的schema文档中定义了schema元素
      格式2：xmlns（默认命名空间引用）
    * targetNamespace
      为当前的schema文档命名，必须全球唯一，采用URL的形式

[html] view plain copy print ?
  1. <!-- books.xml文档中的内容：--> 
  2. <?xml version="1.0" encoding="UTF-8"?> 
  3. <books  xmlns="http://www.example.org/books" 
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  5.     xsi:schemaLocation="http://www.example.org/books books.xsd"> 
  6. </books>  
			<!-- books.xml文档中的内容：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<books  xmlns="http://www.example.org/books"
				xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				xsi:schemaLocation="http://www.example.org/books books.xsd">
			</books>


   解释：* xmlns="http://www.example.org/books"
      确定需要的schema文档的名称  
    * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      将当前xml文档实例化，这样才能使用schemaLocation属性确定其位置
    * xsi:schemaLocation="http://www.example.org/books books.xsd"
      通知xml解析器，自己文档的名称和位置，用空格隔开
  （2）代码示例（引用w3c中的示例）

[html] view plain copy print ?
  1. <!-- shiporder.xml文档的内容：--> 
  2. <?xml version="1.0" encoding="UTF-8"?> 
  3. <shiporder orderid="889923" 
  4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  5. xsi:noNamespaceSchemaLocation="shiporder.xsd"> 
  6. <orderperson>George Bush</orderperson> 
  7. <shipto> 
  8.   <name>John Adams</name> 
  9.   <address>Oxford Street</address> 
  10.   <city>London</city> 
  11.   <country>UK</country> 
  12. </shipto> 
  13. <item> 
  14.   <title>Empire Burlesque</title> 
  15.   <note>Special Edition</note> 
  16.   <quantity>1</quantity> 
  17.   <price>10.90</price> 
  18. </item> 
  19. <item> 
  20.   <title>Hide your heart</title> 
  21.   <quantity>1</quantity> 
  22.   <price>9.90</price> 
  23. </item> 
  24. </shiporder> 
  25.  
  26. <!--schema文件内容：--> 
  27.  
  28. <?xml version="1.0" encoding="UTF-8"?> 
  29. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
  30.  
  31.     <!-- 简易元素的定义 --> 
  32.     <xs:element name="orderperson" type="xs:string" /> 
  33.     <xs:element name="name" type="xs:string" /> 
  34.     <xs:element name="address" type="xs:string" /> 
  35.     <xs:element name="city" type="xs:string" /> 
  36.     <xs:element name="country" type="xs:string" /> 
  37.     <xs:element name="title" type="xs:string" /> 
  38.     <xs:element name="note" type="xs:string" /> 
  39.     <xs:element name="quantity" type="xs:positiveInteger" /> 
  40.     <xs:element name="price" type="xs:decimal" /> 
  41.  
  42.     <!-- 属性的定义 --> 
  43.     <xs:attribute name="orderid" type="xs:string" /> 
  44.  
  45.     <!-- 复合元素的定义 --> 
  46.     <xs:element name="shipto"> 
  47.         <xs:complexType> 
  48.             <xs:sequence> 
  49.                 <xs:element ref="name" /> 
  50.                 <xs:element ref="address" /> 
  51.                 <xs:element ref="city" /> 
  52.                 <xs:element ref="country" /> 
  53.             </xs:sequence> 
  54.         </xs:complexType> 
  55.     </xs:element> 
  56.     <xs:element name="item"> 
  57.         <xs:complexType> 
  58.             <xs:sequence> 
  59.                 <xs:element ref="title" /> 
  60.                 <xs:element ref="note" minOccurs="0" /> 
  61.                 <xs:element ref="quantity" /> 
  62.                 <xs:element ref="price" /> 
  63.             </xs:sequence> 
  64.         </xs:complexType> 
  65.     </xs:element> 
  66.  
  67.     <xs:element name="shiporder"> 
  68.         <xs:complexType> 
  69.             <xs:sequence> 
  70.                 <xs:element ref="orderperson" /> 
  71.                 <xs:element ref="shipto" /> 
  72.                 <xs:element ref="item" maxOccurs="unbounded" /> 
  73.             </xs:sequence> 
  74.             <xs:attribute ref="orderid" use="required" /> 
  75.         </xs:complexType> 
  76.     </xs:element> 
  77.  
  78. </xs:schema>  
			<!-- shiporder.xml文档的内容：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<shiporder orderid="889923"
			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
			xsi:noNamespaceSchemaLocation="shiporder.xsd">
			 <orderperson>George Bush</orderperson>
			 <shipto>
			  <name>John Adams</name>
			  <address>Oxford Street</address>
			  <city>London</city>
			  <country>UK</country>
			 </shipto>
			 <item>
			  <title>Empire Burlesque</title>
			  <note>Special Edition</note>
			  <quantity>1</quantity>
			  <price>10.90</price>
			 </item>
			 <item>
			  <title>Hide your heart</title>
			  <quantity>1</quantity>
			  <price>9.90</price>
			 </item>
			</shiporder>
			
			<!--schema文件内容：-->
			
			<?xml version="1.0" encoding="UTF-8"?>
			<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
			
				<!-- 简易元素的定义 -->
				<xs:element name="orderperson" type="xs:string" />
				<xs:element name="name" type="xs:string" />
				<xs:element name="address" type="xs:string" />
				<xs:element name="city" type="xs:string" />
				<xs:element name="country" type="xs:string" />
				<xs:element name="title" type="xs:string" />
				<xs:element name="note" type="xs:string" />
				<xs:element name="quantity" type="xs:positiveInteger" />
				<xs:element name="price" type="xs:decimal" />
			
				<!-- 属性的定义 -->
				<xs:attribute name="orderid" type="xs:string" />
			
				<!-- 复合元素的定义 -->
				<xs:element name="shipto">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="name" />
							<xs:element ref="address" />
							<xs:element ref="city" />
							<xs:element ref="country" />
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="item">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="title" />
							<xs:element ref="note" minOccurs="0" />
							<xs:element ref="quantity" />
							<xs:element ref="price" />
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			
				<xs:element name="shiporder">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="orderperson" />
							<xs:element ref="shipto" />
							<xs:element ref="item" maxOccurs="unbounded" />
						</xs:sequence>
						<xs:attribute ref="orderid" use="required" />
					</xs:complexType>
				</xs:element>
			
			</xs:schema>

     
三、XML解析技术概述
1.XML解析方式
  dom:（Document Object Model,即文档对象模型）是W3C组织推荐的方式，但它是把整个文档对象放入内存，如果文档太大会导致溢出.
  sax:（Simple API for XML）不是官方标准，但它是xml社区事实上的标准，几乎所有的xml解析器都支持它，是事件驱动型，解决了可能的溢出问题，但只支持I操作.
2.XML解析器
  Crimson（sun）、Xerces（IBM）、Aelfred2（dom4j）
4.XML解析开发包
  Jaxp（sun）、Jdom、dom4j、pull（android的sdk自带）
  其中jaxp指（Java API for XML processing）
四、XML解析示例
     ----------------------
  声明：books.xml中的内容为：
  <?xml version="1.0" encoding="UTF-8"?>
  <books>
   <book id="001">
    <title>Java Core</title>
    <price>20</price>
   </book>
   <book id="002">
    <title>中文试一下</title>
    <price>30</price>
   </book>
  </books>
-----------------------
1.dom4j解析
注意：使用dom4j开发，需要下载dom4j相应的jar文件.
  如果其中用到XPath表达式，则需要导入jaxen-1.1-beta-6.jar.
  （1）IO操作
   I: SAXReader reader = new SAXReader();
    Document document = reader.read("file.xml"); 
   O: FileOutputStream fos = new FileOutputStream("file.dom4j.xml");
    XMLWriter writer = new XMLWriter();
    writer.write(document);
    writer.close();
  （2）获取Document的三种方式
   a:读取XML文件，获得document对象，上边的I操作.
   b:解析XML形式的文本，得到document对象.
    String text = "<books><book></book></books>";
    Document document = DocumentHelper.parseText(text);
   c:主动创建document对象.
    Document document = DocumentHelper.createDocument();
    //创建根节点 books(名字随意)
    Element root = document.addElement("books");
  （3）常用API
   * 获得根元素
    Element rootElement = document.getRootElement();
   * 获得所有的子元素
    List list = rootElement.elements();
   * 获得指定的子元素
    Element priceElement = bookElement.element("price");
   * 获得指定属性的元素(用到XPath表达式)
    Node bookNode = document.selectSingleNode("//book[@id='b002']");
   * 设置文本
    priceElement.setText("100");
   * 获得节点的名称
    child.getName();
   * 获得指定名称的属性值
    String id = bookElement.attributeValue("id");
   * 在某节点下添加子节点
    Element ageEle = bookElement.addElement("title");
   * 删除某节点(//childElement是待删除节点，parentElement是其父节点)
    parentElement.remove(childElement);
   * 获得某节点下的某属性
    Attribute attribute = rootElement.attribute("id");
   * 获得属性的文字
    String text = attribute.getText();
2.dom4j代码示例

[java] view plain copy print ?
  1. import java.io.FileOutputStream; 
  2.  
  3. import org.dom4j.Attribute; 
  4. import org.dom4j.Document; 
  5. import org.dom4j.DocumentHelper; 
  6. import org.dom4j.Element; 
  7. import org.dom4j.Node; 
  8. import org.dom4j.io.SAXReader; 
  9. import org.dom4j.io.XMLWriter; 
  10. //演示Dom4j中的CURD(create update read delete) 
  11. public class Demo { 
  12.  
  13.     public static void main(String[] args) throws Exception { 
  14.         //读取指定文件获取Document 
  15.         SAXReader reader = new SAXReader(); 
  16.         Document document = reader.read("books.xml"); 
  17.          
  18.         //create(document); 
  19.         //update(document); 
  20.         //delete(document); 
  21.          
  22.         //将文档写入XML文件 
  23.         FileOutputStream fos = new FileOutputStream("books.dom4j.xml"); 
  24.         XMLWriter writer = new XMLWriter(fos); 
  25.         writer.write(document); 
  26.         writer.close(); 
  27.     } 
  28.     public static void create(Document document) { 
  29.         Element rootElement = document.getRootElement();//获取根节点 
  30.         //添加id属性 
  31.         Element newBook = DocumentHelper.createElement("book");//创建新元素 
  32.         Attribute id = DocumentHelper.createAttribute(newBook, "id", "003"); 
  33.         newBook.add(id); 
  34.         //添加title元素 
  35.         Element newTitle = DocumentHelper.createElement("title"); 
  36.         newTitle.setText("News"); 
  37.         newBook.add(newTitle); 
  38.         //把创建的newBook添加进根节点 
  39.         rootElement.add(newBook); 
  40.     } 
  41.     public static void update(Document document) { 
  42.         //将id为002的book节点中的加个修改为444 
  43.         Node bookNode = document.selectSingleNode("//book[@id='002']");//XPath表达式 
  44.         Element bookElement = (Element)bookNode;//Node中没有适当方法，转换为Element 
  45.         Element priceElement = bookElement.element("price");//获取price元素 
  46.         priceElement.setText("444");//修改 
  47.     } 
  48.     public static void delete(Document document) { 
  49.         //删除id为001的book节点 
  50.         Node bookNode = document.selectSingleNode("//book[@id='001']"); 
  51.         Element parent = bookNode.getParent();//获取要删除元素的父级元素 
  52.         parent.remove(bookNode); 
  53.     } 
  54. }  
		import java.io.FileOutputStream;

		import org.dom4j.Attribute;
		import org.dom4j.Document;
		import org.dom4j.DocumentHelper;
		import org.dom4j.Element;
		import org.dom4j.Node;
		import org.dom4j.io.SAXReader;
		import org.dom4j.io.XMLWriter;
		//演示Dom4j中的CURD(create update read delete)
		public class Demo {
		
			public static void main(String[] args) throws Exception {
				//读取指定文件获取Document
				SAXReader reader = new SAXReader();
				Document document = reader.read("books.xml");
				
				//create(document);
				//update(document);
				//delete(document);
				
				//将文档写入XML文件
				FileOutputStream fos = new FileOutputStream("books.dom4j.xml");
				XMLWriter writer = new XMLWriter(fos);
				writer.write(document);
				writer.close();
			}
			public static void create(Document document) {
				Element rootElement = document.getRootElement();//获取根节点
				//添加id属性
				Element newBook = DocumentHelper.createElement("book");//创建新元素
				Attribute id = DocumentHelper.createAttribute(newBook, "id", "003");
				newBook.add(id);
				//添加title元素
				Element newTitle = DocumentHelper.createElement("title");
				newTitle.setText("News");
				newBook.add(newTitle);
				//把创建的newBook添加进根节点
				rootElement.add(newBook);
			}
			public static void update(Document document) {
				//将id为002的book节点中的加个修改为444
				Node bookNode = document.selectSingleNode("//book[@id='002']");//XPath表达式
				Element bookElement = (Element)bookNode;//Node中没有适当方法，转换为Element
				Element priceElement = bookElement.element("price");//获取price元素
				priceElement.setText("444");//修改
			}
			public static void delete(Document document) {
				//删除id为001的book节点
				Node bookNode = document.selectSingleNode("//book[@id='001']");
				Element parent = bookNode.getParent();//获取要删除元素的父级元素
				parent.remove(bookNode);
			}
		}

3.JAXP-DOM解析XML
  （1）IO操作
   I： DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document document = builder.parse("file.xml");
   O： TransformerFactory factory = TransformerFactory.newInstance();
    Transformer transformer = factory.newTransformer();
    //将document封装到Source
    Source xmlsource = new DOMSource(document);
    //将file.dom.xml路径封装到Result
    Result outputTarget = new StreamResult("file.dom.xml");
    transformer.transform(xmlSource, outputTarget);
  （2）常用API
   * 获取指定标签的所有元素
    NodeList bookElements = document.getElementsByTagName("book");
   * 获得上边NodeList的长度
    bookElements.getLength();
   * 获得指定索引的节点对象
    bookElements.item(index);
   * 获得当前元素的所有子节点
    NodeList childList = element.getChildNodes();//element为当前元素名称
   * 通过元素获得当前元素指定的属性
    element.getAttribute("id");//element为当前元素名称
   * 获得当前节点的名称
    node.getNodeName();//node为当前节点名称
   * 获得当前节点的子节点的所有文本
    node.getTextContent();
    例如：<book><title>Java</title></book> 获取book节点的子节点的所有文本
    结果:"<title>Java</title>"
   * 返回这个节点的第一个子节点
    getFirstChild();
   * 返回这个节点的父节点对象
    getParentNode();
   * 为这个节点添加一个子节点，并放在所有字节点的最后，如果这个子节点已经存在，则先把它删掉再添加进去.
    appendChild();
   * 删除给定的子节点对象
    removeChild();
  （3）DOM代码示例

[java] view plain copy print ?
  1. import javax.xml.parsers.DocumentBuilder; 
  2. import javax.xml.parsers.DocumentBuilderFactory; 
  3. import javax.xml.transform.Result; 
  4. import javax.xml.transform.Source; 
  5. import javax.xml.transform.Transformer; 
  6. import javax.xml.transform.TransformerFactory; 
  7. import javax.xml.transform.dom.DOMSource; 
  8. import javax.xml.transform.stream.StreamResult; 
  9. import org.w3c.dom.Document; 
  10. import org.w3c.dom.Element; 
  11. import org.w3c.dom.NodeList; 
  12.  
  13. public class Demo2 { 
  14.  
  15.     public static void main(String[] args) throws Exception { 
  16.         //获取document 
  17.         DocumentBuilderFactory factory1 = DocumentBuilderFactory.newInstance(); 
  18.         DocumentBuilder builder = factory1.newDocumentBuilder(); 
  19.         Document document = builder.parse("books.xml"); 
  20.          
  21.         //delete(document); 
  22.         //create(document); 
  23.          
  24.         //保存 
  25.         TransformerFactory factory2 = TransformerFactory.newInstance(); 
  26.         Transformer transformer = factory2.newTransformer(); 
  27.         Source xmlSource = new DOMSource(document); 
  28.         Result outputTarget = new StreamResult("books.jaxp.xml"); 
  29.         transformer.transform(xmlSource, outputTarget); 
  30.     } 
  31.     public static void create(Document document) { 
  32.         //新建元素 
  33.         Element newBook = document.createElement("book"); 
  34.         Element newTitle = document.createElement("title"); 
  35.         Element newPrice = document.createElement("price"); 
  36.         //设置元素内容或属性 
  37.         newTitle.setTextContent("Thinking in Java！"); 
  38.         newPrice.setTextContent("99"); 
  39.         newBook.setAttribute("id", "004"); 
  40.         //关联 
  41.         newBook.appendChild(newTitle); 
  42.         newBook.appendChild(newPrice); 
  43.         document.getDocumentElement().appendChild(newBook); 
  44.          
  45.     } 
  46.     public static void delete(Document document) { 
  47.         NodeList list = document.getElementsByTagName("book"); 
  48.         for(int i = 0; i < list.getLength(); i++) { 
  49.             //获取每一本书 
  50.             Element element = (Element)list.item(i); 
  51.             if("001".equals(element.getAttribute("id"))){ 
  52.                 //获取根节点，即book元素的父节点，用来删除book 
  53.                 Element rootElement = document.getDocumentElement(); 
  54.                 rootElement.removeChild(element); 
  55.             } 
  56.         } 
  57.     } 
  58. }  
			import javax.xml.parsers.DocumentBuilder;
			import javax.xml.parsers.DocumentBuilderFactory;
			import javax.xml.transform.Result;
			import javax.xml.transform.Source;
			import javax.xml.transform.Transformer;
			import javax.xml.transform.TransformerFactory;
			import javax.xml.transform.dom.DOMSource;
			import javax.xml.transform.stream.StreamResult;
			import org.w3c.dom.Document;
			import org.w3c.dom.Element;
			import org.w3c.dom.NodeList;
			
			public class Demo2 {
			
				public static void main(String[] args) throws Exception {
					//获取document
					DocumentBuilderFactory factory1 = DocumentBuilderFactory.newInstance();
					DocumentBuilder builder = factory1.newDocumentBuilder();
					Document document = builder.parse("books.xml");
					
					//delete(document);
					//create(document);
					
					//保存
					TransformerFactory factory2 = TransformerFactory.newInstance();
					Transformer transformer = factory2.newTransformer();
					Source xmlSource = new DOMSource(document);
					Result outputTarget = new StreamResult("books.jaxp.xml");
					transformer.transform(xmlSource, outputTarget);
				}
				public static void create(Document document) {
					//新建元素
					Element newBook = document.createElement("book");
					Element newTitle = document.createElement("title");
					Element newPrice = document.createElement("price");
					//设置元素内容或属性
					newTitle.setTextContent("Thinking in Java！");
					newPrice.setTextContent("99");
					newBook.setAttribute("id", "004");
					//关联
					newBook.appendChild(newTitle);
					newBook.appendChild(newPrice);
					document.getDocumentElement().appendChild(newBook);
					
				}
				public static void delete(Document document) {
					NodeList list = document.getElementsByTagName("book");
					for(int i = 0; i < list.getLength(); i++) {
						//获取每一本书
						Element element = (Element)list.item(i);
						if("001".equals(element.getAttribute("id"))){
							//获取根节点，即book元素的父节点，用来删除book
							Element rootElement = document.getDocumentElement();
							rootElement.removeChild(element);
						}
					}
				}
			}

4.JAXP-SAX解析XML
  （1）SAX解析概述
   SAX是事件驱动的XML处理方法，它逐行扫描文档，一边扫描一边解析.
   在I操作时会用到DefaultHandler类，需要定义自定义类继承此类，并实现需要的方法.
   DefaultHandler默认的是空实现.
  （2）SAX解析需要用到的方法
   * startDocument: 文档开始
   * startElement: 元素开始
    uri: 名称空间URI，如果元素没有则为空字符串.
    localName: 本地名称，如果没有名称空间，则为空字符串.
    qName： 限定的名称.
    attributes: 附加到元素的属性.
   * characters: 文本
    通过new String(ch, start, length)获得字符串.
   * endElement： 元素结束
   * endDocument: 文档结束
   还有很多方法，可以查看API文档，如果需要可以在自定义类中覆盖未实现的方法.
  
  （3）SAX解析的I操作代码示例

[java] view plain copy print ?
  1. import javax.xml.parsers.SAXParser; 
  2. import javax.xml.parsers.SAXParserFactory; 
  3. import org.xml.sax.helpers.DefaultHandler; 
  4.  
  5. public class Demo3 { 
  6.     public static void main(String[] args) throws Exception { 
  7.         SAXParserFactory factory = SAXParserFactory.newInstance(); 
  8.         SAXParser parser = factory.newSAXParser(); 
  9.         //这里需要编写自定义处理事件  
  10.         DefaultHandler dh = new MyDefaultHandler(); 
  11.         parser.parse("books.xml", dh); 
  12.     } 
  13. } 
  14. ------------------------- 
  15. //自定义类 
  16. import org.xml.sax.Attributes; 
  17. import org.xml.sax.SAXException; 
  18. import org.xml.sax.helpers.DefaultHandler; 
  19.  
  20. public class MyDefaultHandler extends DefaultHandler{ 
  21.      
  22.     @Override 
  23.     public void startDocument() throws SAXException { 
  24.         System.out.println("文档开始"); 
  25.     } 
  26.     @Override 
  27.     /**
  28.      * 如果xml文件使用了schema约束 <xs:element>
  29.      *   * uri:schema -- targetNameSpace  
  30.      *   * localName--element
  31.      *   * qName---xs:element
  32.      * 如果不使用
  33.      *   * uri:null
  34.      *   * localName:null
  35.      *   * qName : element
  36.      * Attributes:当前元素的所有的属性的集合
  37.      */ 
  38.     public void startElement(String uri, String localName, String qName, 
  39.             Attributes attributes) throws SAXException { 
  40.         System.out.println("元素开始" + qName + " *** " + attributes.getValue("id")); 
  41.     } 
  42.     @Override 
  43.     public void characters(char[] ch, int start, int length) 
  44.             throws SAXException { 
  45.         System.out.println(new String(ch ,start, length)); 
  46.     } 
  47.     @Override 
  48.     public void endElement(String uri, String localName, String qName) 
  49.             throws SAXException { 
  50.         System.out.println("元素结束：" + qName); 
  51.     } 
  52.     @Override 
  53.     public void endDocument() throws SAXException { 
  54.         System.out.println("文档结束"); 
  55.     } 
  56. }  
			import javax.xml.parsers.SAXParser;
			import javax.xml.parsers.SAXParserFactory;
			import org.xml.sax.helpers.DefaultHandler;
			
			public class Demo3 {
				public static void main(String[] args) throws Exception {
					SAXParserFactory factory = SAXParserFactory.newInstance();
					SAXParser parser = factory.newSAXParser();
					//这里需要编写自定义处理事件 
					DefaultHandler dh = new MyDefaultHandler();
					parser.parse("books.xml", dh);
				}
			}
			-------------------------
			//自定义类
			import org.xml.sax.Attributes;
			import org.xml.sax.SAXException;
			import org.xml.sax.helpers.DefaultHandler;
			
			public class MyDefaultHandler extends DefaultHandler{
				
				@Override
				public void startDocument() throws SAXException {
					System.out.println("文档开始");
				}
				@Override
				/**
				 * 如果xml文件使用了schema约束 <xs:element>
				 * 	 * uri:schema -- targetNameSpace   
				 *   * localName--element
				 *   * qName---xs:element
				 * 如果不使用
				 *   * uri:null
				 *   * localName:null
				 *   * qName : element
				 * Attributes:当前元素的所有的属性的集合
				 */
				public void startElement(String uri, String localName, String qName,
						Attributes attributes) throws SAXException {
					System.out.println("元素开始" + qName + " *** " + attributes.getValue("id"));
				}
				@Override
				public void characters(char[] ch, int start, int length)
						throws SAXException {
					System.out.println(new String(ch ,start, length));
				}
				@Override
				public void endElement(String uri, String localName, String qName)
						throws SAXException {
					System.out.println("元素结束：" + qName);
				}
				@Override
				public void endDocument() throws SAXException {
					System.out.println("文档结束");
				}
			}

 

原文地址：http://blog.youkuaiyun.com/wyply115/article/details/7990210


《XML》实验(1) -- XML Basics & DTD
04-27
[实验目的] 1、安装并学习如何使用XMLSPY集成开发环境完成XML相关的开发工作。 2、熟悉和掌握XML规范的基本内容，包括XML声明、注释、处理指令、元素、属性、CDATA段、预定义实体、命名空间的使用，以及如何进行XML文档良构和有效性验证；能够灵活地使用XML层次数据来表示各种信息。 3、掌握如何在DTD文档中声明元素及其内容模型、属性，以及实体的声明和使用；使用内部/外部DTD规则，对XML数据文档的有效性进行约束。 某软件学院XML课程实验答案
实验2XML文档及其DTD
11-29
XML网页设计使用教程 实验2XML文档及其DTD 一、实验目的 （1）理解XML和DTD文档之间的关系及使用DTD的重要性 （2）熟练掌握DTD中的元素、属性、实体和注记的声明方法
XML介绍之DTD约束语法详解五
lijizh1013的专栏
10-11 2127
7.DTD - 来自网络的实例 =========================================== 电视节目表 DTD 由 David Moisan 创造。拷贝自：http://www.davidmoisan.org/ ]>报纸文章 DTD 拷贝自：http://www.vervet.
【xml】DTD文档和内部DTD 实验三
韩旭051的博客
09-24 1433
外部DTD文档 不需要在外面再套一层 <!DOCTYPE NEWSPAPER[ ]> 这个了。直接这样写 <?xml version="1.0" encoding="UTF-8"?> <!ELEMENT NEWSPAPER (ARTICLE+)> <!ELEMENT ARTICLE (HEADLINE, BYLINE, LEAD, BODY, ...
xml-02-DTD约束
flaydog的博客
09-01 354
1.DTD简介 引用W3C的一段介绍：文档类型定义（DTD）可定义合法的XML文档构建模块。它使用一系列合法的元素来定义文档的结构。DTD 可被成行地声明于 XML 文档中，也可作为一个外部引用。这句话说白了就是用来规范xml的。xml是可扩展的标记语言，元素和属性都可以任意定义，没有任何的约束。这样在给了coder权利的同时也更容易犯错误。同时也造成了数据传输的不规范性。那么为了保证对
xml 小结2
05-28
在本文中，我们将对XML进行深入的小结，探讨它的基本概念、结构以及在IT领域的应用。 XML是一种自描述性的语言，这意味着每个XML文档都包含描述其结构的元数据。它通过使用标签来定义数据的含义，而不是它的外观。...
net操作xml小结
02-10
net操作xml小结
你所不知道的XML安全—XML攻击方法小结
01-30
XML可扩展标记语言，被设计用来传输和存储数据，其形式多样。某些在XML中被设计出来的特性，比如 XMLschemas(遵循XMLSchemas规范)和documentstypedefinitions(DTDs)都是安全问题来源。纵然被公开的讨论了上十年，...
JQuery解析XML的方法小结
01-19
本文实例总结了JQuery解析XML的方法。分享给大家供大家参考，具体如下： 用JavaScript解析XML数据是常见的编程任务，JavaScript能做的，JQuery当然也能做。下面我们来总结几个使用JQuery解析XML的例子。 第一种方案...
.net webapi接收xml格式数据的3种情况小结
01-20
前段时间接到一个任务写一个小接口，要接收java端返回过来的短信xml数据。 刚拿到项目，我的第一想法是对方会以什么形式发送xml格式的数据给我呢，设想三种情况。 我一开始拿到手上的是一串xml格式字符串。如下 &lt...
XML编程与应用教程课后习题答案
04-29
XML编程与应用教程课后习题答案
xml基于DTD的XML文档有效性验证
热门推荐
pshdhx的博客
03-14 1万+
实验工具：xmlspy2013、firefox；实验问题：1.分析下列XML实例，编写DTD文档，并进行验证。 &lt;?xml version=”1.0” encoding=”GB2312”&gt; &lt;学生名册&gt;  &lt;学生 学号="A"&gt;        &lt;姓名&gt;张三&lt;/姓名&gt;        &lt;性别&gt;男&lt;/性别
DTD的一点资料，不错，就拿来看看，学习学习
weixin_30667649的博客
07-24 365
DTD 概要 本教程已经向您讲解了如何描述 XML 文档的结构。 您学习到了如何使用 DTD 来定义一个 XML 文档的合法元素，以及如何在您的 XML 内部或者作为一个外部引用来声明 DTD。 您已经学习了如何为 XML 文档声明合法的元素、属性、实体以及 CDATA 部分。 您也看到了如何根据某个 DTD 来验证一个 XML 文档。 您已经学习了 DTD，下一步学习什么内容呢？ 下...
根据DTD实例约束写出xml文件
fighting_xuan的博客
05-07 3061
DTD约束标签 <!ELEMENT 元素名称 类别> 或<!ELEMENT 元素名称 (元素内容)> 类别：约束标签的内容 EMPTY：空标签 PCDATA：普通字符串（没有子标签） ANY ： 可以是任何内容（包含子标签） (元素内容)： 标签包含子标签的情况 顺序问题： (A,B,C...
基础篇verilog-‘timescale的解释
ciscomonkey的博客
11-02 5316
verilog-timescale解释 ’timescale 1ns/1ps 其中1ns代表步进，1ps代表精度，精度代表小数点后能够识别到的位数 #200.001 //代表200ns_1ps #200.0001 //编译将会报错
javaweb-day01-4（DTD 的语法）
程序员
01-27 434
XML 文件中 DOCTYPE 声明语句的格式： XML 文件使用 DOCTYPE 声明语句来指定它所遵循的 DTD 文件。 DOCTYPE声明语句有两种形式： 1.  当引用的约束文件在本地硬盘时，使用如下方式： 例如： 2.  当引用的约束文件是一个公共文件时，来自网上，使用如下方式： dtd的名称：如果一个网站公布了一个dtd的时候，那么它一定
浅谈XML语言(三)
知足常乐
09-05 793
这一篇来谈一谈XML的约束吧，毕竟XML这家伙太随意了，无法无天也不是很好，适当的约束起来，对于一个团队开发中还是有一定的必要的，按照一定的约束来，既能节省一定的时间，也能提高开发效率。 先谈一谈DTD吧，啥叫DTD呢，简而言之，就是文档类型定义，作用是定义 XML 文档的合法构建模块。 引用方式有两种，内部和外部，内部主要引用如下： 下面来一个例子： ]>
个人学习Schema引入约束遇到的问题
z289796216的博客
11-12 430
eclipe默认创建的xsd文件的内容 targetNamespace="http://www.example.org/NewXMLSchema"  xmlns:tns="http://www.example.org/NewXMLSchema"  elementFormDefault="qualified"> xmlns：表示这是一个约束文件 targetName
深入解析XML应用与结构小结
而文件列表中包含的“xml小结.docx”可能是对XML知识的总结文档，而“1.xml”和“1.xsd”则分别可能是用于示例的XML文件和XML模式定义（XML Schema）文件。 基于上述信息，我们可以从以下几个方面详细说明标题和...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值