XML解析

标记语言：是一种文本及相关的其他信息结合起来，展现出文档数据结构和数据处理细节的电脑文字编码

HTML：超文本标记语言，其设计目标是显示数据并集中于数据外观展现，HTML的标记系统与东一，不可以自己定义，只能使用系统预定义的。

XML：可扩展标记语言，其设计目标是描述数据并集中于处理数据内容；XML是可扩展的，标记符号是无限的，自己定义的

 

XML的优点：

1. 保值性：不会“磨损”
2. 开放性：基于规范和标准的，在任何平台上都可以编译，运行
3. 自我描述性。

XML的创建：

1. 直接以文本格式书写，后缀是.xml
2. XML的声明包含三个属性

Version  表示文档遵守的XML规范版本

Encoding 文档的编码方式，默认为utf-8

Standalone 表示文档是否是一个独立的文件或者需要从外部导入的其他文件，值为yes表示文件是独立的

 

 

XML 声明必须放在第一行

？和XML之间不能有空格，和<  >之间也不能有空格

正确嵌套

标记：（标签）<字符></字符>

元素 从语法上说，一个完整的元素包含，一个开始的标签，一个结束的标签以及标签中的内容

根元素  最外层的元素

叶子元素   没有子元素的元素

空元素 没有内容的元素

 

XML解析：

DOM:  基于dom树来完成的，会根据读取的文档，构架一个树形结构，然后通过DOM接口操作此结构，因为其常驻内存，支持删除，修改，排序等操作，适用于多次访问XML的程序，比较耗内存。

JDOM: 相比DOM速度快，使用的是类 不用接口，但是它不灵活，大量使用了Cllections类 简化步骤

DOM4J: 当今使用最广的，性能优异，功能强大，易用性强，源码开放

SAX: 不太耗内存，也能弥补DOM的不足

 

什么是DOM？ Document object model  文档对象模型

  把XML映射成一课数的样子，以根元素为节点，每个节点以对象的形式存在，通过存取对象操作XML文档的内容。

操作DOM步骤：

1 创建解析器工厂对象 DocumentBuilderFactory

2 由解析器工厂对象创建解析器对象（DocumentBuilder）

3 解析文件 创建DOM树，文档对象（Document）

4 以文档对象为基础操作DOM树（增删改查）

 

DOM解析时常用的对象及意义

 Document对象： 代表整个XML文档

 getElementByTagName(String tagName)

 NdeList 对象 指一个或多个节点

 Element对象

package TestXML;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class DOM_Test implements XMlDocument {
    private Document document;
    private  String filename;

    public void init(){

        try {
            //获得解析器工厂对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //由解析器工厂对象创建解析器对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //由解析器对象创建文档对象
            this.document = builder.newDocument();

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
    }
    public void createXml(String filename) {
        //创建根元素
        Element root = this.document.createElement("employees");
        //文档拼接根元素
        this.document.appendChild(root);
        //创建根元素的子元素
        Element emplpyee = this.document.createElement("emplpyee");
        //创建叶子元素
        Element name = this.document.createElement("name");
        //添加叶子元素的内容
        name.appendChild(this.document.createTextNode("张三"));
        //把叶子元素添加到它的父元素中
        emplpyee.appendChild(name);

        Element sex = this.document.createElement("sex");
        sex.appendChild(this.document.createTextNode("nan"));
        emplpyee.appendChild(sex);

        Element age = this.document.createElement("age");
        age.appendChild(this.document.createTextNode("18"));
        emplpyee.appendChild(age);

        root.appendChild(emplpyee);//把根元素的子元素添加到根元素节点中

        //保存XML文档，通过转换器，把内存中的DOM树模型转存到物理路径上
        //创建转换器工厂
        TransformerFactory tf = TransformerFactory.newInstance();
        try {
          //由转换器对象tf创建转换器
            Transformer transformer = tf.newTransformer();
            //创建文档资源对象
            DOMSource source = new DOMSource(document);
            //设置物理模型的属性（编码方式，缩进）
            transformer.setOutputProperty("encoding","gb2312");
            transformer.setOutputProperty("indent","yes");
            //通过输出流把内存中的DOM树模型输出到根目录下
            PrintWriter pw = new PrintWriter(new FileOutputStream(filename));
            StreamResult result = new StreamResult(pw);
            //转换器转化相关数据
            transformer.transform(source,result);
            System.out.println("创建XML");

        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            e.printStackTrace();
        }

    }

    public void parseXml(String filename){

    }

    public static void main(String[] args) {

        DOM_Test dom_test = new DOM_Test();

        dom_test.init();
        dom_test.createXml("emp.xml");
    }

}

SAX解析

 

package httpserver.Test_xml;

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

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

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class test_xml1 {
    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        List<Person> ps = new ArrayList<Person>();
        //SAX解析固定步骤：
        // 获取解析工厂
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //从解析工厂获取解析器
        SAXParser parser = factory.newSAXParser();
        //编写处理器

        //加载文档Document注册处理器
        PHandler handler = new PHandler();

        //解析
        parser.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("httpserver/Test_xml/p.xml"),handler);
         ps = handler.getPs();
        Iterator<Person> iterator = ps.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}
class PHandler extends DefaultHandler{
    List<Person> ps;
    Person temp ;

    public List<Person> getPs() {
        return ps;
    }

    static String nowname;

    @Override
    public void startDocument() throws SAXException {
        ps = new ArrayList<Person>();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
       // System.out.println(qName+"解析开始");
        nowname = qName;
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        if("person".equals(nowname)){
            temp= new Person();
        }
        if ("name".equals(nowname)){
            String tname = new String(ch,start,length);
            temp.setName(tname);
        }
        if("age".equals(nowname)){
            String age = new String(ch,start,length);
            int tage = Integer.parseInt(age);
            temp.setAge(tage);
        }
       String str= new String(ch,start,length).trim();
       if (str.length()>0)
        System.out.println("内容："+str);
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
      //  System.out.println(qName+"解析结束");
        if("person".equals(qName)){
            ps.add(temp);
        }
        nowname = null;
    }
}

所解析的xml文档
<?xml version="1.0" encoding="UTF-8" ?>
<persons>
    <person>
      <name>leikuan</name>
      <age>19</age>
   </person>
   <person>
      <name>zhoumingjiao</name>
      <age>21</age>
   </person>
</persons>