Java 与 XML 相关

最新推荐文章于 2023-12-21 16:14:52 发布

jcpp9527

最新推荐文章于 2023-12-21 16:14:52 发布

阅读量356

点赞数

分类专栏： Spring源码解读

本文链接：https://blog.csdn.net/wqc19920906/article/details/82708194

版权

Spring源码解读专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文系摘抄再整理，来自http://www.w3school.com.cn/xml/xml_attributes.asp等

一、XML解析技术有两种

DOM方式

根据XML的层级结构在内存中分配一个树形结构,把XML的标签,属性和文本等元素都封装成树的节点对象

优点: 便于实现增删改查
缺点: XML文件过大可能造成内存溢出

SAX方式

采用事件驱动模型边读边解析:从上到下一行行解析,解析到某一元素, 调用相应解析方法

优点: 不会造成内存溢出,
缺点: 查询不方便,但不能实现增删改

不同的公司和组织提供了针对DOM和SAX两种方式的解析器

SUN的jaxp
Dom4j组织的dom4j(最常用:如Spring)
JDom组织的jdom

关于这三种解析器渊源可以百度下：java解析xml文件四种方式.

二、JAXP 解析 Javax.xml.parsers

JAXP是JavaSE的一部分,在javax.xml.parsers包下,分别针对dom与sax提供了如下解析器:

Dom

DocumentBuilder
DocumentBuilderFactory

SAX

SAXParser
SAXParserFactory

三、XML格结构

XML 文档形成了一种树结构，它从“根部”开始，然后扩展到“枝叶”

1、一个 XML 文档实例

XML 使用简单的具有自我描述性的语法：

<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>

第一行是 XML 声明。它定义 XML 的版本 (1.0) 和所使用的编码 (ISO-8859-1 = Latin-1/西欧字符集)。

下一行描述文档的根元素（像在说：“本文档是一个便签”）：

<note>

接下来 4 行描述根的 4 个子元素（to, from, heading 以及 body）：

<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>

最后一行定义根元素的结尾：

</note>

从本例可以设想，该 XML 文档包含了 John 给 George 的一张便签。

2、XML 文档形成一种树结构——DOM节点树

XML DOM 把 XML 文档视为一种树结构。这种树结构被称为节点树。

可通过这棵树访问所有节点。可以修改或删除它们的内容，也可以创建新的元素。

这颗节点树展示了节点的集合，以及它们之间的联系。这棵树从根节点开始，然后在树的最低层级向文本节点长出枝条。

XML 文档必须包含根节点(根元素)。该元素是所有其他元素的父元素。

XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。

所有元素均可拥有子元素：

<root>
  <child>
    <subchild>.....</subchild>
  </child>
</root>

父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。

所有元素均可拥有文本内容和属性（类似 HTML 中）。

实例

上图表示下面的 XML 中的一本书：

<bookstore>
<book category="COOKING" group="test01">
  <title lang="en">Everyday Italian</title> 
  <author>Giada De Laurentiis</author> 
  <year>2005</year> 
  <price>30.00</price> 
</book>
<book category="CHILDREN"  group="test01">
  <title lang="en">Harry Potter</title> 
  <author>J K. Rowling</author> 
  <year>2005</year> 
  <price>29.99</price> 
</book>
<book category="WEB" group="test01">
  <title lang="en">Learning XML</title> 
  <author>Erik T. Ray</author> 
  <year>2003</year> 
  <price>39.95</price> 
</book>
</bookstore>

例子中的根元素是 <bookstore>。文档中的所有 <book> 元素都被包含在 <bookstore> 中。

<book> 元素有 4 个子元素：<title>、< author>、<year>、<price>。

3、元素节点、属性节点、文本节点、文档节点区别

如果从一个xml文档来看，不太好区分什么这几个节点，这几个节点是从 " XML DOM 把 XML 文档视为一种树结构--节点树 " 来说的，只有转化为节点树，才有这几个节点的概念。

<bookstore>
<book category="COOKING" group="test01">
  <title lang="en">Everyday Italian</title> 
  <author>Giada De Laurentiis</author> 
  <year>2005</year> 
  <price>30.00</price> 
</book>
<book category="CHILDREN"  group="test01">
  <title lang="en">Harry Potter</title> 
  <author>J K. Rowling</author> 
  <year>2005</year> 
  <price>29.99</price> 
</book>
<book category="WEB" group="test01">
  <title lang="en">Learning XML</title> 
  <author>Erik T. Ray</author> 
  <year>2003</year> 
  <price>39.95</price> 
</book>
</bookstore>

（1）元素节点：一般是拥有一对开闭合标签的元素整体，例如下图中的<ul>...</ul>这一部分都属于一个元素节点。

（2）属性节点：一般是元素节点的属性，比如下图中的“宽度”属性也就是width="80 px"这一部分。

（3）文本节点：DOM中用于呈现文本的部分，如下图中的 “点我” 儿子，一般被包含在元素节点的开闭合标签内部。

节点信息

每个节点都拥有包含着关于节点某些信息的属性。这些属性是：
nodeName（节点名称）
nodeValue（节点值）
nodeType（节点类型）

4、节点与元素的区别：

Element是Node的扩展，除了Element之外，Attribute（属性）、Text（文本节点）、PI（处理指令）、 Document（文档）等等都是Node。
例如，用Element可以方便的获得Node的属性getAttribute(String attrName)
如果用Node，可以得到一个属性集，还要进一步检索才可得到想要的属性。

四、实例DEMO

1、xml文件：applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="myTestBean" class="com.wqc.bean.MyTestBean"/>

</beans>

2、TestParseDemo.java（打印出xml的内容，循环解析）

import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class TestParseDemo {

    public static void main(String[] args) {
        //File docFile = new File("src/main/resources/orders.xml");
        File docFile = new File("src/main/resources/applicationContext.xml");
        Document doc = null;
        Element root = null;
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);//名称空间支持，没有这个getNamespaceURI将会是null
        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            doc = db.parse(docFile);
            root = doc.getDocumentElement();
            //System.out.println(root.getNamespaceURI());
            int count = 0;
            parse(root, count);

        } catch (ParserConfigurationException pex) {
            System.out.println("解析配置错误：" + pex.getMessage());
        } catch (SAXException saex) {
            System.out.println("sax错误：" + saex.getMessage());
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
    
    static void parse(Element element, int count)
    {
        
        //System.out.println(count++);
        String nodeName = element.getNodeName();
        System.out.print("<" + nodeName);
        parseAttr(element);
        System.out.print(">");
 
        NodeList nodeList = element.getChildNodes();
        if (nodeList != null)
        {
            int length = nodeList.getLength();
            for (int i = 0; i < length; i++)
            {
                Node node = nodeList.item(i);
                short nodeType = node.getNodeType();
                if (nodeType == Node.ELEMENT_NODE)
                {
                    //System.out.println("ELEMENT_NODE--uri："+element.getNamespaceURI());
                    //递归
                    parse((Element) node, count);
                }
                else if (nodeType == Node.TEXT_NODE)
                {
                    //这里会读出\n\t,所以打印不用换行
                    System.out.print("TEXT_NODE："+node.getNodeValue());
                }
                else if (nodeType == Node.COMMENT_NODE)
                {
                    System.out.print("<!--" + node.getNodeValue() + "-->");
                }
                else if (nodeType == Node.ATTRIBUTE_NODE)
                {
                    System.out.println("ATTRIBUTE_NODE--uri："+element.getNamespaceURI());
                }
            }
        }
        System.out.print("</" + nodeName + ">");
    }
 
    static void parseAttr(Element element)
    {
        NamedNodeMap attrMap = element.getAttributes();
        if (attrMap != null && attrMap.getLength() > 0)
        {
            System.out.print(" ");
            int length = attrMap.getLength();
            for (int i = 0; i < length; i++)
            {
                Node attr = attrMap.item(i);
                String attrName = attr.getNodeName();
                String attrValue = attr.getNodeValue();
                if (i > 0)
                {
                    System.out.print(" ");
                }
                System.out.print(attrName + "=\"" + attrValue + "\"");
            }
        }
    }


}

输出结果：

3、DomNSTest.java 打印出NamespaceURL

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class DomNSTest {

    public static void printNSInfo(Node node){
         //System.out.println("Namespace Uri:"+node.getNamespaceURI());
         short type=node.getNodeType();
         switch(type){
         case Node.ELEMENT_NODE:
             if(node.getNamespaceURI()!=null){
                 System.out.println("Element Name:"+node.getNodeName());
                 System.out.println("Local Name:"+node.getLocalName());
                 System.out.println("Namespace Prefix:"+node.getPrefix());
                 System.out.println("Namespace Uri:"+node.getNamespaceURI());
                 System.out.println("---------------");
             }
             if(node.hasAttributes()){
                 NamedNodeMap map=node.getAttributes();
                 int len=map.getLength();
                 for (int i = 0; i < len; i++) {
                    Node attr=map.item(i);
                    if(attr.getNamespaceURI()!=null){
                        printNSInfo(attr);
                    }
                }
             }
             Node child=node.getFirstChild();
             System.out.println(child);
             while(child!=null)
                {
                    printNSInfo(child);
                    child=child.getNextSibling();
                }
            
             break;
         case Node.ATTRIBUTE_NODE:
             System.out.println("Attribute Name:"+node.getNodeName());
             System.out.println("Local Name:"+node.getLocalName());
             System.out.println("Namespace Prefix:"+node.getPrefix());
             System.out.println("Namespace Uri:"+node.getNamespaceURI());
             System.out.println("---------------");
             break;
         default:
             break;
         }
    }
    public static void main(String[] args) {
        File docFile = new File("src/main/resources/applicationContext.xml");
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);//名称空间支持
        try {
            DocumentBuilder builder=factory.newDocumentBuilder();
            Document doc=builder.parse(docFile);
            printNSInfo(doc.getDocumentElement());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

输出结果：

jcpp9527

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java 与 XML 相关

本文系摘抄再整理，来自http://www.w3school.com.cn/xml/xml_attributes.asp等一、XML解析技术有两种DOM方式根据XML的层级结构在内存中分配一个树形结构,把XML的标签,属性和文本等元素都封装成树的节点对象优点: 便于实现增删改查缺点: XML文件过大可能造成内存溢出SAX方式采用事件驱动模型边读边解析:从上到下一行行...
复制链接

扫一扫