Java解析XML

XML

相关类：javax.xml.parsers.DocumentBuilder

org.w3c.dom.Document

一、作用：

①模拟数据

②配置系统

二、服务器与服务器之间迁移数据：

①先转换为xml文档

②然后通过网络传输到目的服务器

③目的服务器解析xml文档

1、DOM

DOM解析文件的方式

①、相关类：

javax.xml.parsers.*

javax.xml.parsers.DocumentBuilder

javax.xml.parsers.DocumentBuilderFactory

javax.xml.transform.*

javax.xml.transform.Result

javax.xml.transform.Source

javax.xml.transform.TransformerFactory

javax.xml.transform.Transformer

org.w3c.dom.Document.*

org.w3c.dom.Document.Document

org.w3c.dom.Document.Element

org.w3c.dom.Document.NodeList

②、解析步骤:

①、构建DocumentBuilderFactory,使用DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

②、获得DocumentBuilder,使用DocumentBuilder builder = factory.newDocumentBuilder();

③、获得解析文件路径的Document对象，使用Document doc = builder.parse(path);

④、获得指定Document中的标签的对象集，使用NodeList nodes = dom.getElementsByTagName("student");

⑤、获得对象标签的相应属性，通过遍历nodes。            
        //转换成为元素
        Element  node =(Element) nodes.item(i);
        //获得指定的标签对应得值
        String id = node.getElementsByTagName("id").item(0).getFirstChild().getNodeValue();

③、解析实例

public static ArrayList parse(String path) throws ParserConfigurationException, SAXException, IOException{
    //第一步：建立DocmentBuilderfactory
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    //第二步：建立DocmentBuild
    DocumentBuilder builder = factory.newDocumentBuilder();
    //第三步：建立Document
    Document dom = builder.parse(path);
    //第四步：获得对象的标签
    NodeList nodes = dom.getElementsByTagName("student");
    ArrayList data = new ArrayList();

// for(int i = 0; i < nodes.getLength(); i++){
// Node node = nodes.item(i);
//
// System.out.println(node.getNodeName());
//
// }
//第五步：获得对象标签的相应属性
for(int i = 0; i < nodes.getLength(); i++){
//转换成为元素
Element node =(Element) nodes.item(i);
//获得指定的标签对应得值
String id = node.getElementsByTagName(“id”).item(0).getFirstChild().getNodeValue();
String name = node.getElementsByTagName(“name”).item(0).getFirstChild().getNodeValue();
String age = node.getElementsByTagName(“age”).item(0).getFirstChild().getNodeValue();
//第六步:将对象标签中的属性值添加到对象ArrayList中
Student stu = new Student(Integer.parseInt(id),name,Integer.parseInt(age));
data.add(stu);
}

    return data;

}

④、DOM生成XML文档

①、获得DocumentBuilderFactory,使用DocumentBuilderFactory factory = DocumentBulderFactory.newInstance()

②、获得DocumentBulder,使用DocumentBuilder builder = factory.newDocumentBuilder();

③、在内存中创建一个空文档,使用Document doc = builder.newDocument();

④、构建目录所需标签，使用Element root = doc.createElement("dom");Element name1 = doc.createElement("name");

⑤、向需要有内容的标签添加内容，使用name1.setTextContent("aaa");

⑥、生成doc的目录结构，使用appendChild方法  doc.appendChild(root);root.appendChild(item1);

⑦、根据doc生成的目录结构创建输入源Source。DOMSource source = new DOMSource(doc); 

⑧、设置输出结果的Result的方式，Result res = new StreamResult(path+"dome.xml");

⑨、建立一个Transformer对象，使用transform(Source source,Result result)关联，生成XML。

    1、建立Transformer对象步骤：

    ①、TransformerFactory transfactory = TransformerFactory.newInstance();

    ②、Transformer tran = transfactory.newTransformer();

    2、设置transformer中的一些方法

    ①、设置编码方式 tran.setOutputProperty(OutputKeys.ENCODING, "utf-8");

    ②、开启换行 tran.setOutputProperty(OutputKeys.INDENT, "yes");

⑤、DOM方式生成文档实例

public static void write(String path) throws ParserConfigurationException, Exception{
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    //在内存中，创建了一个空文档
    Document doc = builder.newDocument();

    //生成目录结构
    Element root = doc.createElement("dom");

    Element item1 = doc.createElement("item");
    Element name1 = doc.createElement("name");
    //向标签里面添加内容
    name1.setTextContent("aaa");

    Element item2 = doc.createElement("item");
    Element name2 = doc.createElement("name");
    name2.setTextContent("aaa");

    Element item3 = doc.createElement("item");
    Element name3 = doc.createElement("name");
    name3.setTextContent("aaa");

    //添加根目录
    doc.appendChild(root);
    //根目录添加子目录
    root.appendChild(item1);
    //子目录添加子目录 
    item1.appendChild(name1);
    root.appendChild(item2);
    item2.appendChild(name2);
    root.appendChild(item3);
    item3.appendChild(name3);

    //通过流来操作
    TransformerFactory transfactory = TransformerFactory.newInstance();
    Transformer tran = transfactory.newTransformer();
    //创建一个带有DOM节点的输入源
    DOMSource source = new DOMSource(doc); //输入源

    //输出地点
    Result res = new StreamResult(path+"dome.xml");

    //设置编码方式
    tran.setOutputProperty(OutputKeys.ENCODING, "utf-8");
    //开启换行
    tran.setOutputProperty(OutputKeys.INDENT, "yes");

    tran.transform(source, res);

    }

④、DOM是树状模型，要把所有的内容都载入内存中，才能进行解析。

①、JAXP 第三方基于DOM的扩展

②、JDOM

③

2、SAX

1、解析文档

①、相关类

javax.xml.parsers.SAXParser;

javax.xml.parsers.SAXParserFactory;

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


②、解析步骤：

①、获得SAXParserFactory, 使用SAXParserFactory factory = SAXParserFactory.newInstance();

②、获得SAXParser,使用SAXParser parser = factory.newSAXParser();

③、编写一个解析文件方法的类，让这个类继承DefaultHandler类

④、重写DefaultHandler类中的方法
    startDocument(),
    endDocument(),
    startElement(String uri,String localName,String qName,Attributes attributes),
    endElement(String uri, String localName, String qName)
    characters(char[] ch, int start, int length)
⑤、最后调用SAXParser.parse("student.xml",new 解析文件的方法类);

2、解析文件实例:

package com.xml.simple;

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

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.helpers.DefaultHandler;

public class SaxSimple extends DefaultHandler{

private ArrayList data = new ArrayList();
private Student temp ;
private boolean isStart = false;
private String currentTag = "";

//开始解析文档
@Override
public void startDocument() throws SAXException {
    System.out.println("开始解析文档");
}

//结束解析文档
@Override
public void endDocument() throws SAXException {
    System.out.println("结束解析文档");
}

//开始解析元素
@Override
public void startElement(String uri, String localName, String qName,
        Attributes attributes) throws SAXException {
    this.currentTag = qName;
    this.isStart = true;
    if(qName.equals("student")){
        temp = new Student();
    }
}

//结束解析元素
@Override
public void endElement(String uri, String localName, String qName)
        throws SAXException {
    this.isStart = false;
    if(qName.equals("student")){
        data.add(temp);
        temp = null;
        currentTag="";
    }
}

//解析字符数据
@Override
public void characters(char[] ch, int start, int length)
        throws SAXException {
    String data = new String(ch,start,length);
    if(isStart){
        if(currentTag.equals("id")) temp.setId(data);
        if(currentTag.equals("name"))temp.setName(data);
        if(currentTag.equals("age"))temp.setAge(Integer.parseInt(data));
    }
}

public ArrayList getData(){
    return data;
}

public static void main(String[] args) {

    try {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        SaxSimple ss =  new SaxSimple();
        parser.parse("student.xml", ss);
        ArrayList data = ss.getData();
        for (int i = 0; i < data.size(); i++) {
            System.out.println(data.get(i));
        }
    } catch (ParserConfigurationException e) {
        e.printStackTrace();
    } catch (SAXException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

}