xml文档概述

时间：2015-03-15 15:15:17 阅读：137 评论：0 收藏：0 [点我收藏+]

标签：

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 称之为模式文档（约束文档）。

xml文档概述

标签：

原文地址：http://www.cnblogs.com/lcpholdon/p/4339719.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行