Java中的XML解析

最新推荐文章于 2023-04-03 15:06:57 发布

张鹿鹿

最新推荐文章于 2023-04-03 15:06:57 发布

阅读量1.4k

点赞数

分类专栏： Java基础文章标签： xml java

本文链接：https://blog.csdn.net/u013144863/article/details/52165599

版权

Java基础专栏收录该内容

39 篇文章 0 订阅

订阅专栏

XML解析

什么是XMl ?
- XML 指可扩展标记语言（EXtensible Markup Language）
- XML 是一种标记语言，很类似 HTML
- XML 的设计宗旨是传输数据，而非显示数据
- XML 标签没有被预定义。您需要自行定义标签。
- XML 被设计为具有自我描述性。
- XML 是 W3C 的推荐标准

XML的解析和生成

接下来总结xml解析(生成)的三种方案:

1. Android自带Pull解析

XML解析

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Project: Day11_PullXml
 * Created: Lulu
 * Date: 2016/8/9
 */
public class TestPull {
    public static void main(String[] args) {
        /*
        Pull的xml解析
        parser: 转换
         */
        try {
            //工厂类, 生产对象
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            //XmlPullParser类对象解析xml的
            XmlPullParser parser = factory.newPullParser();
            //首先设置输入流(当前为文件输入流)    编码格式
            parser.setInput(new FileInputStream("res/test.xml"), "UTF-8");
            int type;

            Note note = null;

            while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
                switch (type) {
                    case XmlPullParser.START_DOCUMENT:
                        //开始文档没有用
                        break;
                    //这个字段下是最重要的
                    case XmlPullParser.START_TAG:

                        switch (parser.getName()) {
                            case "note":
                                note = new Note();
                                break;
                            case "to":
                                note.getToes().add(parser.nextText());
                                break;
                            case "from":
                                note.setFrom(parser.nextText());
                                break;
                            case "heading":
                                Heading heading = new Heading();
                                //      第一个值为命名空间, 第二个是属性名
                                heading.setFont(parser.getAttributeValue(null, "font"));
                                heading.setColor(parser.getAttributeValue(null, "color"));
                                heading.setText(parser.nextText());
                                note.setHeading(heading);
                                break;
                            case "body" :
                                note.getBodies().add(new Body());
                                break;
                            case "font":
                                note.getBodies().getLast().setFont(parser.nextText());
                                break;
                            case "color":
                                note.getBodies().getLast().setColor(parser.nextText());
                                break;
                            case "level":
                                note.getBodies().getLast().setLevel(Integer.parseInt(parser.nextText()));
                                break;
                            case "message":
                                note.getBodies().getLast().setMessage(parser.nextText());
                                break;
                        }


                        break;
                }
            }

            System.out.println(note);
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

实体类对象不再贴出, 不过务必注意Note类中的getBodies方法, 在返回之前要检查对象是否为空, 为空则创建对戏

    public LinkedList<Body> getBodies() {
        if (bodies == null){
            bodies = new LinkedList<>();
        }
        return bodies;
    }

XML生成

/**
 * Project: Day11_PullXml
 * Created: Lulu
 * Date: 2016/8/9
 * 使用pullxml生成xml
 */
public class TestPull01 {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("res/out.xml")){
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            //就是把对象让其可传递
            XmlSerializer serializer = factory.newSerializer();
            //设置输出流
            serializer.setOutput(fos, "UTF-8");
            serializer.startDocument("UTF-8", true);
            serializer.startTag(null, "note");
            serializer.startTag(null, "to");
            serializer.text("你好");
            serializer.endTag(null, "to") ;
            serializer.startTag(null, "to");
            serializer.text("4545644646");
            serializer.endTag(null, "to") ;
            serializer.endTag(null, "note");
            serializer.endDocument();
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

2. SAX解析

MyHandler.java

package org.lulu.learn;

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

import java.util.Stack;

/**
 * Project: Day11_SAXXml
 * Created: Lulu
 * Date: 2016/8/9
 */
public class MyHandler extends DefaultHandler {
        private Note note;
    //定义一个栈
    private Stack<String> nameStack;
    public MyHandler(Note note) {
        this.note = note;
    }

    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
        //初始化实体类
        nameStack = new Stack<>();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        super.startElement(uri, localName, qName, attributes);
        nameStack.push(qName);
//        System.out.println(qName);
        switch (qName){
            case "note":
                note.setLevel(Integer.parseInt(attributes.getValue("level")));
                break;
            case "heading":
                note.setHeading(new Heading());
                break;
            case "body":
                note.setBody(new Body());
                break;
        }
    }
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        String s = new String(ch, start, length).trim();
        if (!s.isEmpty()) {
//            System.out.println(s);
            switch (nameStack.peek()) {
                case "to" :
                    note.getTo().add(s);
                    break;
                case "from" :
                    note.setFrom(s);
                    break;
                case "font" :
                    switch (nameStack.get(nameStack.size() - 2)) {
                        case "heading":
                            note.getHeading().setFont(s);
                            break;
                        case "body":
                            note.getBody().setFont(s);
                            break;
                    }
                    break;
                case "title" :
                    note.getHeading().setTitle(s);
                    break;
                case "message" :
                    note.getBody().setMessage(s);
                    break;



            }
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
        nameStack.pop();
    }

    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }
}

Test.java

package org.lulu.learn;

import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 *
 * SAX只能解析不能序列化
 *
 * 1. 基本解析
 * 2. 带嵌套的解析
 * 3. 属性名重名解析
 * 4.
 *
 * Project: Day11_SAXXml
 * Created: Lulu
 * Date: 2016/8/9
 */
public class Test {
    public static void main(String[] args) {
        try {
            //1. 生成SAX工厂类
            SAXParserFactory factory = SAXParserFactory.newInstance();
            //2. 通过工厂类生成SAXParser对象
            SAXParser parser = factory.newSAXParser();

            Note note = new Note();
            parser.parse(new FileInputStream("res/test.xml"), new MyHandler(note));

            System.out.println(note.toString());
            System.out.println(note.getLevel());

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

SAX生成xml过于麻烦, 这里我们只说到解析

3. Dom解析

Dom解析虽方便, 但是需要大量内存空间所以并不是特别实用

XML解析


import org.w3c.dom.*;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.io.IOException;

/**
 * Project: Day11_DomXml
 * 创建过多的对象, 对内存有过大压力
 * Created: Lulu
 * Date: 2016/8/9
 */
public class Test {
    public static void main(String[] args) {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse(new File("res/test.xml"));
            Element root = document.getDocumentElement();

            Note note = new Note();
            note.setTo(
                    root.getElementsByTagName("to").
                            item(0).
                            getTextContent());
            note.setFrom(
                    root.getElementsByTagName("from").
                            item(0).getTextContent());
            note.setHeading(
                    root.getElementsByTagName("heading").
                            item(0).getTextContent());


            Body body = new Body();
            Element body1 = (Element) root.getElementsByTagName("body").item(0);
            body.setLevel(Integer.parseInt(body1.getAttribute("level")));
            body.setFont(body1.getElementsByTagName("font").item(0).getTextContent());
            body.setMessage(body1.getElementsByTagName("message").item(0).getTextContent());
            System.out.println(body);

            System.out.println(note.toString());

        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }

    }
}

XML生成


/**
 * Project: Day11_DomXml
 * Created: Lulu
 * Date: 2016/8/9
 */
public class Test01 {
    public static void main(String[] args) {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.newDocument();
            Element note = document.createElement("note");
            Element to = document.createElement("to");
            to.setTextContent("电动车");
            note.appendChild(to);
            Element from = document.createElement("from");
            from.setTextContent("电动车");
            note.appendChild(from);
            Element heading = document.createElement("heading");
            heading.setTextContent("动车");
            note.appendChild(heading);
            Element body = document.createElement("body");
            body.setTextContent("骑动车");
            note.appendChild(body);

            DOMSource domSource = new DOMSource();
            domSource.setNode(note);
            StreamResult result = new StreamResult();

            result.setOutputStream(new FileOutputStream("res/out.xml"));


        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}