Xml的4种解析 及增删改（增删改查）泛型实现XML的4种解析

书写xml文件

<?xml version="1.0" encoding="UTF-8"?>
<books>
	<book>
		<name>书名</name>
		<author>作者</author>
		<year>年份</year>
	</book>
	<book>
		<name>安徒生童话</name>
		<author>安徒生</author>
		<year>2004</year>
	</book> 
</books>

书写存储解析的类

public class Book {
	private String name;
	private String author;
	private String year;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public String getYear() {
		return year;
	}
	public void setYear(String year) {
		this.year = year;
	}
	public Book(String name, String author, String year) {
		super();
		this.name = name;
		this.author = author;
		this.year = year;
	}
	public Book() {
		super();
	}
	@Override
	public String toString() {
		return "Book [name=" + name + ", author=" + author + ", year=" + year + "]";
	}
}

SAX解析

public class SAX  extends DefaultHandler {
	String s = "";
	ArrayList<Book> arr = new ArrayList<Book>();
	Book b = null;
	// startElement当解析器解析到其实标签时执行的方法
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		// System.out.print(qName);
	}
	// endElement当解析器解析到原始结束标签时执行的方法
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {	
		if (qName.equals("name")) {
			b = new Book();
			b.setName(s);
		} else if (qName.equals("author")) {
			b.setAuthor(s);
		} else if (qName.equals("year")) {
			b.setYear(s);
			arr.add(b);
		}
	}
	// 当解析器读取到文本内容时执行的方法
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		// System.out.print(new String(ch, start, length));
		s = new String(ch, start, length);
	}
	public static void main(String[] args) throws Exception {
		// 创建SAX解析工厂对象
		SAXParserFactory sParserFactory = SAXParserFactory.newInstance();
		// 获取SAX解析对象
		SAXParser parser = sParserFactory.newSAXParser();
		// 获取SAX解析管理者对象
		SAX handler = new SAX();
		// 使用指定解析管理者对象对文档进行解析
		parser.parse("F://eclipse_workspace//javaOO//books.xml", handler);
		System.out.println(handler.arr);
	}
}

JDOM解析

SAXBuilder sb=new SAXBuilder();
	Document d = sb.build("F://eclipse_workspace//javaOO//books.xml");
	Element rootElement = d.getRootElement();
	List<Element> children = rootElement.getChildren();
	for (Element element : children) {
		List<Element> children2 = element.getChildren();
		for (Element element2 : children2) {
			System.out.println(element2.getValue());
		}
	}

DOM4J解析

public class Dom4JTest {
public static void main(String[] args) throws DocumentException {
		// TODO Auto-generated method stub
SAXReader sr=new SAXReader();
Document read = sr.read("F://eclipse_workspace//javaOO//books.xml");
Element rootElement = read.getRootElement();
Iterator elementIterator = rootElement.elementIterator();
while(elementIterator.hasNext())
{
	Element next = (Element) elementIterator.next();
	Iterator elementIterator2 = next.elementIterator();
	while(elementIterator2.hasNext())
	{
		Element next2 = (Element) elementIterator2.next();
		System.out.println(next2.getText());
	}
}
	}
}

Xml的增删改的实现方法

package com.yunhe.Readtxml;

import java.io.FileOutputStream;
import java.io.IOException;

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.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;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

public class TestZengShanGai {

	/**
	 * @param args
	 * @throws ParserConfigurationException 
	 * @throws IOException 
	 * @throws SAXException 
	 * @throws TransformerException 
	 */
	public static void main(String[] args) throws SAXException, IOException, ParserConfigurationException, TransformerException {
		// TODO Auto-generated method stub
		//deleteNode();
	    //deleteNode2();
		//reviseNode();
		//reviseNode2();
		//updtNode();
		updtNode2();
	}
//删除节点 返回上一步Ctrl+z，下一步Ctrl+y
	public static void deleteNode() throws SAXException, IOException, ParserConfigurationException, TransformerException
	{
		 DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		   DocumentBuilder db=dbf.newDocumentBuilder();
		   //创建一个文档对象
		   //参数：文件名
		   Document doc=db.parse("src//com//text//books.xml");
		   //删除id=101的书籍
		   //找到根节点（books）
		   //根据根节点（books)，遍历根的子节点(book)
		   //遍历三个book,找到id=101的子节点（book)
		   //删除
		   //获取该文档所有子节点
		   NodeList all=doc.getChildNodes();
		   //从子节点中找到根节点，根节点肯定是第一个节点
		   //下标未0的节点是根
		   Node root=all.item(0);
		   //打印根节点的名字
		   System.out.println(root.getNodeName());
		   //得到根节点books之后
		   //子节点
		   NodeList books=root.getChildNodes();
		   for(int i=0;i<books.getLength();i++)
		   {//得到一本书
			   Node book=books.item(i);
			   if("book".equals(book.getNodeName()))
			   {
				   Element el=(Element)book;
				   if(el.getAttribute("id").equals("101"))
				   {
					   System.out.println(el.getAttribute("id"));
					   //System.out.println(el.getParentNode());
					  // root.removeChild(el);
					   el.getParentNode().removeChild(book);
					   /**
					       * 当我们修改xml的时候
					       * doc=db.parse("src/com/text/books.xml");这个方法把xml中的内容都加载到了内存中了
					       * 我们所做的所有的增删改操作都是在内存中进行的
					       * 现在我们已经删了一个节点了，那么内存中的内容已经跟xml中的内容不一致了
					       * 如果不把内存中的内容保存到xml  那么代码结束的时候，xml中的内容是没有任何改变的
					       *接下来要把内存中最新的数据保存到xml中
					       *下面的代码是固定写法  你看不懂也没事，会复制就可以了
					       */
					   TransformerFactory tf=TransformerFactory.newInstance();
					   Transformer tran=tf.newTransformer();
					   //doc文档对象
					   DOMSource domSourse=new DOMSource(doc);
					   //设置编码
					   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
					   //设置保存到哪里
					   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
					   //保存
					   tran.transform(domSourse, result);
				   }
			   }
			   }
		   }
	public static void deleteNode2() throws ParserConfigurationException, SAXException, IOException, TransformerException
	{
		   DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		   DocumentBuilder db=dbf.newDocumentBuilder();
		   db=dbf.newDocumentBuilder();
		   Document doc=db.parse("src//com//text//books.xml");
		   //创建一个文档对象
		   //参数:文件名
		   //直接找到所有的book节点
		   //doc.getElementsByTagName("book");根据标签名字获取节点（元素）
		  // get Element By Tag Name
		   NodeList books=doc.getElementsByTagName("book");
		   for(int i=0;i<books.getLength();i++)
		   {
			   System.out.println(books.item(i).getNodeName());
			   Node book=books.item(i);
			   if("book".equals(book.getNodeName()))
			   {
				   Element el=(Element)book;
				   if(el.getAttribute("id").equals("101"))
				   {
					   System.out.println(el.getAttribute("id"));
					   //System.out.println(el.getParentNode());
					  // root.removeChild(el);
					   el.getParentNode().removeChild(book);
					   /**
					       * 当我们修改xml的时候
					       * doc=db.parse("src/com/text/books.xml");这个方法把xml中的内容都加载到了内存中了
					       * 我们所做的所有的增删改操作都是在内存中进行的
					       * 现在我们已经删了一个节点了，那么内存中的内容已经跟xml中的内容不一致了
					       * 如果不把内存中的内容保存到xml  那么代码结束的时候，xml中的内容是没有任何改变的
					       *接下来要把内存中最新的数据保存到xml中
					       *下面的代码是固定写法  你看不懂也没事，会复制就可以了
					       */
					   TransformerFactory tf=TransformerFactory.newInstance();
					   Transformer tran=tf.newTransformer();
					   //doc文档对象
					   DOMSource domSourse=new DOMSource(doc);
					   //设置编码
					   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
					   //设置保存到哪里
					   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
					   //保存
					   tran.transform(domSourse, result);
				   }
			   }
		   }
	}
	//修改
	public static void reviseNode() throws ParserConfigurationException, SAXException, IOException, TransformerException
	{
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		   DocumentBuilder db=dbf.newDocumentBuilder();
		   //创建一个文档对象
		   //参数：文件名
		   Document doc=db.parse("src//com//text//books.xml");
		   //获取该文档所有子节点
		   NodeList all=doc.getChildNodes();
		   //从子节点中找到根节点，根节点肯定是第一个节点
		   //下标未0的节点是根
		   Node root=all.item(0);
		   //打印根节点的名字
		   System.out.println(root.getNodeName());
		   
		   
		   //得到根节点books之后
		   //子节点
		   NodeList books=root.getChildNodes();
		   for(int i=0;i<books.getLength();i++)
		   {//得到一本书
			   Node book=books.item(i);
			  // System.out.println("=="+book.getNodeType());  
			   if("book".equals(book.getNodeName()))
			   {
			   //System.out.println(book.getNodeName());//#test是空格
			   //输出ID,先把book节点转换为Element类型
			   Element el=(Element)book;
			  // System.out.println(el.getAttribute("id"));
			   if("102".equals(el.getAttribute("id")))
			   {
				  NodeList items=book.getChildNodes();//保存了book的子节点name authors price 
				  for(int j=0;j<items.getLength();j++)
				   {
					   Node item=items.item(j);
					   //System.out.println("=="+item.getNodeType()); 
					   if("name".equals(item.getNodeName()))
					   {
						  item.setTextContent("张三丰");
					   }
					   if("author".equals(item.getNodeName()))
					   {
						   item.setTextContent("张三丰");
					   }
					   if("price".equals(item.getNodeName()))
					   {
						   item.setTextContent("张三丰");
					   }
			        }
				   TransformerFactory tf=TransformerFactory.newInstance();
				   Transformer tran=tf.newTransformer();
				   //doc文档对象
				   DOMSource domSourse=new DOMSource(doc);
				   //设置编码
				   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
				   //设置保存到哪里
				   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
				   //保存
				   tran.transform(domSourse, result);
			   }
			   //在xml中空格也是节点
			   //已经得到一本书，
			   }
		   
		   
		   }
	}
	public static void reviseNode2() throws ParserConfigurationException, SAXException, IOException, TransformerException
	{
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		   DocumentBuilder db=dbf.newDocumentBuilder();
		   //创建一个文档对象
		   //参数：文件名
		   Document doc=db.parse("src//com//text//books.xml");
		   //获取该文档所有子节点
		   NodeList all=doc.getChildNodes();
		   //从子节点中找到根节点，根节点肯定是第一个节点
		   //下标未0的节点是根
		   Node root=all.item(0);
		   //打印根节点的名字
		   System.out.println(root.getNodeName());
		   
		   
		   //得到根节点books之后
		   //子节点
		   NodeList books=root.getChildNodes();
		   for(int i=0;i<books.getLength();i++)
		   {//得到一本书
			   Node book=books.item(i);
			  // System.out.println("=="+book.getNodeType());  
			   if("book".equals(book.getNodeName()))
			   {
			   //System.out.println(book.getNodeName());//#test是空格
			   //输出ID,先把book节点转换为Element类型
			   Element el=(Element)book;
			  // System.out.println(el.getAttribute("id"));
			   if("102".equals(el.getAttribute("id")))
			   {
				   NodeList prices=el.getElementsByTagName("price");
				   System.out.println("======"+prices.getLength());
				   for(int j=0;j<prices.getLength();j++)
				   {
					   Node price=prices.item(j);
					   price.setTextContent("15");
				   }
				   TransformerFactory tf=TransformerFactory.newInstance();
				   Transformer tran=tf.newTransformer();
				   //doc文档对象
				   DOMSource domSourse=new DOMSource(doc);
				   //设置编码
				   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
				   //设置保存到哪里
				   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
				   //保存
				   tran.transform(domSourse, result);
			   }
			   //在xml中空格也是节点
			   //已经得到一本书，
			   }
		   
		   
		   }
	}
	//新增
	public static void updtNode() throws ParserConfigurationException, SAXException, IOException, TransformerException
	{
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		   DocumentBuilder db=dbf.newDocumentBuilder();
		   //创建一个文档对象
		   //参数：文件名
		   Document doc=db.parse("src//com//text//books.xml");
		   //获取该文档所有子节点
		   //创建节点
		   Element book=doc.createElement("book");
		   book.setAttribute("id", "101");
		   
		   Element name=doc.createElement("name");
		   Text item=doc.createTextNode("AAA");
		   name.appendChild(item);
		   
		   Element author=doc.createElement("author");
		     item=doc.createTextNode("BBB");
		     author.appendChild(item);
		     
		   Element price=doc.createElement("price");
		    item=doc.createTextNode("CCC");
		    price.appendChild(item);
		   
		   book.appendChild(name);
		   book.appendChild(author);
		   book.appendChild(price);
		   NodeList all=doc.getChildNodes();
		   //从子节点中找到根节点，根节点肯定是第一个节点
		   //下标未0的节点是根
		   Node root=all.item(0);
		   //打印根节点的名字
		   root.appendChild(book);
		  TransformerFactory tf=TransformerFactory.newInstance();
		   Transformer tran=tf.newTransformer();
		   //doc文档对象
		   DOMSource domSourse=new DOMSource(doc);
		   //设置编码
		   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
		   //设置保存到哪里
		   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
		   //保存
		   tran.transform(domSourse, result);
	}

public static void updtNode2() throws ParserConfigurationException, SAXException, IOException, TransformerException
{
	DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
	   DocumentBuilder db=dbf.newDocumentBuilder();
	   //创建一个文档对象
	   //参数：文件名
	   Document doc=db.parse("src//com//text//books.xml");
	   //获取该文档所有子节点
	   //创建节点
	   Element book=doc.createElement("book");
	   book.setAttribute("id", "101");
	   
	   Element name=doc.createElement("name");
	   name.setTextContent("盗墓笔记");
	   
	   Element author=doc.createElement("author");
	   author.setTextContent("南派三叔");
	     
	   Element price=doc.createElement("price");
	   price.setTextContent("35");
	   
	   book.appendChild(name);
	   book.appendChild(author);
	   book.appendChild(price);
	   NodeList all=doc.getChildNodes();
	   //从子节点中找到根节点，根节点肯定是第一个节点
	   //下标未0的节点是根
	   Node root=all.item(0);
	   //打印根节点的名字
	   root.appendChild(book);
	  TransformerFactory tf=TransformerFactory.newInstance();
	   Transformer tran=tf.newTransformer();
	   //doc文档对象
	   DOMSource domSourse=new DOMSource(doc);
	   //设置编码
	   tran.setOutputProperty(OutputKeys.ENCODING,"utf-8");
	   //设置保存到哪里
	   StreamResult result=new StreamResult(new FileOutputStream("src//com//text//books.xml"));
	   //保存
	   tran.transform(domSourse, result);
}
}

利用泛型实现XML的4种解析

import java.io.IOException;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.w3c.dom.NodeList;


public class XmlUtil {
// sax解析
	public static <E> ArrayList<E> sax(Class<E> c,String uri) 
	{
		E o;
		ArrayList<E> arr = new ArrayList<E>();
		
		return arr;
		
	}
// dom解析
	public static <E> ArrayList<E> Dom(Class<E> c,String uri) 
	{
		E o;
		ArrayList<E> arr = new ArrayList<E>();
		 // 创建文档创建工厂对象
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 获取新的的文档创建对象
		DocumentBuilder db = null;
		// 将给定 URI 的内容解析为一个 XML 文档,并返回Document对象
			try {
				db = dbf.newDocumentBuilder();
				org.w3c.dom.Document parse = db.parse(uri);
				NodeList root = parse.getChildNodes();

				for (int i = 0; i < root.getLength(); i++) {
					NodeList childNodes = root.item(i).getChildNodes();
					for (int j = 0; j < childNodes.getLength(); j++) {
						if(childNodes.item(j).getNodeType()!=3)
						{
						    o=c.newInstance();
							NodeList childNodes2 = childNodes.item(j).getChildNodes();
							for (int k = 0; k < childNodes2.getLength(); k++) {
								Field field = null ;
								if(childNodes2.item(k).getNodeType()!=3)
								{
								field = c.getDeclaredField(childNodes2.item(k).getNodeName());
								field.setAccessible(true);
	          					field.set(o,childNodes2.item(k).getFirstChild().getTextContent());
							}
							}
							arr.add(o);
						}
					}
				
				}
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		return arr;
	
	}
// jdom解析
	public static <E> ArrayList<E> JDom(Class<E> c,String uri) 
	{
		ArrayList<E> arr = new ArrayList<E>();
		E o = null;
		SAXBuilder sb=new SAXBuilder();
		try {
			org.jdom2.Document build = sb.build(uri);
			org.jdom2.Element rootElement = build.getRootElement();
			List<org.jdom2.Element> children = rootElement.getChildren();
			for (org.jdom2.Element element : children) {
				try {
					o = c.newInstance();
				} catch (InstantiationException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				List<org.jdom2.Element> children2 = element.getChildren();
				for (org.jdom2.Element element2 : children2) {
					Field field = null;
					try {
						field = c.getDeclaredField(element2.getName());
					} catch (NoSuchFieldException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (SecurityException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					field.setAccessible(true);
					try {
						field.set(o, element2.getValue());
					} catch (IllegalArgumentException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				arr.add(o);
			}
		} catch (JDOMException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return arr;
	}

// dom4j解析
	public <E> ArrayList<E> Dom4J(Class<E> c,String uri)
	{
		ArrayList<E> arr = new ArrayList<E>();
		try {
			SAXReader sr = new SAXReader();
			Document d = sr.read(uri);
			Element rootElement = d.getRootElement();
			Iterator<?> ei = rootElement.elementIterator();
			while (ei.hasNext()) {
				// 使用传入的class对象 创建指定class对象代表类的对象
				E e = c.newInstance();
				Element next = (Element) ei.next();
				Iterator<?> elementIterator = next.elementIterator();
				while (elementIterator.hasNext()) {
					Element next1 = (Element) elementIterator.next();
					// 通过获取的标签名获取指定类的属性字段对象
					Field field = c.getDeclaredField(next1.getName());
					field.setAccessible(true);
					field.set(e, next1.getStringValue());
					// System.out.println(next1.getName()+"->"+next1.getText());
				}
				arr.add(e);
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return arr;
	}
	public static void main(String[] args) throws MalformedURLException {
//		ArrayList<Book> jDom = XmlUtil.JDom(Book.class,"F://eclipse_workspace//javaOO//books.xml");
//		System.out.println(jDom);
//		ArrayList<Book> dom = XmlUtil.Dom(Book.class,"F://eclipse_workspace//javaOO//books.xml");
//		System.out.println(dom);
	}
}