JDK原生类操作XML

使用JDK自带的类操作XML，包括从对象创建XML，并将XML转换为对象。

import java.io.ByteArrayInputStream;
import java.io.StringWriter;

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.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * JDK 原生XML解析器封装
 * @author lizhiyang
 *
 */
public class XmlUtils {
	
	private static final String DEFAULT_ENCODING = "utf-8";
	/** ClientData有三个属性：ipAddress、port、source **/
	private static final String XML_ROOT = "root";
	private static final String XML_IPADDRESS = "ipAddress";
	private static final String XML_PORT = "port";
	private static final String XML_SOURCE = "source";

	/**
	 * ClientData转换为XML格式字符串
	 * @param clientData
	 * @return
	 * @throws Exception
	 */
	public static String convertClientData2XML(ClientData clientData) throws Exception {
		Document doc = null;
		DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
		doc = builder.newDocument();
		//不进行校验
		doc.setXmlStandalone(true);
		//创建根节点jobcenter
		Element root = doc.createElement(XML_ROOT);
		doc.appendChild(root);

		//创建ipAddress节点
		Element ipAddress = doc.createElement(XML_IPADDRESS);
		Node ipAddressNode = doc.createTextNode(clientData.getIpAddress());
		ipAddress.appendChild(ipAddressNode);
		root.appendChild(ipAddress);
		
		//创建port节点
		Element port = doc.createElement(XML_PORT);
		Node portNode = doc.createTextNode(clientData.getPort());
		port.appendChild(portNode);
		root.appendChild(port);
		
		//创建source节点
		Element source = doc.createElement(XML_SOURCE);
		Node sourceNode = doc.createTextNode(clientData.getSource()+"");
		source.appendChild(sourceNode);
		root.appendChild(source);
		
		return document2String(doc);
	}
	
	/**
	 * Document对象转换为字符串输出
	 * @param doc
	 * @return
	 * @throws Exception
	 */
	private static String document2String(Document doc) throws Exception {
		TransformerFactory transFactory = TransformerFactory.newInstance();  
        Transformer transFormer = transFactory.newTransformer();  
        transFormer.setOutputProperty(OutputKeys.ENCODING, DEFAULT_ENCODING);  
        DOMSource domSource = new DOMSource(doc);  
        StringWriter sw = new StringWriter();  
        StreamResult xmlResult = new StreamResult(sw);  
        transFormer.transform(domSource, xmlResult);  
        return sw.toString();  
	}
	
	/**
	 * XML格式字符串转换为ClientData对象
	 * @param xml
	 * @return
	 */
	public static ClientData convertXML2ClientData(String xml) throws Exception {
		ClientData clientData = null;
		ByteArrayInputStream bis = null;
		try {
			DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			bis = new ByteArrayInputStream(xml.getBytes(DEFAULT_ENCODING));
			Document doc = builder.parse(bis);
			String ipAddress = doc.getElementsByTagName(XML_IPADDRESS).item(0).getTextContent();
			String port = doc.getElementsByTagName(XML_PORT).item(0).getTextContent();
			String source = doc.getElementsByTagName(XML_SOURCE).item(0).getTextContent();
			
			clientData = new ClientData();
			clientData.setIpAddress(ipAddress);
			clientData.setPort(port);
			clientData.setSource(Integer.parseInt(source));
		} catch (Exception e) {
			throw e;
		} finally {
			if(bis != null) {
				bis.close();
				bis = null;
			}
		}
		return clientData;
	}
	
	public static void main(String[] args) {
		ClientData client = new ClientData();
		client.setIpAddress("1.2.3.4");
		client.setPort("100");
		client.setSource(1);
		try {
			String str = XmlUtils.convertClientData2XML(client);
			System.out.println(str);
			
			ClientData clientData = XmlUtils.convertXML2ClientData(str);
			System.out.println(clientData.getIpAddress()+" "+clientData.getPort()+" "+clientData.getSource());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

以上只是非常简单的一个操作。如果对象不确定，此时我们可能就需要使用反射来获取属性了。当然了，这种方式也有很大的局限性。现在比较流行的dom4j等开源的第三方框架也有很多，都能够很方面的操作XML。这种方式只是为了在制作工具类的时候，如果不能引入第三方的工具类，使用JDK原生的类完全可以实现这些功能。