XML文件生成

XML文件生成方法

1.DOM和SAX（官方）
DOM生成XML文件（基于tree）
1.获取documentBuilder对象
2.获取Document对象
3.创建根节点
4.将子节点添加到DOM树中
5.创建TransformFactory对象
6.创建Transformer对象
7.将document对象（DOM树）转换为xml文件，并控制格式输出
SAX生成XML文件（基于事件）
1.生成一个SAXTransformerFactory类的对象
2.通过SAXTransformerFactory创建一个TransformerHandler的对象
3.通过TransformerHandler对象创建一个Transformer对象
4.通过transformer对象,对XML文件进行设置，如：setProperty，设置编码和换行
5.创建一个result对象，进行文件创建和文件输出流的编写（属性设置之后，document打开之前）
6.使result和TransformerHandler关联
7.利用TransformerHandler对象对XML文件进行编写
8.打开document
9.循环生成book节点和book下的子节点
10.关闭document
2.DOM4J和JDOM（生成全新形式的文件-RSS）
DOM4J生成XML文件（基于底层API）
1.创建document对象，代表整个XML文档
2.创建根节点rss
3.向rss节点中添加version属性
4.向rss节点中添加节点和节点内容
5.设置XML文件格式,和编码字符集
6.内容中处理转义字符(生成的文本不会自动转义)
7.控制台输出XML文件内容
8.生成XML文件
JDOM生成XML文件（基于底层API）
1.生成一个根节点
2.为节点添加属性
3.生成一个document对象
4.向节点中添加内容
5.创建一个XMLOutputter对象
6.利用output将document对象转换为XML文件
区别：
DOM生成的树驻留在内存中（倒树模型-根-》叶）
方便后序改动，修改删除
SAX生成的树不驻留在内存中，一步一步生成
不可以走回头路，SAX性能高，后面不可改动
性能测试：（生成XML时间）
按照生成XML时间排序：
DOM > JDOM > DOM4J > SAX
性能依次提升。

Code-1：DOM创建XML文件
package com.xml;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
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 org.w3c.dom.Document;
import org.w3c.dom.Element;

public class DOMCreateXML {
    /**
     * 创建XML文件
     * @param args
     */
    public DocumentBuilder getDocumentBuilder(){
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = null;
        try {
            db = dbf.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        return db;
    }

    public void createXML(){
        DocumentBuilder db = getDocumentBuilder();
        Document doc= db.newDocument();
        doc.setXmlStandalone(true);
        //创建根节点
        Element bookstore = doc.createElement("bookstore");
        //向bookstore中添加节点
        Element book = doc.createElement("book");
        Element name = doc.createElement("name");
        name.setTextContent("小王子");
        book.setAttribute("id", "001");
        bookstore.appendChild(book);
        book.appendChild(name);
        //将bookstore()添加到document树中
        doc.appendChild(bookstore);
        //创建树之后将树DOM转换为XML文件
        TransformerFactory tff = TransformerFactory.newInstance();
        try {
            Transformer tf = tff.newTransformer();
            //进行合理换行（键值对（属性名和属性值））
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            tf.transform(new DOMSource(doc), new StreamResult(new File("src/e.xml")));
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            e.printStackTrace();
        }
    }
    /**
     * 主程序
     * @param args
     */
    public static void main(String[] args) {
        DOMCreateXML c = new DOMCreateXML();
        c.createXML();
    }
}


Code-2：SAX创建XML文件
package com.xml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

public class SAXCreateXML {
    /**
     * SAX方式生成XML文件
     * 
     * @param args
     */
    // 利用一个XML文件解析的结果生成一个XML文件
    public ArrayList<Book> parseXML() {
        // 1首先获取一个SAXFactory的实例factory
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 2通过factory获取SAXParser的实例
        // 2创建一个SAXParseHandler的实例
        SAXParseHandler phandler = new SAXParseHandler();
        try {
            SAXParser parser = factory.newSAXParser();
            parser.parse("books.xml", phandler);
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ArrayList booklist = phandler.getBooklist();
        return booklist;
    }

    public void createXML() {

        ArrayList<Book> booklist = parseXML();
        // 生成一个XML文件
        // 1.生成一个SAXTransformerFactory类的对象,
        SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        try {
            // 2.通过SAXTransformerFactory创建一个TransformerHandler的对象
            TransformerHandler tfh = tff.newTransformerHandler();
            // 3.通过TransformerHandler对象创建一个Transformer对象
            Transformer tf = tfh.getTransformer();
            // 4.通过transformer对象,对XML文件进行设置，如：setProperty，设置编码和换行,在setResult之前写
            tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            tf.setOutputProperty(OutputKeys.INDENT, "yes");
            // 5.创建一个result对象，进行文件创建和文件输出流的编写
            File f = new File("src/newbooks.xml");
            if (!f.exists()) {
                f.createNewFile();
            }
            Result result = new StreamResult(new FileOutputStream(f));
            // 6.使result和TransformerHandler关联
            tfh.setResult(result);
            // 7.利用handler对象对XML文件进行编写
            // 8.打开document
            tfh.startDocument();
            // AttributesImpl attr = new AttributesImpl();
            // tfh.startElement("", "", "bookstore", attr);
            // attr.clear();
            // tfh.startElement("", "", "book", attr);
            // attr.addAttribute("", "", "id", "", "001");
            // tfh.endElement("", "", "book");
            // tfh.endElement("", "", "bookstore");
            // 循环生成book节点
            AttributesImpl attr = new AttributesImpl();
            tfh.startElement("", "", "bookstore", attr);
            for (Book book : booklist) {
                attr.clear();
                attr.addAttribute("", "", "id", "", book.getId());
                tfh.startElement("", "", "book", attr);

                //创建name节点
                if(book.getName()!=null && !book.getName().trim().equals("")){
                    attr.clear();
                    tfh.startElement("", "", "name", attr);
                    tfh.characters(book.getName().toCharArray(), 0, book.getName().length());
                    tfh.endElement("", "", "name");
                }
                //创建year节点
                if(book.getYear()!=null && !book.getYear().trim().equals("")){
                    attr.clear();
                    tfh.startElement("", "", "year", attr);
                    tfh.characters(book.getYear().toCharArray(), 0, book.getYear().length());
                    tfh.endElement("", "", "year");
                }
                //创建author节点
                if(book.getAuthor()!=null && !book.getAuthor().trim().equals("")){
                    attr.clear();
                    tfh.startElement("", "", "author", attr);
                    tfh.characters(book.getAuthor().toCharArray(), 0, book.getAuthor().length());
                    tfh.endElement("", "", "author");
                }
                //创建price节点
                if(book.getPrice()!=null && !book.getPrice().trim().equals("")){
                    attr.clear();
                    tfh.startElement("", "", "price", attr);
                    tfh.characters(book.getPrice().toCharArray(), 0, book.getPrice().length());
                    tfh.endElement("", "", "price");
                }
                //创建language节点
                if(book.getLanguage()!=null && !book.getLanguage().trim().equals("")){
                    attr.clear();
                    tfh.startElement("", "", "language", attr);
                    tfh.characters(book.getLanguage().toCharArray(), 0, book.getLanguage().length());
                    tfh.endElement("", "", "language");
                }
                tfh.endElement("", "", "book");
            }
            tfh.endElement("", "", "bookstore");
            // 9.关闭document
            tfh.endDocument();

        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        SAXCreateXML c = new SAXCreateXML();
        c.createXML();
    }

}
Code-3：DOM4J创建XML文件
package com.xml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class DOM4JRSS {
    /**
     * DOM4J生成RSS文件
     * @param args
     */
    public void createXML(){
        //1.创建document对象，代表整个XML文档
        Document doc = DocumentHelper.createDocument();
        //2.创建根节点rss
        Element rss = doc.addElement("rss");
        //3.向rss节点中添加version属性
        rss.addAttribute("version", "2.0");
        //4.向rss节点中添加节点和节点内容
        Element chanel = rss.addElement("chanel");
        Element title = chanel.addElement("title");
        title.setText("<娱乐消息>");

        //生成XML文件
        //控制台输出XML文件内容
        //设置XML文件格式,和编码字符集
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("GBK");
        XMLWriter writer = null;
        try {
            writer = new XMLWriter(format);
            //5.内容中处理转义字符(生成的文本不会自动转义)
            //默认值为TRUE--转义
            writer.setEscapeText(false);
        } catch (UnsupportedEncodingException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        try {
            writer.write(doc);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //生成XML文件
        File f = new File("rss.xml");
        try {
            XMLWriter writeXMl = new XMLWriter(new FileOutputStream(f), format);
            writeXMl.write(doc);
            writeXMl.close();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }

    public static void main(String[] args) {
        DOM4JRSS dom = new DOM4JRSS();
        dom.createXML();
    }
}
Code-4：JDOM生成XML文件
package com.xml;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

public class JDOMXML {

    public void createXML(){
        //1.生成一个根节点
        Element rss = new Element("rss");
        //2.为节点添加属性
        rss.setAttribute("version","2.0");
        //3.生成一个document对象
        Document doc = new Document(rss);
        //4.向节点中添加内容
        Element chanel = new Element("chanel");
        rss.addContent(chanel);
        Element title = new Element("title");
        title.setText("<娱乐新闻>");
        chanel.addContent(title);
        //4.创建一个XMLOutputter对象
        Format format = Format.getCompactFormat();
        format.setIndent("");
        format.setEncoding("GBK");
        format.setEscapeStrategy(null);
        XMLOutputter output = new XMLOutputter(format);
        //5.利用output将document对象转换为XML文件
        try {
            output.output(doc, new FileOutputStream(new File("rssnew.xml")));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        JDOMXML c = new JDOMXML();
        c.createXML();
    }
}