1、Jaxb工具类如下.
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.*;

/**
 * @author sundy
 * @since 1.8
 * 日期: 2019年09月29日 10:11:34
 * 描述：
 */
public class JaxbUtil {
    private static final Logger logger = LoggerFactory.getLogger(JaxbUtil.class);

    /**
     * @param t 要生成xml的实体类
     * @param file 要生成的文件对象
     * @param encoding 数据格式编码
     * @return 是否成生成对应的xml
     */
    public static <T> boolean createXml(T t,File file,String encoding){
        if(file==null) return false;
        if(!file.getParentFile().exists()){
            boolean mkdirs = file.getParentFile().mkdirs();
            logger.debug("mkdirs {} is {}",file.getParent(),mkdirs?"success":"failed");
        }

        try {
            FileWriter fileWriter = new FileWriter(file);
            JAXBContext instance = JAXBContext.newInstance(t.getClass());
            Marshaller marshaller = instance.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.setProperty(Marshaller.JAXB_ENCODING,encoding);
            marshaller.marshal(t,fileWriter);
            fileWriter.flush();
            fileWriter.close();
            return true;
        } catch (Exception e) {
            logger.error(getException(e));
            return false;
        }
    }

    /**
     * @param t 要生成xml的实体类
     * @param filePath 要生成的文件路径
     * @param encoding 数据格式编码
     * @return 是否成生成对应的xml
     */
    public static <T> boolean createXml(T t,String filePath,String encoding){
        return createXml(t,new File(filePath),encoding);
    }

    /**
     * @param t 要生成xml的实体类
     * @param filePath 要生成的文件路径
     * @return 是否成生成对应的xml
     */
    public static <T> boolean createXml(T t,String filePath){
        return createXml(t,new File(filePath),"utf-8");
    }

    /**
     * @param t 要生成xml的实体类
     * @param file 要生成的文件对象
     * @return 是否成生成对应的xml
     */
    public static <T> boolean createXml(T t,File file){
        return createXml(t,file,"utf-8");
    }

    /**
     * @param file 读取的文件对象
     * @param type 要映射生成的Java对象实体
     * @param encoding 编码格式
     */
    public static <T> T readXml(File file,Class<T> type,String encoding) {
        if(file==null||!file.isFile()||type==null) return null;
        T value = null;
        InputStream inStream = null;
        InputStreamReader reader = null;
        try{
            JAXBContext context = JAXBContext.newInstance(type);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            inStream = new FileInputStream(file);
            reader = new InputStreamReader(inStream,encoding);
            value = (T) unmarshaller.unmarshal(reader);
        }catch (Exception e){
            logger.error(getException(e));
        }finally {
            try{
                if(inStream!=null) inStream.close();
                if(reader!=null) reader.close();
            }catch (Exception e){
                logger.error(getException(e));
            }
        }
        return value;
    }

    /**
     * @param filePath 读取的文件路径
     * @param type 要映射生成的Java对象实体
     * @param encoding 编码格式
     */
    public static <T> T readXml(String filePath,Class<T> type,String encoding) {
        return readXml(new File(filePath),type,encoding);
    }

    /**
     * @param filePath 读取的文件路径
     * @param type 要映射生成的Java对象实体
     */
    public static <T> T readXml(String filePath,Class<T> type) {
        return readXml(new File(filePath),type,"utf-8");
    }


    /**
     * @param file 读取的文件对象
     * @param type 要映射生成的Java对象实体
     */
    public static <T> T readXml(File file,Class<T> type) {
        return readXml(file,type,"utf-8");
    }

    /**
     * 获取异常信息的日志描述
     */
    private static String getException(Throwable throwable) {
        if (throwable == null) return "";

        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        throwable.printStackTrace(pw);
        pw.flush();
        LineNumberReader reader = new LineNumberReader(new StringReader(sw.toString()));
        StringBuilder sb = new StringBuilder();
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
        } catch (IOException ex) {
            sb.append(ex.toString());
        }
        return sb.toString();
    }
    
}
 
2、映射生成的xml如下.
 
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<root>
    <status>0</status>
    <service>
        <id>1</id>
        <name>MySQL</name>
        <desc>mysql-server</desc>
        <action>2</action>
        <path>/srv/bin/mysql</path>
    </service>
    <service>
        <id>2</id>
        <name>Java</name>
        <desc>java-server</desc>
        <action>3</action>
        <path>/srv/bin/java</path>
    </service>
</root>
 
3、生成的Java Bean实体类.
 
package com.sundy.spring.boot.entity;

import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
import java.util.List;

/**
 * @author sundy
 * @since 1.8
 * 日期: 2019年09月29日 10:57:50
 * 描述：
 */

@XmlRootElement(name = "root")
@XmlType(propOrder = {"status","service"})
public class ServiceXml {
    private int status;
    private List<Service> service;

    @XmlType(propOrder = {"id","name","desc","action","path","authStatus"})
    public static class Service{
        private long id;
        private String name;
        private String desc;
        private int action;
        private String path;
        private String authStatus;

        public long getId() {
            return id;
        }

        public Service setId(long id) {
            this.id = id;
            return this;
        }

        public String getName() {
            return name;
        }

        public Service setName(String name) {
            this.name = name;
            return this;
        }

        public String getDesc() {
            return desc;
        }

        public Service setDesc(String desc) {
            this.desc = desc;
            return this;
        }

        public int getAction() {
            return action;
        }

        public Service setAction(int action) {
            this.action = action;
            return this;
        }

        public String getPath() {
            return path;
        }

        public Service setPath(String path) {
            this.path = path;
            return this;
        }

        public String getAuthStatus() {
            return authStatus;
        }

        public Service setAuthStatus(String authStatus) {
            this.authStatus = authStatus;
            return this;
        }
    }

    public int getStatus() {
        return status;
    }

    public ServiceXml setStatus(int status) {
        this.status = status;
        return this;
    }

    public List<Service> getService() {
        return service;
    }

    public ServiceXml setService(List<Service> service) {
        this.service = service;
        return this;
    }
}
 
 

首先列出目录结构及其文件内的功能：
 
com.testxml
           .main    //所有对象的入口，测试类

           .books   //实体

           .boos.xml   //xml文件

           .booksDao      //将实体中的值转化为xml文件，保存到制定目录下的xml文件中

                          //解析xml文件转化为list<实体>

           .testxml  //未整合的对xml文件的操作

           .xmlUtil       //xml工具类，创建document对象

                          //得到父节点的子节点的值,只限于父节点下面的子节点是末端元素

                          //将document对象写入到指定的xml文件中去

 
                         //删除指定节点及其子节点
 
xml工具类代码：
 

package com.testxml;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
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;
import org.w3c.dom.NodeList;

public class xmlUtil {

	/**
	 * 创建document对象
	 * @param 相对路径
	 * @return
	 * @throws Exception
	 */
	public  static Document getDocument(String str) throws Exception
	{
		//获取dom解析器工厂
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		//获取具体的解析器
		DocumentBuilder db = dbf.newDocumentBuilder();
		//解析xml文件，获取document对象
		Document document = db.parse(new File(str));
		return document;
	}
	
	/**
	 * 得到父节点的子节点的值,只限于父节点下面的子节点是末端元素
	 * @param document   xml对象
	 * @param parentSrt  父元素
	 * @param childStr   子元素
	 * @param i   第几个父元素,从0开始
	 * @return
	 */
	public  static String getChildValue(Document document,String parentSrt,String childStr,int i)
	{
		NodeList list = document.getElementsByTagName(parentSrt);
	    Element element = (Element) list.item(i);
	    if(element==null)
	    {
	    	throw new NullPointerException("指定的父节点不存在");
	    }
	    String content = element.getElementsByTagName(childStr).item(0).getFirstChild().getNodeValue();
		return content;
	}
	
	/**
	 * 将document对象写入到指定的xml文件中去
	 * @param document
	 * @param str  xml所在目录
	 * @throws Exception
	 */
	 public  static void saveDocument(Document document,String str) throws Exception
	 {
	    TransformerFactory transformerFactory = TransformerFactory.newInstance();  
        //step10:获得一个Transformer对象  
        Transformer transformer = transformerFactory.newTransformer();  
        //step11:把document对象用一个DOMSource对象包装起来  
        Source xmlSource = new DOMSource(document);  
        //step12:建立一个存储目标对象  
        Result outputTarget = new StreamResult(new File(str));  
        //step13:生成相应的xml文件  
        transformer.setOutputProperty("encoding", "UTF-8");
        transformer.transform(xmlSource, outputTarget);  
	 }
	
	 /**
	  * 删除指定节点及其子节点
	  * @param name  节点键
	  * @param str   xml文件所在目录
	  * @return
	  * @throws Exception
	  */
	 public  static boolean delete(Document document,String name,String str) throws Exception
	 {
		 boolean result = false; 
		 NodeList nodeLists = document.getElementsByTagName(name); 
		 int len=nodeLists.getLength();
		 //遍历这个nodelist,每次都删除nodelist的第一个，因为nodelist的size是不断变化的
		 for(int i=0;i<len;i++)
		 { 
			 nodeLists.item(0).getParentNode().removeChild(nodeLists.item(0)); 
		 }
		 xmlUtil.saveDocument(document, str);
		 result=true;
		 return result;
	 }
	 
	public static void main(String[] args) throws Exception {
		Document document=xmlUtil.getDocument("./src/testxml/books.xml");
		String value=xmlUtil.getChildValue(document,"book","title",1);
		System.out.println(value);
	}

}

 

 
 booksdao类代码： 

package com.testxml;

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

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

public class booksDao {

	private Document document;
	public booksDao(String str) throws Exception
	{
		if(document==null)
		{
			document = xmlUtil.getDocument(str);
		}
	}
	
	/**
	 * 将实体中的值转化为xml文件，保存到制定目录下的xml文件中
	 * @param books  实体
	 * @param str  存放xml文件的路径
	 * @return  是否保存成功
	 * @throws Exception
	 */
	 public boolean save(books books,String str) throws Exception
	 {  
		 if(books==null)
		 {
			 throw new IllegalArgumentException("实体类book不能为null");  
		 }
		 boolean result = false; 
		 
		 Element book = document.createElement("book"); 
		 //给获取的book元素添加属性
		 book.setAttribute("category", books.getCategory());  
		 //创建元素，添加到book上面
		 Element title = document.createElement("title");  
		 title.setTextContent(books.getTitle()); 
		 book.appendChild(title);
		 Element author = document.createElement("author");  
		 author.setTextContent(books.getAuthor());
		 book.appendChild(author);
		 
		 //获取根节点，根节点添加book元素
		 Node tempNode=document.getElementsByTagName("booklist").item(0);
		 tempNode.appendChild(book);
		 
		 xmlUtil.saveDocument(document, str);
		 result=true;
		 return result;
	 }
	 
	 /**
	  * 删除指定节点及其子节点
	  * @param name  节点键
	  * @param str   xml文件所在目录
	  * @return
	  * @throws Exception
	  */
	 public void delete(String name,String str) throws Exception
	 {
		 boolean result=xmlUtil.delete(document, name, str);
		 if(result==true)
		 {
			 System.out.println("删除成功！");
		 }
	 }
	 
	 /**
	  * 解析xml文件转化为list<实体>
	  * @param name
	  * @return
	  */
	 public List<books> GetEntityList(String name)
	 {
		 List<books> booklists=new ArrayList<books>();
		 NodeList nodeLists = document.getElementsByTagName(name);
		 for(int i=0;i<nodeLists.getLength();i++)
		 {  
             Element e = (Element) nodeLists.item(i); 
             books books=new books();
             books.setCategory(e.getAttribute("category"));
             books.setTitle(e.getElementsByTagName("title").item(0).getTextContent());
             books.setAuthor(e.getElementsByTagName("author").item(0).getTextContent());
             booklists.add(books);
		 }  
		 return booklists;
	 }
	
}


 books.xml文件
 

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<booklist>
	<book category="这是分类1">
		<title>这是标题1</title>
		<author>这是作者1</author>
	</book>
	<book category="这是分类2">
		<title>这是标题2</title>
		<author>这是作者2</author>
	</book>
	<book category="这是分类3">
		<title>这是标题3</title>
		<author>这是作者3</author>
	</book>
	<book category="这是分类4">
		<title>这是标题4</title>
		<author>这是作者4</author>
	</book>
</booklist>
其他文件代码略。

 

 

 

XML编码模型类（一）：
 
package com.XML.test;

import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class XMLEncodeModel {

	private Map<String,String> heads = new HashMap<String, String>();//XML报文头
	private Map<String,String> roots = new HashMap<String, String>();//XML报文数据

	/**往XML模型添加报文头
	 * @param key 数据名
	 * @param value 数据值
	 * @return
	 */
	public String setHeadParameter(String key,String value){
		if(heads == null){
			heads = new HashMap<String, String>();
		}
		return heads.put(key, value);
	}
	
	/**往XML模型添加报文数据
	 * @param key 数据名
	 * @param value 数据值
	 * @return
	 */
	public String setRootParameter(String key,String value){
		if(roots == null){
			roots = new HashMap<String, String>();
		}
		return roots.put(key, value);
	}

	public String getHeadParameter(String key){
		return heads!=null?heads.get(key):null;
	}
	public String getRootParameter(String key){
		return roots!=null?roots.get(key):null;
	}

	
	/**  产生模型对应的XML数据
	 * @param charset 编码
	 * @return
	 */
	public String toSendData(Charset charset){
		StringBuilder builder = new StringBuilder();
		builder.append("<?xml version=\"1.0\" encoding=\"").append(charset.displayName()).append("\"?>");
		builder.append("<DATA>");
		builder.append("<HEAD>");
		if(heads!=null){
			for(Entry<String, String> keyVal:heads.entrySet()){
				if(keyVal!=null){
					builder.append("<").append(keyVal.getKey()).append(">");
					builder.append(keyVal.getValue()!=null?keyVal.getValue():"");
					builder.append("</").append(keyVal.getKey()).append(">");
				}
			}
		}
		builder.append("</HEAD>");
		builder.append("<ROOT>");
		if(roots!=null){
			for(Entry<String, String> keyVal:roots.entrySet()){
				if(keyVal!=null){
					builder.append("<").append(keyVal.getKey()).append(">");
					builder.append(keyVal.getValue()!=null?keyVal.getValue():"");
					builder.append("</").append(keyVal.getKey()).append(">");
				}
			}
		}
		builder.append("</ROOT>");
		builder.append("</DATA>");
		return builder.toString();
	}
}
 
测试：
 
	public static void main(String[] args) {
		XMLEncodeModel model = new XMLEncodeModel();
		model.setHeadParameter("HeadName1", "value1");
		model.setHeadParameter("HeadName2", "value2");
		model.setHeadParameter("HeadName3", "value3");
		
		model.setRootParameter("RootName1", "RootValue1");
		model.setRootParameter("RootName2", "RootValue2");
		model.setRootParameter("RootName3", "RootValue3");
		
		String xmlString = model.toSendData(Charset.forName("GBK"));
		System.out.println(xmlString);
	}
 
结果：
 
<?xml version="1.0" encoding="GBK"?><DATA><HEAD><HeadName3>value3</HeadName3><HeadName2>value2</HeadName2><HeadName1>value1</HeadName1></HEAD><ROOT><RootName3>RootValue3</RootName3><RootName2>RootValue2</RootName2><RootName1>RootValue1</RootName1></ROOT></DATA>
 
           整理后：
 
<?xml version="1.0" encoding="GBK"?>
<DATA>
	<HEAD>
		<HeadName3>value3</HeadName3>
		<HeadName2>value2</HeadName2>
		<HeadName1>value1</HeadName1>
	</HEAD>
	<ROOT>
		<RootName3>RootValue3</RootName3>
		<RootName2>RootValue2</RootName2>
		<RootName1>RootValue1</RootName1>
	</ROOT>
</DATA>
 
XML文件格式可以根据不同的接口要求对toSendData()方法进行修改
 
 
 
也可以把xml报文头和报文数据单独的写成模型类：
 
XML编码模型类（二）：
 
          报文头模型：
 
public class XMLHeadmodel {

	private String HeadName1;
	
	private String HeadName2;

	private String HeadName3;

	
	public XMLHeadmodel() {
		super();
	}

	public XMLHeadmodel(String headName1, String headName2, String headName3) {
		super();
		HeadName1 = headName1;
		HeadName2 = headName2;
		HeadName3 = headName3;
	}

	public String getHeadName1() {
		return HeadName1;
	}

	public void setHeadName1(String headName1) {
		HeadName1 = headName1;
	}

	public String getHeadName2() {
		return HeadName2;
	}

	public void setHeadName2(String headName2) {
		HeadName2 = headName2;
	}

	public String getHeadName3() {
		return HeadName3;
	}

	public void setHeadName3(String headName3) {
		HeadName3 = headName3;
	}

	
}
 
           报文数据模型：
 
public class XMLRootmodel {

	private String RootName1;
	
	private String RootName2;

	private String RootName3;

	
	public XMLRootmodel() {
		super();
	}

	public XMLRootmodel(String rootName1, String rootName2, String rootName3) {
		super();
		RootName1 = rootName1;
		RootName2 = rootName2;
		RootName3 = rootName3;
	}

	public String getRootName1() {
		return RootName1;
	}

	public void setRootName1(String RootName1) {
		RootName1 = RootName1;
	}

	public String getRootName2() {
		return RootName2;
	}

	public void setRootName2(String RootName2) {
		RootName2 = RootName2;
	}

	public String getRootName3() {
		return RootName3;
	}

	public void setRootName3(String RootName3) {
		RootName3 = RootName3;
	}

	
}
 
          xml模型类：
 
import java.lang.reflect.Field;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class XMLEncodeModel2 {

	private XMLHeadmodel heads = null;//XML报文头
	private XMLRootmodel roots = null;//XML报文数据

	public void setHeads(XMLHeadmodel heads) {
		this.heads = heads;
	}
	
	public void setRoots(XMLRootmodel roots) {
		this.roots = roots;
	}
	
	public XMLHeadmodel getHeads() {
		return heads;
	}

	public XMLRootmodel getRoots() {
		return roots;
	}

	/**  产生模型对应的XML数据
	 * @param charset 编码
	 * @return
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public String toSendData(Charset charset) throws IllegalArgumentException, IllegalAccessException{
		StringBuilder builder = new StringBuilder();
		builder.append("<?xml version=\"1.0\" encoding=\"").append(charset.displayName()).append("\"?>");
		builder.append("<DATA>");
		builder.append("<HEAD>");
		Class<?> headsclz = heads.getClass();
		Field[] headsfields = headsclz.getDeclaredFields();
		for (Field field : headsfields) {
			field.setAccessible(true);
			if(field.get(heads)!=null){
				builder.append("<").append(field.getName()).append(">");
				builder.append((String) field.get(heads));
				builder.append("</").append(field.getName()).append(">");
			}else {
				System.out.println("XML报文头字段："+ field.getName() + " 为空");
			}
		}
		builder.append("</HEAD>");
		builder.append("<ROOT>");
		Class<?> rootsclz = roots.getClass();
		Field[] rootsfields = rootsclz.getDeclaredFields();
		for (Field field : rootsfields) {
			field.setAccessible(true);
			if(field.get(roots)!=null){
				builder.append("<").append(field.getName()).append(">");
				builder.append((String) field.get(roots));
				builder.append("</").append(field.getName()).append(">");
			}else {
				System.out.println("XML报文数据字段："+ field.getName() + " 为空");
			}
		}
		builder.append("</ROOT>");
		builder.append("</DATA>");
		return builder.toString();
	}
}
 
测试：
 
	public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
		XMLEncodeModel2 model = new XMLEncodeModel2();
		XMLHeadmodel heads = new XMLHeadmodel("headvalue1","headvalue2","headvalue3");//报文头
		XMLRootmodel roots = new XMLRootmodel("rootvalue1","rootvalue2","rootvalue3");//报文数据
		model.setHeads(heads);
		model.setRoots(roots);
		String xmlString = model.toSendData(Charset.forName("GBK"));
		System.out.println(xmlString);
	}
 
结果整理后和上面第一个测试一样
 
<?xml version="1.0" encoding="GBK"?>
<DATA>
	<HEAD>
		<HeadName1>headvalue1</HeadName1>
		<HeadName2>headvalue2</HeadName2>
		<HeadName3>headvalue3</HeadName3>
	</HEAD>
	<ROOT>
		<RootName1>rootvalue1</RootName1>
		<RootName2>rootvalue2</RootName2>
		<RootName3>rootvalue3</RootName3>
	</ROOT>
</DATA>
 
 

绪论
 
上一篇文章写了xml文件4种读取方式，本篇文章将简介使用四种方式对xml进行写入。
 
一、Dom写入
 
import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

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

public class DomXml {

	@Test
	public void test(){
		Long start = System.currentTimeMillis();
		createXml();
		System.out.println("运行时间："+ (System.currentTimeMillis() - start));
	}

	/**
	 * 生成xml方法
	 */
	public static void createXml(){
		try {
			// 创建解析器工厂			
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = factory.newDocumentBuilder();
			Document document = db.newDocument();
			// 不显示standalone="no"
			document.setXmlStandalone(true);
			Element bookstore = document.createElement("bookstore");
			// 向bookstore根节点中添加子节点book
			Element book = document.createElement("book");
			
			Element name = document.createElement("name");
			// 不显示内容 name.setNodeValue("不好使");
			name.setTextContent("雷神");
			book.appendChild(name);
			// 为book节点添加属性
			book.setAttribute("id", "1");
			// 将book节点添加到bookstore根节点中
			bookstore.appendChild(book);
			// 将bookstore节点（已包含book）添加到dom树中
			document.appendChild(bookstore);
			
			// 创建TransformerFactory对象
			TransformerFactory tff = TransformerFactory.newInstance();
			// 创建 Transformer对象
			Transformer tf = tff.newTransformer();
			
			// 输出内容是否使用换行
			tf.setOutputProperty(OutputKeys.INDENT, "yes");
			// 创建xml文件并写入内容
			tf.transform(new DOMSource(document), new StreamResult(new File("book1.xml")));
			System.out.println("生成book1.xml成功");
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("生成book1.xml失败");
		}		
	}
}

 
生成结果：
 
 
二、Dom4j写入
 
import java.io.File;
import java.io.FileOutputStream;

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

public class Dom4jXml {

	@Test
	public void test(){
		Long start = System.currentTimeMillis();
		createXml();
		System.out.println("运行时间："+ (System.currentTimeMillis() - start));
	}

	/**
	 * 生成xml方法
	 */
	public static void createXml(){
		try {
			// 1、创建document对象
			Document document = DocumentHelper.createDocument();
			// 2、创建根节点rss
			Element rss = document.addElement("rss");
			// 3、向rss节点添加version属性
			rss.addAttribute("version", "2.0");
			// 4、生成子节点及子节点内容
			Element channel = rss.addElement("channel");
			Element title = channel.addElement("title");
			title.setText("国内最新新闻");
			// 5、设置生成xml的格式
			OutputFormat format = OutputFormat.createPrettyPrint();
			// 设置编码格式
			format.setEncoding("UTF-8");
			
			
			// 6、生成xml文件			
			File file = new File("rss.xml");
			XMLWriter writer = new XMLWriter(new FileOutputStream(file), format);
			// 设置是否转义，默认使用转义字符
			writer.setEscapeText(false);
			writer.write(document);
			writer.close();
			System.out.println("生成rss.xml成功");
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("生成rss.xml失败");
		}
	}
}

 
生成结果：
 
 
三、jDom写入
 
import java.io.File;
import java.io.FileOutputStream;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.junit.Test;

public class JDomXml {
	
	@Test
	public void test(){
		Long start = System.currentTimeMillis();
		createXml();
		System.out.println("运行时间："+ (System.currentTimeMillis() - start));
	}

	/**
	 * 生成xml方法
	 */
	public static void createXml(){
		try {
			// 1、生成一个根节点
			Element rss = new Element("rss");
			// 2、为节点添加属性
			rss.setAttribute("version", "2.0");			
			// 3、生成一个document对象
			Document document = new Document(rss);
			
			Element channel = new Element("channel");
			rss.addContent(channel);
			Element title = new Element("title");
			title.setText("国内最新新闻");
			channel.addContent(title);
						
			Format format = Format.getCompactFormat();
			// 设置换行Tab或空格
			format.setIndent("	");
			format.setEncoding("UTF-8");
						
			// 4、创建XMLOutputter的对象
			XMLOutputter outputer = new XMLOutputter(format);
			// 5、利用outputer将document转换成xml文档
			File file = new File("rssNew.xml");
			outputer.output(document, new FileOutputStream(file));

			System.out.println("生成rssNew.xml成功");
		} catch (Exception e) {
			System.out.println("生成rssNew.xml失败");
		}
	}
	
}

 
生成结果：
 
 
四、Sax写入
 
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.junit.Test;
import org.xml.sax.helpers.AttributesImpl;

public class SaxXml {

	@Test
	public void test(){
		List<Book> bList = new ArrayList<Book>();
		Book b = new Book();
		b.setName("冰与火之歌");
		b.setAuthor("乔治马丁");
		b.setId("1");
		b.setLanguage("English");
		b.setPrice("86");
		b.setYear("2014");
		bList.add(b);
		Long start = System.currentTimeMillis();
		createXml(bList);
		System.out.println("运行时间："+ (System.currentTimeMillis() - start));
	}

	// 生成xml
	public static void createXml(List<Book> bList){		
		// 1、创建一个SAXTransformerFactory类的对象
		SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
		
		try {
			// 2、通过SAXTransformerFactory创建一个TransformerHandler的对象
			TransformerHandler handler = tff.newTransformerHandler();
			// 3、通过handler创建一个Transformer对象
			Transformer tr = handler.getTransformer();
			// 4、通过Transformer对象对生成的xml文件进行设置
			// 设置编码方式
			tr.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			// 设置是否换行
			tr.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与handler关联
			handler.setResult(result);
			
			// 打开document
			handler.startDocument();
			AttributesImpl attr = new AttributesImpl();			
			handler.startElement("", "", "bookstore", attr);
			attr.clear();
			
			for (Book book : bList) {
				attr.clear();
				attr.addAttribute("", "", "id", "", book.getId());
				handler.startElement("", "", "book", attr);
				
				// 创建name
				attr.clear();
				handler.startElement("", "", "name", attr);
				handler.characters(book.getName().toCharArray(), 0, book.getName().length());
				handler.endElement("", "", "name");
				
				// 创建year
				attr.clear();
				handler.startElement("", "", "year", attr);
				handler.characters(book.getYear().toCharArray(), 0, book.getYear().length());
				handler.endElement("", "", "year");
				
				// 创建author
				if(book.getAuthor() != null && !"".equals(book.getAuthor().trim())){
					attr.clear();
					handler.startElement("", "", "author", attr);
					handler.characters(book.getAuthor().toCharArray(), 0, book.getAuthor().length());
					handler.endElement("", "", "author");
				}
				
				// 创建price
				if(book.getPrice() != null && !"".equals(book.getPrice().trim())){
					attr.clear();
					handler.startElement("", "", "price", attr);
					handler.characters(book.getPrice().toCharArray(), 0, book.getPrice().length());
					handler.endElement("", "", "price");
				}
				
				// 创建language
				if(book.getLanguage() != null && !"".equals(book.getLanguage().trim())){
					attr.clear();
					handler.startElement("", "", "language", attr);
					handler.characters(book.getLanguage().toCharArray(), 0, book.getLanguage().length());
					handler.endElement("", "", "language");
				}
				
				handler.endElement("", "", "book");
			}

			handler.endElement("", "", "bookstore");
			// 关闭document
			handler.endDocument();
			System.out.println("生成newbooks.xml成功");
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("生成newbooks.xml失败");
		}
	}
}

 
生成结果：
 
 
五、其它
 
	/**
	 * 四种方式总结
	 * 
	 * dom基于tree，sax基于事件，JDOM和DOM4J基于底层API
	 * 
	 * dom生成的内容会保存到内存中，方便删除和修改
	 * sax不能修改已经生成的标签
	 * 
	 * 添加JUnit在Libraries选择Add Library中的JUnit即可
	 * 
	 */
 
（若有什么错误，请留言指正，3Q）