使用jaxp操作xml文档

package jaxp;
/*使用jaxp操作xml文档事例笔记/

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class Demo1{
	public static void main(String [] args) throws Exception{
		//1:获取工厂
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2:产生解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：解析文档，获取代表文挡的document对象
		Document doc=db.parse(new File("src/1.xml"));
		//4：利用document对象对xml文档进行操作
		read(doc);
		update();
		add();
		add2();
		delete();
		updateAttribute();
		list(doc);
		replace();
	}
	//获取xml文件中的指定对象
	
	public static void read(Document doc){
			NodeList list=doc.getElementsByTagName("售价");
			Node price=list.item(0);
			String value=price.getTextContent();
			System.out.println(value);
	}
	//修改xml文件中的结点
	public static void update() throws ParserConfigurationException, SAXException, IOException, TransformerException{
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//获取domcumentBuilderFactory对象
		DocumentBuilder db=dbf.newDocumentBuilder();//获取documentBuilder
		Document doc=db.parse(new File("src/1.xml"));//利用建立者建立一个document对象
		NodeList list=doc.getElementsByTagName("售价");//在document对象中获取到所有结点的容器
		Node node=list.item(0);//从容器中取出下标为零的节点
		node.setTextContent("109");//将这个节点的值改变
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中
	}
	//增加xml文件中的结点
	public static void add() throws ParserConfigurationException, SAXException, IOException, Exception{
		//1:获取操作xml文件的对象创建工厂实例
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2：通过工厂获取到操作xml的对象实例，也就是解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：通过解析器产生document对象实例，其实解析器操作的是document对象，也就是xml的根节点。
		Document doc=db.parse(new File("src/1.xml"));
		//4：通过操作document实例来操作document下的所有结点也就是每个标签。首先利用document对象获取到他的所有结点列表。再通过结点列表来获取到每个节点
		//创建一个新增的结点
		Node price=doc.createElement("售价");
		price.setTextContent("59");
		//获取到文件中结点为书的结点对象
		Node book=doc.getElementsByTagName("书").item(0);
		book.appendChild(price);//将新增的节点加到书的下面
		//textcontent代表每个结点
		//操做完节点后，只是将内存中的结点进行了修改，要让硬盘中文本也改变，就得利用transformer这个对象来转换操作流的写出。
		//因为这个对象实例也是一个接口，所以就得利用工厂来产生一个transformer对象实例
		//1：利用工厂类的静态方法来获取到产生转换流的工厂
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		//2；利用工厂来产生一个转换流的对对象实例
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		//3：调用这个对象实例的transform方法将内存改变后的结点写出到硬盘中的文件中 
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中	
	}
	//在指定位置上增加结点
	public static void add2()throws Exception{
		//1:获取操作xml文件的对象创建工厂实例
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2：通过工厂获取到操作xml的对象实例，也就是解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：通过解析器产生document对象实例，其实解析器操作的是document对象，也就是xml的根节点。
		Document doc=db.parse(new File("src/1.xml"));
		//4：通过操作document实例来操作document下的所有结点也就是每个标签。首先利用document对象获取到他的所有结点列表。再通过结点列表来获取到每个节点
		//创建一个新增的结点
		Node price=doc.createElement("售价");
		price.setTextContent("39");
		//获取到文件中结点为书的结点对象
		Node book=doc.getElementsByTagName("书").item(0);
		book.insertBefore(price, doc.getElementsByTagName("书名").item(0));
		//1：利用工厂类的静态方法来获取到产生转换流的工厂
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		//2；利用工厂来产生一个转换流的对对象实例
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		//3：调用这个对象实例的transform方法将内存改变后的结点写出到硬盘中的文件中 
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中	
	}
	//删除指定的节点标签
	public static void delete()throws Exception{
		//1:获取操作xml文件的对象创建工厂实例
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2：通过工厂获取到操作xml的对象实例，也就是解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：通过解析器产生document对象实例，其实解析器操作的是document对象，也就是xml的根节点。
		Document doc=db.parse(new File("src/1.xml"));
		//4：通过操作document实例来操作document下的所有结点也就是每个标签。首先利用document对象获取到他的所有结点列表。再通过结点列表来获取到每个节点
		//获取要删除的节点的父节点
		Node price=doc.getElementsByTagName("书").item(0);
		price.removeChild(doc.getElementsByTagName("售价").item(3));
		/*或者直接这么写
		  Node price1=doc.getElementsByTagName("售价").item(0);
		  price1.getParentNode().removeChild(price1);//得到自己的父亲节点，然后调用父亲的移除节点方式删除。以下的替换也可以类似
		 */
		//price.removeChild(doc.getElementsByTagName("售价").item(5));
		//1：利用工厂类的静态方法来获取到产生转换流的工厂
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		//2；利用工厂来产生一个转换流的对对象实例
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		//3：调用这个对象实例的transform方法将内存改变后的结点写出到硬盘中的文件中 
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中
	}
	//修改制定结点的内容
	public static void replace()throws Exception{
		//1:获取操作xml文件的对象创建工厂实例
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2：通过工厂获取到操作xml的对象实例，也就是解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：通过解析器产生document对象实例，其实解析器操作的是document对象，也就是xml的根节点。
		Document doc=db.parse(new File("src/1.xml"));
		//4：通过操作document实例来操作document下的所有结点也就是每个标签。首先利用document对象获取到他的所有结点列表。再通过结点列表来获取到每个节点
		//获取要删除的节点的父节点
		//创建一个要替换的结点
		Node bookname=doc.createElement("书名");
		Node price=doc.getElementsByTagName("书").item(0);
		price.replaceChild(bookname, doc.getElementsByTagName("STL原码剖析").item(0));
		//price.removeChild(doc.getElementsByTagName("售价").item(5));
		//1：利用工厂类的静态方法来获取到产生转换流的工厂
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		//2；利用工厂来产生一个转换流的对对象实例
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		//3：调用这个对象实例的transform方法将内存改变后的结点写出到硬盘中的文件中 
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中
	}
	//修改元素的属性
	public static void updateAttribute()throws Exception{
		//1:获取操作xml文件的对象创建工厂实例
		DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
		//2：通过工厂获取到操作xml的对象实例，也就是解析器
		DocumentBuilder db=dbf.newDocumentBuilder();
		//3：通过解析器产生document对象实例，其实解析器操作的是document对象，也就是xml的根节点。
		Document doc=db.parse(new File("src/1.xml"));
//此处有一个重要的思想，就是如果把document的标签当结点不够使时，就要把它强转为一个元素，然后再操作他的属性。归根结底也就是多态，父类引用指向子类对象
		Element color=(Element)doc.getElementsByTagName("书").item(0);
		color.setAttribute("color", "##00ff");
		
		TransformerFactory tff=TransformerFactory.newInstance();//获取transformer的创建工厂
		//2；利用工厂来产生一个转换流的对对象实例
		Transformer tf=tff.newTransformer();//利用工厂获取到transformer的实例对象
		//3：调用这个对象实例的transform方法将内存改变后的结点写出到硬盘中的文件中 
		tf.transform(new DOMSource(doc), new StreamResult(new File("src/1.xml")));//利用这个实例对象调用transformer方法将改变后的值写出到文件中
	}
	//遍历文档中的所有标签，此处利用了递归思想，归根结底也就是树的遍历
	public static void list(Node node){
		if(node.getNodeType()==node.ELEMENT_NODE){
		System.out.println(node.getNodeName());	
		}
		NodeList list=node.getChildNodes();
		for(int i=0;i<list.getLength();i++){
			Node childnode=list.item(i);
			list(childnode);
		}
	}
	
}