day16_xml(跟着宝哥学java：xml解析)-CSDN博客

本文链接：https://blog.csdn.net/mtb278750/article/details/129632621

1 概念

xml : extended markup language
      可扩展的标记类语言
编程类语言：数据分类+流程控制
描述性语言：让数据以指定格式保存、展示
特点1：标记：：：使用标签封装数据：： <标签名 属性名=属性值 属性名=属性值 >数据</标签名>
特点2：可扩展：：：标签/属性都是自定义
特点3：用于描述有关系的数据：：：一般作为软件的配置文件(软件启动/运行过程中需要加载的配置信息)

2 创建xml

xml是纯文本类型的语言：只要可以操作文本的软件都可以作为xml的编辑软件
xml文件的解析：通过浏览器(内置有解析xml文件的引擎)
xml文件的后缀名必须是.xml
xml文件有两部分组成：声明区+数据区
声明区：对xml文件的整体属性的设置：版本version(协议版本) encoding(中文必须有编码集)
数据区：当前xml存储的所有数据
标记类语言的注释：<!--注释的内容-->

创建一个文本文档：后缀名更改为.xml

<?xml version='1.0' encoding='utf-8'?> <!--声明区-->
<!--数据区-->
<!--注意1：标签类语言支持标签与标签之间的合理嵌套：<a><b></b></a>-->
<!--注意2：一个xml文件中有且只有一个根标签：：所有的标签都是此标签的子标签-->
<!--注意3：存储数据：属性+文本  一般只有叶标签才设置文本-->
<!--注意4: 使用标签实体来表示特殊含义的字符：标签实体格式：&xxx;
            小于号： &lt;   
			大于号：&gt;  
			单引号：&apos;
			双引号：&quot;
-->
<!--注意5:<![CDATA[ <a>hehe</a> ]]>  ::不对[]内的文本进行解析-->

<dangAn>  <!--根标签-->
     <class id="java43">
	      <student sid="stu_43_1">
		        <name>韩梅梅</name>
				<age>18</age>
				<sex>女</sex>
				<score>98.5</score>
		  </student>
		  <student sid="stu_43_2">
		        <name>韩寒</name>
				<age>28</age>
				<sex>男</sex>
				<score>48.5</score>
		  </student>
		  <student sid="stu_43_3">
		        <name>韩非子</name>
				<age>88</age>
				<sex>男</sex>
				<score>99.5</score>
		  </student>
	 </class>
	 
	  <class id="java42">
	      <student sid="stu_42_1">
		        <name>张三</name>
				<age>18</age>
				<sex>女</sex>
				<score>96.5</score>
		  </student>
		  <student sid="stu_42_2">
		        <name>张无忌</name>
				<age>68</age>
				<sex>男</sex>
				<score>46.5</score>
		  </student>
		  <student sid="stu_42_3">
		        <name>张翠山</name>
				<age>38</age>
				<sex>男</sex>
				<score>96.5</score>
				<hehe>1&lt;a&gt;3&lt;b&#62;4&lt;d&gt;</hehe>
				<code>
				    <![CDATA[
						<a>hehe</a>
					]]>
					<a>hehe</a>
				</code>
		  </student>
	 </class>
</dangAn>

运行xml文件通过浏览器

3 使用dom对xml进行增删改查

概念

dom解析

dom:document object model : 文档对象模型
    把xml文档及其中的所有元素都封装为对象  这些有关系的对象形成dom树

在这里插入图片描述

sax解析

simple api for xml:民间组织为读取xml 创建的api
sax只提供给了 对xml快速读取的方法 没有提供增删改的方法
它逐行扫描文档，一边扫描一边解析
api:帮助文档:::接口 类 方法的集合

sax解析和dom解析的区别

1         dom解析需要把文档及其所有元素都封装为对象 比较占内存 不宜与读取大文件
          sax实现xml文件的快速扫描：占用内存少  适合于读取大文件
2         dom解析支持对xml的增删改查
          sax只支持读取：不支持增删改

查询

package day17_xml;

import java.io.File;

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

import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

public class Demo01CRUD {
	static String path="C:\\Users\\Administrator\\Desktop\\学校.xml";
     /*
      * CRUD:create read update delete
      * 
      * 获取：
      *    1 Document的方法：NodeList getElementsByTagName(String eleName):通过标签名获取指定的所有标签
      *    2 Node的方法：String getNodeName():获取节点名字
      *                 String getNodeValue():获取节点值(只有当节点是属性时 才有值)
      *                 short getNodeType():获取节点类型：：Element是1
      *                 Node getParentNode();获取父节点
      *                 NodeList getChildNodes();获取所有的子节点
      *    3 Element的方法：String getTextContent();获取标签文本内容：：
      *                    String getAttribute(String attrName);标签标签的指定属性值
      *                    NamedNodeMap getAttributes();获取所有属性
      *    4 Attr的方法：      String getName();获取属性名         
      *                    String getValue();获取属性值             
      *    NodeList：节点集合
      *    方法： int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      *    NamedNodeMap:节点集合
      *    方法：  int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      * 
      * */
	public static void main(String[] args)throws Exception{
		//1 解析xml为document对象
		Document doc=readXml2doc(path);
		//2 获取所有的class标签
		NodeList list=doc.getElementsByTagName("class");
		//遍历
		for (int i = 0; i < list.getLength(); i++) {
			System.out.println(i+"::"+list.item(i));
			Node node=list.item(i);
			System.out.println("getNodeName:"+node.getNodeName());//标签名字
			System.out.println("getNodeValue:"+node.getNodeValue());
			System.out.println("getNodeType:"+node.getNodeType());//1
			//获取其父标签
			Node parent=node.getParentNode();
			System.out.println("父节点的名字："+parent.getNodeName());
			//获取所有的子节点
			NodeList children=node.getChildNodes();
			for (int j = 0; j < children.getLength(); j++) {
				Node zi=children.item(j);
				System.out.println(i+":::"+j+"::::"+zi.getNodeName()+":::"+zi.getNodeType());
			}
			//向下转型为标签
			Element ele=(Element)node;
			System.out.println("获取标签文本内容：getTextContent="+ele.getTextContent());
			System.out.println("获取指定的标签属性：getAttribute(\"id\")="+ele.getAttribute("id"));
			//获取标签的所有属性
			NamedNodeMap map=ele.getAttributes();
			for (int j = 0; j < map.getLength(); j++) {
				Attr attr=(Attr)map.item(j);
				System.out.println("属性："+attr.getName()+"="+attr.getValue());
			}
			System.out.println("-------");
			
		}
		
		bianLi(doc);
	}
	public static Document  readXml2doc(String path)throws Exception{
		//1 静态工厂模式：获取documentbuilderfactory对象
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		//2 通过工厂对象获取documentbuidler对象::文档解析器对象
		DocumentBuilder builder=factory.newDocumentBuilder();
		//3 通过builder文档解析器对象的parse方法 解析xml为document对象
		return builder.parse(new File(path));
	}
}

遍历

//写一个方法 遍历xml中的所有内容
public static void  bianLi(Node node)throws Exception{

    //判断节点的类型
    if(node instanceof Text) {
        Text text=(Text)node;
        System.out.println("文本：："+node.getNodeType()+":"+node.getNodeName()+":"+text.getTextContent());
        return;
    }
    if(node instanceof Comment) {
        Comment comment=(Comment)node;
        System.out.println("注释：："+node.getNodeType()+":"+node.getNodeName()+":"+comment.getTextContent());
        return;
    }
    if(node instanceof Element) {
        Element ele=(Element)node;
        System.out.println("标签：："+node.getNodeType()+":"+node.getNodeName());
        //获取标签的所有属性
        NamedNodeMap  attrs=ele.getAttributes();
        for (int i = 0; i < attrs.getLength(); i++) {
            Attr attr=(Attr)attrs.item(i);
            System.out.println("标签："+node.getNodeName()+"的属性："+attr.getNodeType()+"::"+attr.getName()+"="+attr.getValue());
        }
        //获取所有子元素
        NodeList zis=ele.getChildNodes();
        for (int i = 0;zis!=null&& i < zis.getLength(); i++) {
            //通过递归来遍历所有的子元素
            bianLi(zis.item(i));
        }
    }
    if(node instanceof Document) {
        System.out.println("文档：："+node.getNodeType()+":"+node.getNodeName());
        Document doc=(Document)node;
        //获取所有子元素
        NodeList zis=doc.getChildNodes();
        for (int i = 0;zis!=null&& i < zis.getLength(); i++) {
            //通过递归来遍历所有的子元素
            bianLi(zis.item(i));
        }
    }
}

修改

package day17_xml;
..
public class Demo02CRUD {
	static String path="C:\\Users\\Administrator\\Desktop\\学校.xml";
     /*
      * CRUD:create read update delete
      * 
      * 获取：
      *    1 Document的方法：NodeList getElementsByTagName(String eleName):通过标签名获取指定的所有标签
      *    2 Node的方法：String getNodeName():获取节点名字
      *                 String getNodeValue():获取节点值(只有当节点是属性时 才有值)
      *                 short getNodeType():获取节点类型：：Element是1
      *                 Node getParentNode();获取父节点
      *                 NodeList getChildNodes();获取所有的子节点
      *    3 Element的方法：String getTextContent();获取标签文本内容：：
      *                    String getAttribute(String attrName);标签标签的指定属性值
      *                    NamedNodeMap getAttributes();获取所有属性
      *                    NodeList getElementsByTagName(String eleName):获取指定的所有直接子标签
      *    4 Attr的方法：      String getName();获取属性名         
      *                    String getValue();获取属性值             
      *    NodeList：节点集合
      *    方法： int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      *    NamedNodeMap:节点集合
      *    方法：  int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      * 
      *修改：
      *   1 Element的方法：void setTextContent(String text);修改和添加文本内容
      *   2 Element的方法：void setAttribute(String attrName,String attrValue);修改和添加属性
      * */
	public static void main(String[] args)throws Exception{
		//1 解析xml为document对象
		Document doc=readXml2doc(path);
        //和第一个class的所有student子标签
        Element classEle=(Element)doc.getElementsByTagName("class").item(0);
        
        //修改
        NodeList stus1=classEle.getElementsByTagName("student");
        //给所有分数加1
        for (int i = 0; i < stus1.getLength(); i++) {
			Element stu=(Element)stus1.item(i);
			//获取对齐student标签的score标签
			Element sco=(Element)stu.getElementsByTagName("score").item(0);
			//分数加1
			sco.setTextContent(Double.parseDouble(sco.getTextContent())+1+"");
			//名字加同学
			Element name=(Element)stu.getElementsByTagName("name").item(0);
			name.setTextContent(name.getTextContent()+"同学");
			//更改属性：
			stu.setAttribute("sid", stu.getAttribute("sid")+"_0");
		}
        //把doc的信息刷新道xml文件中
        writeDoc2Xml(doc,path);
	}
	//读取xml文件为document
	public static Document  readXml2doc(String path)throws Exception{
		//1 静态工厂模式：获取documentbuilderfactory对象
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		//2 通过工厂对象获取documentbuidler对象::文档解析器对象
		DocumentBuilder builder=factory.newDocumentBuilder();
		//3 通过builder文档解析器对象的parse方法 解析xml为document对象
		return builder.parse(new File(path));
	}
	//把document刷新道xml中
	public static void  writeDoc2Xml(Document doc,String path)throws Exception{
		//1 获取格式转换器工厂对象
		TransformerFactory factory=TransformerFactory.newInstance();
		//2 获取转换器对象
		Transformer former=factory.newTransformer();
		//设置编码集
		former.setOutputProperty(OutputKeys.ENCODING, "utf-8");
		//自动换行
		former.setOutputProperty(OutputKeys.INDENT, "yes");
		//3 调用转换器的的
		Source source=new DOMSource(doc);
		Result result=new StreamResult(new File(path));
		former.transform(source, result);
	}
}

删除

package day17_xml;
...
public class Demo02CRUD {
	static String path="C:\\Users\\Administrator\\Desktop\\学校.xml";
     /*
      * CRUD:create read update delete
      * 
      * 获取：
      *    1 Document的方法：NodeList getElementsByTagName(String eleName):通过标签名获取指定的所有标签
      *    2 Node的方法：String getNodeName():获取节点名字
      *                 String getNodeValue():获取节点值(只有当节点是属性时 才有值)
      *                 short getNodeType():获取节点类型：：Element是1
      *                 Node getParentNode();获取父节点
      *                 NodeList getChildNodes();获取所有的子节点
      *    3 Element的方法：String getTextContent();获取标签文本内容：：
      *                    String getAttribute(String attrName);标签标签的指定属性值
      *                    NamedNodeMap getAttributes();获取所有属性
      *                    NodeList getElementsByTagName(String eleName):获取指定的所有直接子标签
      *    4 Attr的方法：      String getName();获取属性名         
      *                    String getValue();获取属性值             
      *    NodeList：节点集合
      *    方法： int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      *    NamedNodeMap:节点集合
      *    方法：  int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      * 
      *修改：
      *   1 Element的方法：void setTextContent(String text);修改和添加文本内容
      *   2 Element的方法：void setAttribute(String attrName,String attrValue);修改和添加属性
      *添加：
      *   1  Document的方法： Element createElement(String nodeName) ；创建标签
      *   2  Element的方法：Node appendChild(Node zi);把参数标签添加道当前标签下 符合当前标签
      *      Element的方法：void setTextContent(String text);修改和添加文本内容
      *      Element的方法：void setAttribute(String attrName,String attrValue);修改和添加属性
      *删除：
      *   1 Element的方法：  removeAttribute(String name);删除属性
      *   2 Element的方法：  Node removeChild(Node zi);删除参数子标签：返回此子标签
      * */
	public static void main(String[] args)throws Exception{
		//1 解析xml为document对象
		Document doc=readXml2doc(path);
        //和第一个class的所有student子标签
        Element classEle=(Element)doc.getElementsByTagName("class").item(0);

        //删除：
        //删除属性：
        classEle.removeAttribute("a");
        //删除子标签
        Element classStu=(Element)classEle.getElementsByTagName("student").item(0);
        System.out.println(classEle.removeChild(classStu).getNodeName());
        //把doc的信息刷新道xml文件中
        writeDoc2Xml(doc,path);
	}
	//读取xml文件为document
	public static Document  readXml2doc(String path)throws Exception{
		//1 静态工厂模式：获取documentbuilderfactory对象
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		//2 通过工厂对象获取documentbuidler对象::文档解析器对象
		DocumentBuilder builder=factory.newDocumentBuilder();
		//3 通过builder文档解析器对象的parse方法 解析xml为document对象
		return builder.parse(new File(path));
	}
	//把document刷新道xml中
	public static void  writeDoc2Xml(Document doc,String path)throws Exception{
		//1 获取格式转换器工厂对象
		TransformerFactory factory=TransformerFactory.newInstance();
		//2 获取转换器对象
		Transformer former=factory.newTransformer();
		//设置编码集
		former.setOutputProperty(OutputKeys.ENCODING, "utf-8");
		//自动换行
		former.setOutputProperty(OutputKeys.INDENT, "yes");
		//3 调用转换器的的
		Source source=new DOMSource(doc);
		Result result=new StreamResult(new File(path));
		former.transform(source, result);
	}
}

添加

package day17_xml;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
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.omg.CORBA.NameValuePair;
import org.w3c.dom.Attr;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

public class Demo02CRUD {
	static String path="C:\\Users\\Administrator\\Desktop\\学校.xml";
     /*
      * CRUD:create read update delete
      * 
      * 获取：
      *    1 Document的方法：NodeList getElementsByTagName(String eleName):通过标签名获取指定的所有标签
      *    2 Node的方法：String getNodeName():获取节点名字
      *                 String getNodeValue():获取节点值(只有当节点是属性时 才有值)
      *                 short getNodeType():获取节点类型：：Element是1
      *                 Node getParentNode();获取父节点
      *                 NodeList getChildNodes();获取所有的子节点
      *    3 Element的方法：String getTextContent();获取标签文本内容：：
      *                    String getAttribute(String attrName);标签标签的指定属性值
      *                    NamedNodeMap getAttributes();获取所有属性
      *                    NodeList getElementsByTagName(String eleName):获取指定的所有直接子标签
      *    4 Attr的方法：      String getName();获取属性名         
      *                    String getValue();获取属性值             
      *    NodeList：节点集合
      *    方法： int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      *    NamedNodeMap:节点集合
      *    方法：  int getLength()  获取节点个数
      *           Node item(int index)  根绝下标获取节点
      * 
      *修改：
      *   1 Element的方法：void setTextContent(String text);修改和添加文本内容
      *   2 Element的方法：void setAttribute(String attrName,String attrValue);修改和添加属性
      *添加：
      *   1  Document的方法： Element createElement(String nodeName) ；创建标签
      *   2  Element的方法：Node appendChild(Node zi);把参数标签添加道当前标签下 符合当前标签
      *      Element的方法：void setTextContent(String text);修改和添加文本内容
      *      Element的方法：void setAttribute(String attrName,String attrValue);修改和添加属性
      *删除：
      *   1 Element的方法：  removeAttribute(String name);删除属性
      *   2 Element的方法：  Node removeChild(Node zi);删除参数子标签：返回此子标签
      * */
	public static void main(String[] args)throws Exception{
		//1 解析xml为document对象
		Document doc=readXml2doc(path);
        //和第一个class的所有student子标签
        Element classEle=(Element)doc.getElementsByTagName("class").item(0);       
        //添加属性
        classEle.setAttribute("className", "className_value");
        //添加子标签
        Element stuNew=doc.createElement("student");//创建标签
        //添加属性
        stuNew.setAttribute("sid", "新来的学生的学号");
        Element nameNew=doc.createElement("name");//创建标签
        Element sexNew=doc.createElement("sex");//创建标签
        Element ageNew=doc.createElement("age");//创建标签
        Element dyNew=doc.createElement("dy");//创建标签
        //设置文本内容
        nameNew.setTextContent("新来的");
        sexNew.setTextContent("女");
        ageNew.setTextContent("18");
        dyNew.setTextContent("true");
        //把子标签添加道父标签下
        stuNew.appendChild(dyNew);stuNew.appendChild(nameNew);
        stuNew.appendChild(sexNew);stuNew.appendChild(ageNew);
        classEle.appendChild(stuNew);
        //把doc的信息刷新道xml文件中
        writeDoc2Xml(doc,path);
	}
	//读取xml文件为document
	public static Document  readXml2doc(String path)throws Exception{
		//1 静态工厂模式：获取documentbuilderfactory对象
		DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
		//2 通过工厂对象获取documentbuidler对象::文档解析器对象
		DocumentBuilder builder=factory.newDocumentBuilder();
		//3 通过builder文档解析器对象的parse方法 解析xml为document对象
		return builder.parse(new File(path));
	}
	//把document刷新道xml中
	public static void  writeDoc2Xml(Document doc,String path)throws Exception{
		//1 获取格式转换器工厂对象
		TransformerFactory factory=TransformerFactory.newInstance();
		//2 获取转换器对象
		Transformer former=factory.newTransformer();
		//设置编码集
		former.setOutputProperty(OutputKeys.ENCODING, "utf-8");
		//自动换行
		former.setOutputProperty(OutputKeys.INDENT, "yes");
		//3 调用转换器的的
		Source source=new DOMSource(doc);
		Result result=new StreamResult(new File(path));
		former.transform(source, result);
	}
}

4 练习

使用xml对Teacher进行增删改查

package day17_xml_socket;

import java.io.Serializable;

public class Teacher implements Serializable {
	private Integer tid;
	private String tname;
	private String tsex;
	private Double tsalary;
	private Boolean tdy;
	public Integer getTid() {
		return tid;
	}
	public void setTid(Integer tid) {
		this.tid = tid;
	}
	public String getTname() {
		return tname;
	}
	public void setTname(String tname) {
		this.tname = tname;
	}
	public String getTsex() {
		return tsex;
	}
	public void setTsex(String tsex) {
		this.tsex = tsex;
	}
	public Double getTsalary() {
		return tsalary;
	}
	public void setTsalary(Double tsalary) {
		this.tsalary = tsalary;
	}
	public Boolean getTdy() {
		return tdy;
	}
	public void setTdy(Boolean tdy) {
		this.tdy = tdy;
	}
	@Override
	public String toString() {
		return "Teacher [tid=" + tid + ", tname=" + tname + ", tsex=" + tsex + ", tsalary=" + tsalary + ", tdy=" + tdy
				+ "]";
	}
	public Teacher(Integer tid, String tname, String tsex, Double tsalary, Boolean tdy) {
		super();
		this.tid = tid;
		this.tname = tname;
		this.tsex = tsex;
		this.tsalary = tsalary;
		this.tdy = tdy;
	}
	public Teacher() {}
	 

}

package day17_xml_socket;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

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.NodeList;

public class TeacherCrudUtil {
    static String fileName="src/day17_xml/Teacher.xml";
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			addOne(new Teacher(1000+i,
					           UUID.randomUUID().toString().replace("-", "").substring(1,10), 
					           Math.random()>0.5?"男":"女", 
					        		   (int)(Math.random()*1001)/10.0,
					        		   Math.random()>0.5));
		}
		System.out.println("获取所有：："+getAll());
		System.out.println("删除一个：："+deleteOne(1001));
		System.out.println("修改一个：："+updateOne(new Teacher(1002, "老二", "男", 11.0, true)));
		System.out.println("获取一个："+getOne(1002));

	}
	//添加一个
	public static int addOne(Teacher t) {
		//获取document对象
		Document doc=readXml2Doc();
		//获取跟标签dangAn
		Element root=(Element)doc.getElementsByTagName("dangAn").item(0);
		//把tid作为标签的属性 其他数据作为标签的子标签
		Element eleTea=doc.createElement("Teacher");
		eleTea.setAttribute("tid", t.getTid()+"");
		Element eleTname=doc.createElement("tname");
		Element eleTdy=doc.createElement("tdy");
		Element eleTsalary=doc.createElement("tsalary");
		Element eleTsex=doc.createElement("tsex");
		eleTdy.setTextContent(t.getTdy()+"");
		eleTname.setTextContent(t.getTname()+"");
		eleTsalary.setTextContent(t.getTsalary()+"");
		eleTsex.setTextContent(t.getTsex()+"");
		//把子标签添加道父标签下
		eleTea.appendChild(eleTname);
		eleTea.appendChild(eleTsex);
		eleTea.appendChild(eleTsalary);
		eleTea.appendChild(eleTdy);
		root.appendChild(eleTea);
		//把doc刷新道xml文件中
		writeDoc2Xml(doc);
		return 1;
	}
	//获取所有
	public static List<Teacher> getAll() {
		//获取document对象
		Document doc=readXml2Doc();
		//获取所有的Teacher标签
		List<Teacher> list=new ArrayList<Teacher>();
		NodeList nodes=doc.getElementsByTagName("Teacher");
		for (int i = 0; i < nodes.getLength(); i++) {
			Element eleTea=(Element)nodes.item(i);
			//获取tid属性
			int tid=Integer.parseInt(eleTea.getAttribute("tid"));
			//获取子标签的文本内容
			String tname=eleTea.getElementsByTagName("tname").item(0).getTextContent();
			String tsex=eleTea.getElementsByTagName("tsex").item(0).getTextContent();
			boolean tdy=Boolean.parseBoolean(eleTea.getElementsByTagName("tdy").item(0).getTextContent());
			double tsalary=Double.parseDouble(eleTea.getElementsByTagName("tsalary").item(0).getTextContent());
			list.add(new Teacher(tid, tname, tsex, tsalary, tdy));
		}
		return list;
	}
	//获取一个
	public static Teacher getOne(int tid) {
		//获取document对象
		Document doc=readXml2Doc();
		//获取所有的Teacher标签
		NodeList nodes=doc.getElementsByTagName("Teacher");
		for (int i = 0; i < nodes.getLength(); i++) {
			Element eleTea=(Element)nodes.item(i);
			//获取tid属性
			int tidAttr=Integer.parseInt(eleTea.getAttribute("tid"));
			if(tidAttr==tid) {
				//获取子标签的文本内容
				String tname=eleTea.getElementsByTagName("tname").item(0).getTextContent();
				String tsex=eleTea.getElementsByTagName("tsex").item(0).getTextContent();
				boolean tdy=Boolean.parseBoolean(eleTea.getElementsByTagName("tdy").item(0).getTextContent());
				double tsalary=Double.parseDouble(eleTea.getElementsByTagName("tsalary").item(0).getTextContent());
				return new Teacher(tid, tname, tsex, tsalary, tdy);
			}
			
		}
		return null;
	}
	//删除一个
	public static int deleteOne(int tid) {
		//获取document对象
		Document doc=readXml2Doc();
		//获取所有的Teacher标签
		NodeList nodes=doc.getElementsByTagName("Teacher");
		//定义变量记录删除的标签个数
		int hang=0;
		for (int i = 0; i < nodes.getLength(); i++) {
			Element eleTea=(Element)nodes.item(i);
			//获取tid属性
			int tidAttr=Integer.parseInt(eleTea.getAttribute("tid"));
			if(tidAttr==tid) {
				//删除当前标签
				eleTea.getParentNode().removeChild(eleTea);
				hang=1;
				break;
			}
		}
		if(hang==1) {
			writeDoc2Xml(doc);
		}
		return hang;
	}
	//修改一个
	public static int updateOne(Teacher teacher) {
		//获取document对象
		Document doc=readXml2Doc();
		//获取所有的Teacher标签
		NodeList nodes=doc.getElementsByTagName("Teacher");
		//定义变量记录修改的标签个数
		int hang=0;
		for (int i = 0; i < nodes.getLength(); i++) {
			Element eleTea=(Element)nodes.item(i);
			//获取tid属性
			int tidAttr=Integer.parseInt(eleTea.getAttribute("tid"));
			if(tidAttr==teacher.getTid()) {
				//修改当前标签
				eleTea.getElementsByTagName("tname").item(0).setTextContent(teacher.getTname());
				eleTea.getElementsByTagName("tsex").item(0).setTextContent(teacher.getTsex());
				eleTea.getElementsByTagName("tdy").item(0).setTextContent(teacher.getTdy()+"");
				eleTea.getElementsByTagName("tsalary").item(0).setTextContent(teacher.getTsalary()+"");
				hang=1;
				break;
			}
		}
		if(hang==1) {
			writeDoc2Xml(doc);
		}
		return hang;
	}
	//1 读取xml文件为document对象
	public static Document  readXml2Doc(){
		File file=new File(fileName);
		try {
			if(!file.exists()) {
				//创建空的文件
				BufferedWriter bout=new BufferedWriter(new FileWriter(file));
				bout.write("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>");
				bout.newLine();
				bout.flush();
				bout.write("<dangAn> </dangAn>");
				bout.flush();
				bout.close();
			}
			return DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	//2 刷新doc道xml中
	public static void writeDoc2Xml(Document doc) {
		try {
			Transformer tf=TransformerFactory.newInstance().newTransformer();
			tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			tf.setOutputProperty(OutputKeys.INDENT, "yes");
			tf.transform(new DOMSource(doc), new StreamResult(new File(fileName)));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	

}