xml文档概述

xml-不能描述页面的排版和表现形式，只是用于描述数据和数据结构。
　　格式要求：开始标签和结束标签必须配套。

　　　　　　　空元素标签采用（/）来关闭。

　　　　　　　标签区分大小写。

　　　　　　   合理嵌套。

　　　　　　　必须用双引号或单引号括起所有的属性。

　　　　　　　只能有一个根元素。

xml-文档声明
　　　　<?xml version="1.0" encoding="utf-8" standalone="no"?>
　　　　version-版本号是1.0，encoding-字符编码集， standalone-是否依赖于其他文档。no是不独立，需要依赖其他文档。

元素的内容：子元素，字符数据，字符引用，实体引用，CDATA段
　　　　字符数据：是不包括任何标记的起始定界符和CDATA段的结束定界符的任何字符串。字符数据中不能有&，<, ]]>.
　　　　5个特殊字符：可以通过字符引用的方式去用用
　　　　CDATA段：cdata段的内容不被xml处理器分析，可以包含任意的字符。可以包含java代码。

处理指令：用来指挥解析引擎如何解析xml文档内容，可以使用xml-stylesheet指令.<?xml-stylesheet type="text/css" href="~~.css"?>

处理空白：xml:space,通知程序保留此元素中的空白。值有default(对此元素使用默认空白处理模式)和preserve(保留所有的空白)属性

　　　　　<!ATTLIST peom xml:space (default|preserve)>

xml引用DTD:
　　　　内部：<!DOCTYPE 文档根元素名 [标记声明块]>
　　　　　　　　eg:<!DOCTYPE g[
　　　　　　　　　  <!ELEMENT g (#PCDATA)> //#PCDATA说明元素包含子元素
　　　　　　　　　　]>
　　　 当引用的文件在本地，<!DOCTYPE 文档根元素名 SYSTEM "DTD文件的URL"> SYSTEM表示的是私有的DTD文件，
         当引用的文件是一个公共文件时，<!DOCTYPE 文档根元素名 PUBLIC "dtd名称" "DTD文件的URL">

元素--即为标签
　　　　xml声明之前不能有注释，注释不能嵌套
　　　　cdata区：这里面的内容xml解析程序不会处理，而是直接原封不动的输出。<![CDATA[内容]]>
　　　　<![CDATA[
　　　　　　内容
　　　　]]>

xml-约束概述
常用的约束技术：xml DTD和xmlSchema

book.dtd
        <!ELEMENT 书架(书+)>
        <!ELEMENT 书(书名, 作者, 售价)>    //(书名, 作者, 售价)表示内容出现的顺序必须与声明的一致。(书名|作者| 售价)表示任选其一，即最多只能出现一个  (书名*, 作者?, 售价+) *?+表示元素出现的次数：+出现一次或多次，*0次或多次，？0次或一次
        <!ELEMENT 书名(#PCDATA)>
        <!ELEMENT 作者(#PCDATA)>
        <!ELEMENT 售价(#PCDATA)>
book.xml
        <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <书架>
        <书 name="dede">
            <书名 name="xxx">呜呜呜</书名>
            <作者>我问问</作者>
            <售价>99元</售价>
        </书>

        <书>
            <书名>呜呜呜</书名>
            <作者>我问问</作者>
            <售价>啊啊啊</售价>
        </书>
    </书架>

DTD结构：
　　　　在DTD文档中使用ELEMENT声明一个xml元素：<!ELEMENT 元素名 元素类型>
　　　　元素类型：可以是元素内容，或类型
　　　　元素内容：需要用()括起来，<!ELEMENT 书(书名, 作者, 售价)>

　　　　　　　　　　　　　　　　　<!ELEMENT 书名(#PCDATA)>
　　　　类型：EMPTY:用于定义空元素。ANY：表示元素内容为任意类型

属性定义：
　　　　<!ATTLIST 元素名
　　　　　　属性名1 属性值类型1 设置说明
　　　　>
设置说明：

　　　　#REQUIRED--必须设置该属性
　　　　#IMPLIED--可以设置也可以不设置
　　　　#FIXED--属性值为固定的值，在xml文件中不能为该属性设置其他值，但需要为该属性提供这个值
　　　　直接使用默认值：
属性值类型：CDATA:表示属性值为普通文本字符串
　　　　　　ENUMERATED:(枚举)
　　　　　　ID:表示属性的设置值为一个唯一值，只能由字母，下划线，不能有空白字符

ENTITY(实体)：在dtd中一条<!ENTITY 实体名 ”实体内容“>语句定义一个实体
引用实体：主要在xml文档中被应用，直接转变成实体内容。引用方式：&实体名称,就指向了“实体内容”
参数实体：被dtd文件自身使用。格式：<!ENTITY % 实体名称 “实体内容”> 引用方式：&实体名称

xml的名词空间：<元素名 xmlns:prefixname="url"> 元素名:指定那一个元素 prefixname：名词空间前缀<元素名 xmlns="url">

xml解析技术概述：dom，sax，jaxp
dom解释的优点，对文档的crud比较方便，缺点占用内存比较大
sax解析优点，占用内存比较小，对文档的crud不方便

调整jvm大小：右击.java程序，RUN AS ->run configeration->arguments->vim argumrnts配置为-Xmx80m

使用dom对xml的crud：

package cn.lcp.xml;

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

import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

//使用dom对xml的crud
public class Demo2 {
//读取
    @Test
    public void read() throws Exception{
        //创建工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //得到dom解析器
        DocumentBuilder builder = factory.newDocumentBuilder();
        //解析xml文档，得到代表文档的document
        Document document = builder.parse("src/book.xml");
        //取到书名标签相当于一个集合
        NodeList list = document.getElementsByTagName("书名");
        //拿到第一个为“书名”的结点
        Node node = list.item(0);
        //得到节点的文本内容
        String content = node.getTextContent();
        System.out.println(content);
    }

//读取遍历标签
    @Test
    public void read2() throws Exception{

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse("src/book.xml");
        //得到根节点 --因为只有一个跟节点
        Node root = document.getElementsByTagName("书架").item(0);
        list(root);
    }
    private void list(Node node) {
        if(node instanceof Element){
            System.out.println(node.getNodeName());
        }

        NodeList list = node.getChildNodes();
        for(int i = 0; i < list.getLength(); i ++){
            Node child = list.item(i);
            list(child);
        }
    }
//读取标签属性的值：
        @Test
        public void read3() throws Exception{

            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //得到根节点 --因为只有一个跟节点
            Element bookname = (Element) document.getElementsByTagName("书名").item(0);
            String value = bookname.getAttribute("name");
            System.out.println(value);
        }
//向xml文档添加节点：
        @Test
        public void add() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //创建节点
            Element price = document.createElement("售价");
            price.setTextContent("99元");
            //把创建的节点挂到第一本书上
            Element book = (Element) document.getElementsByTagName("书").item(0);
            book.appendChild(price);
        　　//把更新后的内容写回到xml文档
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }

//向xml文档添加节点--指定位置插入：
        @Test
        public void add2() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //创建节点
            Element price = document.createElement("售价");
            price.setTextContent("9元");
            //得到参考节点：
            Element refNode = (Element) document.getElementsByTagName("售价").item(0);
            //把创建的节点挂到第一本书上
            Element book = (Element) document.getElementsByTagName("书").item(0);
            //网book节点的指定位置插入值
            book.insertBefore(price, refNode);
        　　//把更新后的内容写回到xml文档
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }

//向xml文档添加节点的属性：
        @Test
        public void add3() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //创建节点
            Element price = document.createElement("售价");
            price.setTextContent("9元");
            //得到参考节点：
            Element bookname = (Element) document.getElementsByTagName("书").item(0);
            //网book节点的指定位置插入值
            bookname.setAttribute("name", "dede");;
        　　//把更新后的内容写回到xml文档
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }

//删除节点
        @Test
        public void del() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //得到要删除的节点
            Element e = (Element) document.getElementsByTagName("售价").item(0);
            //得到要删除节点的爸爸
            Element book = (Element) document.getElementsByTagName("书").item(0);
            //爸爸删儿子
            book.removeChild(e);
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }

//删除节点
        @Test
        public void del2() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");
            //得到要删除的节点
            Element e = (Element) document.getElementsByTagName("售价").item(0);
            e.getParentNode().removeChild(e);
            e.getParentNode().getParentNode().removeChild(e.getParentNode());
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }
//更新价格
        public void update() throws Exception{
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse("src/book.xml");

            Element e = (Element) document.getElementsByTagName("售价").item(0);
            e.setTextContent("144元");
            //创建工厂
            TransformerFactory tffactory = TransformerFactory.newInstance();
            //得到dom解析器
            Transformer tf = tffactory.newTransformer();
            tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream("src/book.xml")));
        }
}

xml例子--实现考生成绩管理系统

sax解析：解析器和事件处理器。
　　解析器可以创建jaxp的api创建。
　　//1.创建工厂
　　SAXParserFactory factory = SAXParserFactory.newInstance();
　　//2.得到解析器
　　SAXParser sp = factory.newSAXParser();
　　//3.得到读取器
　　XMLReader reader = sp.getXMLReader();
　　//4.设置内容处理器---自己重新创建一个class处理器。
　　reader.setContentHandler(new ListHandler());
　　//5.读取xml所有的内容
　　reader.parse("src/book.xml");

package cn.lcp.sax;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

public class Demo {

    /**
     * sax解析xml文档
     * @throws SAXException
     * @throws ParserConfigurationException
     * @throws IOException
     */
    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //1.创建工厂
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //2.得到解析器
        SAXParser sp = factory.newSAXParser();
        //3.得到读取器
        XMLReader reader = sp.getXMLReader();
        //4.设置内容处理器
        reader.setContentHandler(new ListHandler());
        //5.读取xml所有的内容
        reader.parse("src/book.xml");
    }
}

//得到xml的所有内容---内容处理器
class ListHandler implements ContentHandler{

    @Override
    public void setDocumentLocator(Locator locator) {
        // TODO Auto-generated method stub

    }

    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void startPrefixMapping(String prefix, String uri)
            throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void endPrefixMapping(String prefix) throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void startElement(String uri, String localName, String name,
            Attributes atts) throws SAXException {
        System.out.println("<" + name + ">");

        for(int i = 0; atts != null && i < atts.getLength(); i ++){
            String attName = atts.getQName(i);
            String attValue = atts.getValue(i);
            System.out.println(attName + "=" + attValue);
        }
    }

    @Override
    public void endElement(String uri, String localName, String name)
            throws SAXException {
        System.out.println("<" + name + ">");

    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        System.out.println(new String(ch, start, length));

    }

    @Override
    public void ignorableWhitespace(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void processingInstruction(String target, String data)
            throws SAXException {
        // TODO Auto-generated method stub

    }

    @Override
    public void skippedEntity(String name) throws SAXException {
        // TODO Auto-generated method stub
    }
}
//遍历指定的标签的值
package cn.lcp.sax;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

public class Demo {

    /**
     * sax解析xml文档
     * @throws SAXException
     * @throws ParserConfigurationException
     * @throws IOException
     */
    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //1.创建工厂
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //2.得到解析器
        SAXParser sp = factory.newSAXParser();
        //3.得到读取器
        XMLReader reader = sp.getXMLReader();
        //4.设置内容处理器
        reader.setContentHandler( new tagValueHandler());
        //5.读取xml所有的内容
        reader.parse("src/book.xml");
    }
}

//得到xml的指定标签的值---内容处理器
class tagValueHandler extends DefaultHandler{

    private String currentTag;   //记住当前解析到 的是什么标签
    private int needName = 2;    // 记住想获取第几个作者的标签
    private int currentNumber;   //当前解析到的第几个值

    @Override
    public void startElement(String uri, String localName, String name,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        currentTag = name;
        if(currentTag.equals("作者")){
            currentNumber ++;
        }
    }

    @Override
    public void endElement(String uri, String localName, String name)
            throws SAXException {
        // TODO Auto-generated method stub
        currentTag = name;
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        if("作者".equals(currentTag) && currentNumber == needName){
            System.out.println(new String(ch, start, length));
        }
    }
}

dom4j解析xml文档：

package cn.lcp.dom4j;

import java.io.File;
import java.io.FileOutputStream;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

public class Demo {

    @Test
    public void read() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        //获取根节点
        Element root = document.getRootElement();
        //得到第二本书的书名
        Element book = (Element) root.elements("书").get(1);
        String value = book.element("书名").getText();
        System.out.println(value);
    }

    @Test
    public void readAttr() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        //获取根节点
        Element root = document.getRootElement();
        //得到第二本书的name属性
        Element book = (Element) root.elements("书").get(1);
        String value = book.element("书名").attributeValue("name");
        System.out.println(value);
    }

    @Test//在第一本书上添加售价
    public void add() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        Element book = document.getRootElement().element("书");
        book.addElement("售价").setText("209元");

        //指定编码--格式化输出器
        //OutputFormat format = OutputFormat.createCompactFormat();
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");

       // XMLWriter writer = new XMLWriter(
       //       new OutputStreamWriter(new FileOutputStream("src/book.xml"), "gb2312"), format
       //
       //         );
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"), format);
            writer.write( document );
            writer.close();
    }

//第一本书指定位置上添加售价
    @Test
    public void add2() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        Element book = document.getRootElement().element("书");
        List list = book.elements();   //书名，作者，售价

        Element price = DocumentHelper.createElement("售价");
        price.setText("309元");
        list.add(2, price);

//指定编码--格式化输出器
        //OutputFormat format = OutputFormat.createCompactFormat();
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");

       // XMLWriter writer = new XMLWriter(
       //       new OutputStreamWriter(new FileOutputStream("src/book.xml"), "gb2312"), format
       //
       //         );
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"), format);
            writer.write( document );
            writer.close();
    }//删除节点
    @Test
    public void delete() throws Exception{

        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        Element price = document.getRootElement().element("书").element("售价");
        price.getParent().remove(price);

        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");

        XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"), format);
            writer.write( document );
            writer.close();
    }

    //更新节点
    @Test
    public void update() throws Exception{
        SAXReader reader = new SAXReader();
        Document document = reader.read(new File("src/book.xml"));

        Element book = (Element) document.getRootElement().elements("书").get(0);
        book.element("作者").setText("得得");

        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");

        XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"), format);
            writer.write( document );
            writer.close();
    }
}

xpath---快速直接定位

<?xml version="1.0" encoding="UTF-8"?>
<users>
<user id="1" name="aa" password="111"/>
<user id="2" name="bb" password="123"/>
</users>

//检验登录效果

@Test
public void denglu() throws Exception{
　　　　String name = "aa";
　　　　String password = "123";

　　　　SAXReader reader = new SAXReader();
　　　　Document document = reader.read(new File("src/users.xml"));

　　　　Node node = document.selectSingleNode("//user[@password=‘"+password+"‘ and @name=‘"+name+"‘]");
　　　　System.out.println(node);
　　　　if(node == null){
　　　　　　System.out.println("用户名或密码错误");
　　　　}else{
　　　　　　System.out.println("登录成功~~");
　　　　}
}

schema约束:扩展名为.xsd 称之为模式文档（约束文档）。

时间： 2024-11-05 22:55:18

xml文档概述的相关文章

文档对象模型操作xml文档

简介 :文档对象模型(DOM)是一种用于处理xml文档的API函数集. 2.1文档对象模型概述 按照W3C的定义,DOM是“一种允许程序或脚本动态地访问更新文档内容,结构和样式的.独立于平台和语言的规范化接口.DOM是表示文档(比如HTML和XML)和访问.操作构成文档的各种元素的应用程序接口,它以树状结构表示HTML和XML文档,定义了遍历这个树和检查.修改树的节点的方法和属性. DOM的核心API还允许你创建和填充文件.加载文档并保存. 2.2DOM实现 微软的net框架在Systemx.x

XML 文档和数据

.NET Framework 4.5 其他版本 .NET Framework 提供了一组全面而集成的类,可用来方便地生成可以识别 XML 的应用程序. 通过以下命名空间中的类,可以分析和编写 XML,编辑内存中的 XML 数据,进行数据验证以及 XSLT 转换. System.Xml System.Xml.XPath System.Xml.Xsl System.Xml.Schema System.Xml.Linq 有关完整列表,请参阅 System.Xml 命名空间网页. 这些命名空间中的类支持

【学习笔记】关于DOM4J：使用DOM4J解析XML文档

一.概述 DOM4J是一个易用的.开源的库,用于XML.XPath和XSLT中.采用了Java集合框架并完全支持DOM.SAX.和JAXP. DOM4J最大的特色是使用大量的接口,主要接口都在org.dom4j这个包里定义: 二.DOM4J的接口 Attribute:定义了XML的属性: Branch:是能够包含子节点的节点,如XML元素(Element)和文档(Documents)定义了一个公共的行为: CDATA:定义了XML的CDATA区域: CharacterData:是一个标识接口,标

关于XML文档的讲解

1        XML的概述 1.1 什么是XML XML全称为Extensible Markup Language,意思是可扩展的标记语言.XML语法上和HTML比较相似,但HTML中的元素是固定的,而XML的标签是可以由用户自定义的. W3C在1998年2月发布1.0版本,2004年2月又发布1.1版本,但因为1.1版本不能向下兼容1.0版本,所以1.1没有人用.同时,在2004年2月W3C又发布了1.0版本的第三版.我们要学习的还是1.0版本!!! 1.2 XML的应用场景 保存关系型数

XML文档类型定义---XML Schema结构

5.1 Schema概述 XML Schema是2001年5月正式发布的W3C的推荐标准,经过数年的大规模讨论和开发如今终于尘埃落定,成为全球公认的XML环境下首选的数据建模工具. 使用DTD虽然带来较大的方便,但是,DTD存在一些缺陷:一是它用不同于XML的语言编写,需要不同的分析器技术.这增加了工具开发商的负担,降低了软件瘦身的可能性,此外开发人员需要多学一门语言及其语法.而XML Schema是按标准XML规则编写的,更容易掌握.二是DTD不支持名称空间.随着大部分的数据处理日益以XML为

四种生成和解析XML文档的方法详解

众所周知,现在解析XML的方法越来越多,但主流的方法也就四种,即:DOM.SAX.JDOM和DOM4J 一.介绍及优缺点分析 1. DOM(Document Object Model) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准.DOM是以层次结构组织的节点或信息片断的集合.这个层次结构允许开发人员在树中寻找特定信息.分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作.由于它是基于信息层次的,因而DOM被认为是基于树或基于对象的. [优点]      ①允许应用

python+selenium自动化软件测试(第12章)：Python读写XML文档

XML 即可扩展标记语言,它可以用来标记数据.定义数据类型,是一种允许用户对自己的标记语言进 行定义的源语言.xml 有如下特征: 首先,它是有标签对组成:<aa></aa> 标签可以有属性: <aa id=’123’></aa> 标签对可以嵌入数据: <aa>abc</aa>Python对XML文档读写常用有几个模块: (1) xml.etree.ElementTree ElementTree就像一个轻量级的DOM,具有方便友好的A

解析简单xml文档

一.解析简单的xml文档 使用xml.etree.ElementTree 下的parse() xmlName.xml的文档的内容如下: <?xml version="1.0"?> <data> <country name="zhongguo"> <rank updated="yes">2</rank> <year >2017</year> <gdppc>

DTD验证XML文档

DTD验证XML文档        1.DTD简介:DTD是Document Type Definition的缩写,即文档定义            1.1:DTD的内容包含:                    元素定义规则                    元素之间的关系规则                    属性的定义规则            1.2:DTD的作用如下:                    DTD使每个XML文件可以携带一个自身格式的描述