Java解析和写入xml文件

XML文件可扩展标记语言:Extensible Markup Language,

解析和写入xml文件常用的四种方法,DOM SAX JDOM DOM4j方法

其中DOM和SAX方法时java官方提供的解析方法,JDOM和DOM4j为第三方开发商提供的java开发库,需要自己添加库,下面一一介绍解析xml文件的方法

一、DOM

1,解析xml步骤:

a,创建DocumentBuilderFactory类的对象,工厂类需要调用其静态方法newInstance()来得到对象。

b,通过DocumentBuilderFactory对象创建DocumentBuilder对象,调用newDocumentbuilder()方法。

c,通过DocumentBuilder对象调用parse(“xmlw文件地址”)方法加载xml文件。得到Document对象

d,document对象代表整个xml文件,通过其类方法来获取xml文件中的节点。

通过DOM 解析xml文件的代码如下:

package xxlong.test;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import org.w3c.dom.NodeList;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Element;
public class DomTest {
/**
 * DOM解析xml文件的步骤:
 * 1,创建DocumentBuilderFactory对象
 * 2,创建一个DocumentBuilder对象
 * 3,通过DocumentBuilder对象的parser方法加载books.xml文件到当前项目下
 * 4,获取所有book节点的集合getElementByTagName(String name)
 * 5,遍历节点的属性
 * @param args
 */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //通过DocumentBuilderFactory的newInstance()方法创建DocumentBuilderFactory对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
            //创建DocumentBuilder对象
            DocumentBuilder db = dbf.newDocumentBuilder();
            //通过parse方法加载文件
            Document d = db.parse("book.xml");
            //获取所有book节点
            NodeList nl = d.getElementsByTagName("book");
            System.out.println("节点个数: " + nl.getLength());
            
            for(int i = 0; i<nl.getLength(); i++) {
                Node book = nl.item(i);
                NamedNodeMap attrs = book.getAttributes();
                for(int j = 0; j<attrs.getLength(); j++) {
                    Node attr = attrs.item(j);
                    System.out.print("第" + (i+1) + "本书\n" + attr.getNodeName());
                    System.out.println("--属性值:" + attr.getNodeValue());
                }
                NodeList bookChiled = book.getChildNodes();
                System.out.println("第" + (i+1) + "本书共有" + bookChiled.getLength() + "个子节点");
                for(int k = 0; k<bookChiled.getLength(); k++) {
                    if(bookChiled.item(k).getNodeType() == Node.ELEMENT_NODE) {
                        System.out.println(bookChiled.item(k).getNodeName());
//                        System.out.println(bookChiled.item(k).getFirstChild().getNodeValue());
                        System.out.println(bookChiled.item(k).getTextContent());
                    }
                }
//                //知道节点的属性名时可以使用这种方法
//                Element book = (Element) nl.item(i);
//                System.out.println(book.getAttribute("id"));
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

2,通过DOM方法生成xml文件

使用DOM方法生成xml文件的步骤:
1,生成DocumentBuilderFactory dbf,使用静态类方法newInstance()方法
2,生成DocumentBuilder db
3,生成Document document = db.newDocument();Document对象代表要生成的xml文件
4,创建根节点:Element rootElement = document.createElement("bookStore");
5,添加根节点document.appendChild(rootElement);
6,为根节点创建子节点及设置节点值:Element book = document.createElement("book"); book.setAttribute(String name, String value)给子节点添加属性值
添加叶子节点值:name.setTextContent("冰与火之歌");
添加到根节点上:rootElement.appendChild(book);

7,创建transformerFactory工厂类对象,使用类静态方法newInstance();方法得到工厂类对象。

8,通过transformerFactory工厂类对象创建Transformer对象,newTransformer();

9,使用Transformer对象将document对象转换成xml文件,可以通过其设置向xml文件的格式。如编码格式,是否换行等

代码如下:

package xxlong.test;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.parsers.DocumentBuilder;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.UserDataHandler;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
public class DOMUtil {
    /**
     * 使用DOM生成xml文件
     * 1,生成DocumentBuilderFactory dbf,使用newInstance()方法
     * 2,生成DocumentBuilder db
     * 3,生成Document document
     * 4,创建根节点:Element rootElement = document.createElement("bookStore");
     * 5,添加根节点document.appendChild(rootElement);
     * 6,为根节点创建子节点及设置节点值:Element book = document.createElement("book");
     * 添加节点值:name.setTextContent("冰与火之歌");
     * 添加到根节点上:rootElement.appendChild(book);
     *
     */
    public void createXML() {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            Document document = db.newDocument();
            document.setXmlStandalone(true);
            document.setXmlVersion("1.0");
            Element rootElement = document.createElement("bookStore");
            Element book = document.createElement("book");
            Element name = document.createElement("name");
            Element price = document.createElement("price");
            Element year = document.createElement("year");
            Element language = document.createElement("language");
            name.setTextContent("冰与火之歌");
            price.setTextContent("230");
            year.setTextContent("2008");
            language.setTextContent("English");
            book.appendChild(name);
            book.appendChild(price);
            book.appendChild(year);
            book.appendChild(language);
            book.setAttribute("id", "1");
            rootElement.appendChild(book);
            
            
            document.appendChild(rootElement);
            
            TransformerFactory tff = TransformerFactory.newInstance();
            Transformer tf = tff.newTransformer();
            tf.setOutputProperty(OutputKeys.ENCODING, "gbk");
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            tf.transform(new DOMSource(document), new StreamResult(new File("book.xml")));
            
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (TransformerConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

SAX方法解析xml文件
 使用SAX解析xml文件
 1,创建SAXParserFactory对象,使用SAXParserFactory的newinstance()方法,
 包路径为:javax.xml.parsers.SAXParserFactory;
 2,创建SAXParser对象,使用spf.newSAXParser()方法,
 包路径:javax.xml.parsers.SAXParser;
 3,使用sp.parse(String uri, DefaultHandler dh)方法加载.xml文件,需要创建一个DefaultHandler
 对象,创建一个类,继承DefaultHandler类,创建子类的对象;包路径:org.xml.sax.helpers.DefaultHandler;

 创建DefaultHandler对象需要覆写其中的方法

1,public void startDocument() throws SAXException;解析文件开始

2,public void endDocument() throws SAXException;解析文件结束

3,public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException;解析xml文件节点

4,public void endElement(String uri, String localName, String qName) throws SAXException ;结束节点解析

5,public void characters(char[] ch, int start, int length) throws SAXException;解析节点值

方法调用顺序

startDocument
startElement-->characters-->endElement-->循环

endDocument

DefaultHandler 类代码如下:

package xxlong.test;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
public class defaultHandler extends DefaultHandler{
/**
 * 解析顺序
 * startDocument
 * startElement-->characters-->endElement-->循环
 * endDocument
 *
 *
 */
    Book book;
    int countIndex = 0;
    String value;
    private ArrayList<Book> bookList = new ArrayList<Book>();
    /**
     * 解析xml元素
     *
     */
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        //调用父类
        super.startElement(uri, localName, qName, attributes);
        if(qName.equals("book")) {
            book = new Book();
            countIndex++;
            System.out.println("============开始遍历第" + countIndex + "本部的内容===============");
            //已知属性名
            //System.out.println(attributes.getValue("id"));
            //不知道book元素下有多少个属性和名称,
            for(int i = 0; i<attributes.getLength(); i++) {
                if(attributes.getQName(i).equals("id")) {
                    book.setId(attributes.getQName(i));
                }
                System.out.println(attributes.getQName(i));//获取属性名
                System.out.println(attributes.getValue(i));//获取属性值
            }
            
        }
        if(!qName.equals("bookstore")) {
            System.out.print(qName + ":");
        }
        
        
        
    }
    public ArrayList<Book> getBookList() {
        return bookList;
    }
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        // TODO Auto-generated method stub
        super.endElement(uri, localName, qName);
        if(qName.equals("name")) {
            book.setName(value);
        }
        if(qName.equals("author")) {
            book.setAuthor(value);
        }
        if(qName.equals("year")) {
            book.setYear(value);
        }
        if(qName.equals("language")) {
            book.setLanguage(value);
        }
        if(qName.equals("price")) {
            book.setPrice(value);
        }
        
        if(qName.equals("book")) {
            bookList.add(book);
            book = null;
            System.out.println("============结束遍历第" + countIndex + "本部的内容===============");
        }
    }
    /**
     * 标志解析文件开始
     */
    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.startDocument();
        System.out.println("解析文件开始");
    }
    /**
     * 标志解析文件结束
     */
    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.endDocument();
        System.out.println("解析文件开始");
    }
    /**
     * 解析节点
     * value是节点的值
     *
     */
    
    
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        // TODO Auto-generated method stub
        super.characters(ch, start, length);
        value = new String(ch, start, length);
        if(!value.trim().equals("")) {
            System.out.println(value);
            
        }
    }
}

解析方法:

public ArrayList<Book> parseXML() {
        ArrayList<Book> bookList = null;
        SAXParserFactory spf = SAXParserFactory.newInstance();
        try {
            SAXParser sp = spf.newSAXParser();
            defaultHandler dh = new defaultHandler();
            sp.parse("book.xml", dh);
            bookList = dh.getBookList();
            for (Book book : bookList) {
                System.out.println(book.getName());
                System.out.println(book.getAuthor());
                System.out.println(book.getLanguage());
                System.out.println(book.getPrice());
                System.out.println(book.getYear());
                System.out.println(book.getId());
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return bookList;

    }

2,创建xml文件

1.创建一个TransformerFactory对象

2.通过SAXTransformerFactory对象创建一个TransformerHandler对象,通过handler对象创建xml文件

3.通过handler对象创建一个Transformer

4.通过Transformer对象对xml文件格式设置

5.创建result对象

6.handler 对象调用setResult方法加载result对象,一定要在startDocument方法之前。否者会抛出异常

7.使用handler打开document

8.创建属性AttributesImplement attr = new AttributesImpl();

9.创建节点并添加属性;

10.添加子节点并添加属性,和添加根节点及属性的方法相同

生成xml文件的方法代码如下:

    public void createXML() {
        ArrayList<Book> bookList = parseXML();
        //生成XML
        //1.创建一个TransformerFactory对象
        SAXTransformerFactory stff = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
        try {
            //2.通过SAXTransformerFactory对象创建一个TransformerHandler
            TransformerHandler handler = stff.newTransformerHandler();
            //3.通过handler对象创建一个Transformer
            Transformer tf = handler.getTransformer();
            //4.通过Transformer对象对xml文件格式设置
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            File file = new File("book1.xml");
            if(!file.exists()) {
                file.createNewFile();
            }
            //5.创建result对象
            
            Result result = new StreamResult(file);
            handler.setResult(result);//setResult方法一定要在startDocument方法之前。否者会抛出异常
            //打开document
            handler.startDocument();
            //创建属性
            AttributesImpl attr = new AttributesImpl();
            //开始生成节点
            handler.startElement("", "", "bookStore", attr);
            //给子节点添加属性
            attr.clear();
            attr.addAttribute("", "", "id", "", "1");
            //添加子节点
            handler.startElement("", "", "book", attr);
            attr.clear();
            handler.startElement("", "", "name", attr);
            handler.characters("冰与火之歌".toCharArray(), 0, "冰与火之歌".length());
            handler.endElement("", "", "name");
            //结束节点
            handler.endElement("", "", "book");
            handler.endElement("", "", "bookStore");
            //结束document
            handler.endDocument();
        } catch (TransformerConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        
    }

    三、DOM4j方法

1,解析xml文件

a,创建SAXReader对象,通过SAXReader的read方法加载xml文件

b,加载xml文件获得document对象,代表xml文件

c,获取document对象的根节点

d,获取根节点的子节点迭代器,获取子节点的属性及子节点的子节点迭代器,并获取叶子节点的值

代码如下:

public void parseXML() {
        ArrayList<Book> bookList = new ArrayList<Book>();
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(new File("book.xml"));
            Element root = document.getRootElement();
            Iterator<Element> it = root.elementIterator();
            while(it.hasNext()) {
                Book bookstore = new Book();
                Element book = it.next();
                List<Attribute> attrs = book.attributes();
                for (Attribute attribute : attrs) {
                    if(attribute.getName().equals("id")) {
                        bookstore.setId(attribute.getValue());
                    }
                    System.out.println("属性名:" + attribute.getName() + "属性值:"
                            + attribute.getValue());
                    Iterator<Element> itt = book.elementIterator();
                    while(itt.hasNext()) {
                        Element attr = itt.next();
                        if(attr.getName().equals("author")) {
                            bookstore.setAuthor(attr.getStringValue());
                        }
                        if(attr.getName().equals("name")) {
                            bookstore.setName(attr.getStringValue());
                        }
                        if(attr.getName().equals("year")) {
                            bookstore.setYear(attr.getStringValue());
                        }
                        if(attr.getName().equals("price")) {
                            bookstore.setPrice(attr.getStringValue());
                        }
                        if(attr.getName().equals("Language")) {
                            bookstore.setLanguage(attr.getStringValue());
                        }
                        System.out.println("属性名" + attr.getName()
                        + "属性值:" + attr.getStringValue());
                        
                    }
                    bookList.add(bookstore);
                    System.out.println("作者:" + bookstore.getAuthor());
                    bookstore = null;
                }
            }
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

2,生成xml文件

1.创建document对象,代表整个xml,使用DocumentHelper类的静态方法createDocument()方法

2.生成根节点

3.添加属性值

4.添加子节点

5.为子节点添加内容

6.设置xml文件格式,创建OutputFormat format = OutputFormat.createPrettyPrint();方法

7.设置编码格式,通过format对象可以设置xml文件的属性

8,创建XMLWriter对象,通过writer对象将document对象转换成xml文件;

XMLWriter writer = new XMLWriter(new FileOutputStream(new File("rss.xml")),format);

9,writer.write(document)方法将document写入xml文件;

代码如下:

public void createXML(){
        //1.创建document对象,代表整个xml
        Document document = DocumentHelper.createDocument();
        //2.生成根节点
        Element rss = document.addElement("rss");
        //3.添加属性值
        rss.addAttribute("version", "2.0");
        //4.添加子节点
        Element channel = rss.addElement("channel");
        //5.为子节点添加内容
        channel.addText("国内最新新闻");
        //6.设置xml文件格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        //7.设置编码格式
        format.setEncoding("GBK");
        try {
            XMLWriter writer = new XMLWriter(new FileOutputStream(new File("rss.xml")),format);
            //处理转义字符,默认为true,开启转义
            writer.setEscapeText(false);
            writer.write(document);
            writer.close();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        

    }

JDOM方法

参考代码如下:

package xxlong.test;

import org.jdom2.Attribute;
import org.jdom2.CDATA;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

import java.io.InputStream;

import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class JDOMTest {
    /**
     * 使用JDOM解析xml文件的步骤     * 1,创建SAXBuilder对象saxBuilder
     * 2,通过saxBuilder的build方法得到Document对象document
     * 3,获取根节点document.getRootElement()
     * 4,获取根节点的所有子节点:rootElemet.getChildren()
     * 5,获取子节点的所有属性,:element.getAttributes()
     * 6,获取属性名和属性值
     * 7,遍历所有子节点的子节点,获取属性名和属性值
     * @param args
     */
    public void parseXML() {
        SAXBuilder saxBuilder = new SAXBuilder();
        InputStream in;
        ArrayList<Book> bookL= new ArrayList();
        try {
            in = new FileInputStream("book.xml");
            Document document = saxBuilder.build(in);
            Element rootElemet = document.getRootElement();
            List<Element> bookList = rootElemet.getChildren();
            for (Element element : bookList) {
                Book bookstore = new Book();
                System.out.println("开始解析第" + (bookList.indexOf(element)+1) + "本书");
                List<Attribute> attrs = element.getAttributes();
                for (Attribute attribute : attrs) {
                    if(attribute.getName().equals("id")) {
                        bookstore.setId(attribute.getValue());
                    }
                    System.out.println("属性名:"+ attribute.getName() + "属性值:"
                            + attribute.getValue());
                    List<Element> elem = element.getChildren();
                    for (Element element2 : elem) {
                        if(element2.getName().equals("author")) {
                            bookstore.setAuthor(element2.getValue());
                        }
                        if(element2.getName().equals("name")) {
                            bookstore.setName(element2.getValue());
                        }
                        if(element2.getName().equals("year")) {
                            bookstore.setYear(element2.getValue());
                        }
                        if(element2.getName().equals("price")) {
                            bookstore.setPrice(element2.getValue());
                        }
                        if(element2.getName().equals("language")) {
                            bookstore.setLanguage(element2.getValue());
                        }
                        System.out.println("属性名:" + element2.getName()
                        + "属性值: " + element2.getValue());
                    }
                }
                bookL.add(bookstore);
                System.out.println("作者:" + bookstore.getAuthor());

                bookstore = null;
                System.out.println("结束解析第" + (bookList.indexOf(element)+1) + "本书");
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void createXML() {
        Element rss = new Element("rss");
        rss.setAttribute("version", "2.0");
        Document document = new Document(rss);
        Element channel = new Element("channel");
        CDATA cdata = new CDATA("<hahhahha>");
        channel.addContent(cdata);
        
        rss.addContent(channel);
        
        File file = new File("rss.xml");
        //也可以生成
//        if(!file.exists()) {
//            try {
//                file.createNewFile();
//            } catch (IOException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//        }
//        
        Format format = Format.getPrettyFormat();
        format.setEncoding("gbk");
        format.setIndent("");
        XMLOutputter outputter = new XMLOutputter(format);
        try {
            outputter.output(document, new FileOutputStream(file));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    
    public static void main(String[] args) {
        JDOMTest test = new JDOMTest();
        test.createXML();
    }

}



 
 




评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值