xml入门

XML简介

（可扩展标记型语言）

XML的应用

• 不同系统之间传输数据

  • qq之间的数据传输
    

• 用来表示生活中有关系的数据
  

• 经常用在文件配置

XML语法

xml的文档声明

• 后缀名：.xml

• 编写xml第一步 必须有文档声明 （写了文档声明之后，表示写xml文件的内容）

  • <?xml version= "1.0" encoding="gbk"?>
  • 文档声明必须写在 第一行第一列

• 属性：

  • version:xml的版本
  • encoding:xml的编码 gbk utf-8 iso8859-1(不包含中文)
  • standalone: 是否需要依赖其他文件 yes/no

• xml的中文乱码问题的解决：
  

  • 保存的时候的编码和设置打开时候的编码一致，就不会出现乱码

• xml的元素（标签）定义：

  • 标签有开始必须要有结束：

  • 标签没有内容，可以在标签内结束：

  • 标签可以嵌套，必须要合理的嵌套

    • 合理嵌套：
    • 不合理的嵌套：

  • 一个xml文件中，只能有一个根标签，其他标签都是这个标签下面的标签

  • 在xml中把换行和空格都当成内容来解析

    • <pagecode>www.baidu.com</pagecode>
      

    • <pagecode>
      	www.baidu.com
      </pagecode>
      

  • xml中标签名称的规则

    • 代码区分大小写
    • 不能以数字与下划线开头
    • 不能以xml、XML、Xml等开头
    • 不能包含空格和冒号

• xml中属性的定义

  • 一个标签可以有多个属性
    • <person id1 =“aaa" id2="“bbb">
  • 属性名称不能相同
  • 属性名称与属性值之间使用= ，属性值使用引号包起来 （可以是单引号，也可以是双引号）
  • 属性的名称规范和元素的名称规范一致

• 注释

  • 语法：
  • 注释不能嵌套
  • 注释不能放在第一行

• 特殊字符：

• CDATA区

  • 可以解决多个字符都需要转义的操作 if(a<b && b<c && d>f)
  • 把这些内容放在CDATA中，就不需要转义
    • 语法：
    • <![CDATA[ 内容]]>
  • 把特殊字符当做文本内容，而不是标签

• PI指令（处理指令）

  • 在xml中设置样式
  • 语法：<?xml-stylesheet type="text.css" href="css的路径"?>
  • 对于中文标签不能起作用，只对英文标签起作用

• xml约束

• xml的约束技术：DTD约束 和 Schema约束

DTD

• 后缀：.dtd

• 操作过程：

  • 看xml中有多少个元素，有几个元素，在dtd中就写几个 <!ELEMENT>

  • 判断元素是简单元素还是复杂元素：

    • 复杂元素：有子元素的元素
      • <!ELEMENT 元素名称 (子元素)>
    • 简单元素：没有子元素
      • <!ELEMENT 元素名称 (#PCDATA)>

  • 在xml文件中导入dtd文件

    • <!DOCTYPE 根元素名称 SYSTEM “dtd文件的路径">
      

  • 浏览器只负责打开，不负责校检约束

• dtd的三种引入方式

  • 引入外部的dtd文件

    • <!DOCTYPE 根元素名称 SYSTEM "dtd文件的路径">
      

  • 使用内部的dtd文件

    • <!DOCTYPE person [
              <!ELEMENT person (name , age )>
              <!ELEMENT name (#PCDATA)>
              <!ELEMENT age (#PCDATA)>
      ]>
      

  • 使用外部dtd文件(网络上的dtd文件)

    • <!DOCTYPE 根元素名称 PUBLIC "DTD名称" "DTD文档的URL">
      

• dtd定义元素

  • 语法：<!ELEMENT 元素名 约束>

  

  • <?xml version="1.0" encoding="UTF-8"?>
    <!--<!DOCTYPE person SYSTEM "DemoTest.dtd">-->
    <!DOCTYPE person [
            <!ELEMENT person (name+ , age? ,sex* , prodate)>
            <!ELEMENT name (#PCDATA)>
            <!ELEMENT age (#PCDATA)>
            <!ELEMENT sex EMPTY>
            <!ELEMENT prodate ANY>
    ]>
    <person>
        <name>zhangsan</name>
        <age>18</age>
        <sex></sex>
        <prodate>1232345,./</prodate>
    </person>
    

• dtd属性的定义

  • 语法：

    <!ATTLIST 元素名称
        属性名称 属性类型 属性约束
    >
    

  • 属性类型：

    • CDATA :字符串

    • <!ATTLIST name
         name1 CDATA #REQUIRED
      >
      

  • ENUMERATE ：表示只能在一定范围内出现的值，但是只能每次出现其中的一个

    • <!ATTLIST sex
              gender (male|female) #REQUIRED
      >
      

  • ID :值只能是字母或者下划线开头

    • <!ATTLIST age
          age1 ID #REQUIRED
      >
      

  • 属性的约束

    • REQUIRED：属性必须存在

    • IMPLIED：属性可有可无

    • FIXED：表示一个固定的值 #FIXED “AAA”

      • 属性值必须是设置的这个固定值

      •  <!ATTLIST brithday
                    BD CDATA #FIXED "4-22"
                >
        

    • 直接值：

      • 不写属性，使用直接值

      • 写了属性，使用设置的那一个值

      • <!ATTLIST brithday
           BD CDATA "4-22"
        >
        

  • 实体的定义、

    • 语法：<!ENTITY 实体名称 “实体的值">
    • 引用 ： &实体名称;
    • 定义实体需要写在内部dtd里面

XML解析

XML解析简介

• xml的解析方式（技术）：dom 和 sax

1、dom方式解析

• 根据xml的层次结构在内存中分配一个树形结构，把xml的标签、属性和文本都封装成对象
• 优点：方便实现增删改操作
• 缺点：如果文件过大，造成内存溢出

2、sax方式解析

• 采用事件驱动，边读边解析
  • 从上到下，一行一行的解析，解析到某一个对象，返回对象的名称
• 优点：如果文件过大，不会造成内存溢出，方便执行查询操作
• 缺点：不能实现增删改操作

jaxp

1、API的查看

• jaxp解析器在jdk的javax.xml.parsers包里面

######1.1 、dom

DocumentBuilder:解析类（abstract）

• 此类的实例可以从 DocumentBuilderFactory.newDocumentBuilder() 方法获取

• 解析xml： public Document parse(String uri)throws SAXException,IOException 返回Document (interface)-> Superinterface Node

• Document

  • 得到标签：public NodeList getElementsByTagName(String tagname)；
  • 创建标签：public Element createElement(String tagName)throws DOMException；
  • 创建文本：public Text createTextNode(String data)；

• Node：

  • 把文本添加在标签下面：public Node appendChild(Node newChild)throws DOMException；
  • 删除节点：public Node removeChild(Node oldChild)throws DOMException；
  • 获得父节点：public Node getParentNode()；
  • 得到标签下的文本：public String getTextContent()throws DOMException;

• NodeList:(List)

  • 获取集合的长度：public int getLength()；

  • 下标取得具体的值：public Node item(int index)；

  • for(int i = 0 ; i <List.getLength(); i++){
    	i.item(i);
    }
    

DocumentBuilderFactory:解析工厂(abstract)

• 获取对象实例：public static DocumentBuilderFactory newInstance()；

1.2、sax

SAXParser：解析类

SAXParserFactory：解析工厂

2、jaxp查询节点

package in.itcast.jaxpTest;

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

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

public class JaxpDemo {
	public static void main(String[] args) throws Exception {
		/**
		 * 1.创建解析共产
		 * 2.根据解析共产创建解析器
		 * 3.解析xml,返回Document
		 * 4.得到标签->NodeList
		 * 5.遍历NodeList，得到每一个name元素
		 * 
		 */
		//创建解析工厂
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
		// 创建解析器
		DocumentBuilder builder = builderFactory.newDocumentBuilder();
		//解析xml,返回Document
		Document document = builder.parse("src/person.xml");
		//得到标签(name) -> NodeList
		NodeList nodeList = document.getElementsByTagName("name");
		for(int i = 0 ; i < nodeList.getLength() ; i++) {
			Node node = nodeList.item(i);  // 得到每一个name的元素
			String strName = node.getTextContent(); //得到name标签下的值
			System.out.println(strName);
		}
		
		
	}
}

3、得到具体的某一标签下的文本

4、添加节点

// 在<p1>标签下存<sex>male</sex>
	public static void addNode() throws Exception{
		/**
		 * 1.创建解析共产
		 * 2.根据解析共产创建解析器
		 * 3.解析xml,返回Document
		 * 4.得到第一个p1
		 * 5.创建sex标签 createElement
		 * 6.创建文本 createTextNode
		 * 7.将文本添加到sex下appendChild
		 * 8.将sex添加到第一个p1下
		 * 9.回写xml
		 */
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = builderFactory.newDocumentBuilder();
		Document document = builder.parse("src/person.xml");
		
		NodeList nodeList = document.getElementsByTagName("p1");
		Node node = nodeList.item(0);
		
		//创建sex标签 createElement
		Element element =document.createElement("sex");
		//创建文本 createTextNode
		Text text = document.createTextNode("male");
		//将文本添加到sex下appendChild
		element.appendChild(text);
		//将sex添加到第一个p1下
		node.appendChild(element);
		//回写xml
		TransformerFactory transformerFactory = TransformerFactory.newInstance();
		Transformer transformer = transformerFactory.newTransformer();
		transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
	}

回写xml：public abstract void transform(Source xmlSource,Result outputTarget)throws TransformerException

Source: DOMSource 、 JAXSource 、 SAXSource 、StAXSource

Result: StreamSource

DOMSource: public DOMSource(Node n)

StreamSource: public StreamSource(String systemId)

5、修改节点

修改文本内容：public void setTextContent(String textContent)throws DOMException

	// 修改<sex></sex>文本的内容
	public static void modifySex() throws Exception{
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = builderFactory.newDocumentBuilder();
		Document document = builder.parse("src/person.xml");
		
		NodeList nodeList = document.getElementsByTagName("sex");
		Node node = nodeList.item(0);
		node.setTextContent("female");// 修改文本内容 
		
		//回写xml
		TransformerFactory transformerFactory = TransformerFactory.newInstance();
		Transformer transformer = transformerFactory.newTransformer();
		transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
	}

6、删除节点

获取节点的父节点：public Node getParentNode()；

删除当前节点：public Node removeChild(Node oldChild)throws DOMException；

	public static void deleteSex() throws Exception{
		/**
		 * 1.创建解析共产
		 * 2.根据解析共产创建解析器
		 * 3.解析xml,返回Document
		 * 4.得到sex标签
		 * 5.获取sex标签的父标签
		 * 6.通过sex父标签删除sex  removeChild()
		 * 7.回写xml
		 * 
		 */
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = builderFactory.newDocumentBuilder();
		Document document = builder.parse("src/person.xml");
		
		Node node = document.getElementsByTagName("sex").item(0);
		Node nodeParent = node.getParentNode();
		nodeParent.removeChild(node);
		
		TransformerFactory transformerFactory = TransformerFactory.newInstance();
		Transformer transformer = transformerFactory.newTransformer();
		transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
		
	}

7、遍历节点

节点类型：public short getNodeType()；

获取节点名字：public String getNodeName()；

节点类型属性（short） :public static final short ELEMENT_NODE (The node is an Element.)

//遍历节点
	public static void TraverseElement() throws Exception{
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = builderFactory.newDocumentBuilder();
		Document document = builder.parse("src/person.xml");
		/**
		 * 	得到根节点
		 *	得到根节点的子节点
		 *	得到根节点的子节点的子节点 	
		 */
		recursionElement(document); //递归方法
		
	}
	//recursionElement() 
	private static void recursionElement(Node node) {
		//判断元素类型
		if(node.getNodeType() == Node.ELEMENT_NODE) {
			System.out.println(node.getNodeName());
		}
		//得到一层子节点
		NodeList nodeList = node.getChildNodes();
		for(int i = 0 ; i < nodeList.getLength() ; i++) {
			Node nodeFirst = nodeList.item(i);
			//nodeFirst.getChildNodes();
			recursionElement(nodeFirst);// 递归
		}
	}

Schema

1、简介

2、开发过程

2.1 schema文件的后缀名： xsd

在schema文件里面

• 属性：
  • xmlns=“http://www.w3.org/2001/XMLSchema”
  • 表示当前xml文件是一个约束条件
  • targetNamespace=“http://www.itcast.com/Canoe”
    • 使用schema约束条件，直接通过这个地址引入约束文件
  • elementFormDefault=“qualified”

2.2 操作流程

1. 看xml文件中有多少个元素

2. 看简单元素和复杂元素

   • 复杂元素

     <complexType>
     	<sequence>
     		子元素
     	</sequence>
     </complexType>
     

   • 简单元素（写在复杂元素里面）

     <complexType>
     	<sequence>
     		<element name="name" type="string"></element>
     		<element name="age" type="int"></element>
     	</sequence>
     </complexType>
     

3. 在被约束文件里面引入约束文件

   <person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://www.itcast.com/Canoe"
   xsi:schemaLocation="http://www.itcast.com/Canoe First.xsd">
   

   • xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
     • 表示xml是一个约束文件
   • xmlns=“http://www.itcast.com/Canoe”
     • 是约束文件里面的 targetNamespace
   • xsi:schemaLocation=“http://www.itcast.com/Canoe First.xsd”
     • targetNamespace 空格 约束文件的地址路径

4. 约束与被约束的实现过程图
   

3、schema约束 API查看

写在之中

• :表示元素出现的顺序

• :元素只能出现一次

• :元素只能出现其中的一个

• maxOccurs=“unbounded”:表示元素的出现次数（不限次数）

• :任意元素

  约束属性：

  • 写在复杂元素里面

  • 写在之前

    <attribute name="id1" type="int" use="required"></attribute>
    

    • name:属性名称
    • type:属性类型
    • use:属性是否必须出现

• 复杂的schema约束：

  • 导入多个.xsd文件作为xml的约束文件
  • 可以给每一个schema文件起一个别名 (:名称)

  

Sax解析

1、解析过程

• 方式：事件驱动，边读边解析

• 路径：javax.xml.parsers

  SAXParser ：

  • ​ 此类可以从SAXParserFactory.newInstance()方法获得
  • 解析：public void parse(File f,DefaultHandler dh)throws SAXException,IOException
    • File:xml的路径
    • DefaultHandler:事件处理器

  SAXParserFactory：

  • 实例：public static SAXParserFactory newInstance()

• 执行过程：

  • 当解析到开始标签的时候，自动执行 public void startElement(String uri,String localName,String qName,Attributes attributes)
    throws SAXException
  • 当解析到文本的时候，自动执行 public void characters(char[] ch,int start,int length)throws SAXException
  • 当解析到结束标签的时候，自动执行 public void endElement(String uri,String localName,String qName)throws SAXException

2、Sax操作xml查询

package in.itcast.jaxp.Sax;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class Demo {

	public static void main(String[] args) throws Exception{
		/**
		 * 	创建解析工厂
		 * 	创建解析器
		 * 	执行parse()
		 * 	
		 * 	自定义一个类 继承DefaultHander
		 * 	Override  startElement()、characters()、endElement
		 */
		SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
		SAXParser saxparser = saxParserFactory.newSAXParser();
		saxparser.parse("src/person.xml", new MyDefaultHanderName());

	}
}

//打印name标签下的文本
class MyDefaultHanderName extends DefaultHandler{
	private boolean flag = false;  // 
	private int index = 0 ; 
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		//判断qName是否为name标签
		if("name".equalsIgnoreCase(qName)) {
			this.flag = true;
		
		}
	}
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		//当flag=true ，解析name下的文本
		// 当index =0 时 解析第一个name下的值
		if(flag == true && index == 0) {
			System.out.println(new String(ch , start , length));
		}
	}
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		if("name".equalsIgnoreCase(qName)) {
			flag = false;
			index ++;
		}
	}
	
}

// 打印整个xml文件
class MyDefaultHander extends DefaultHandler{

	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		System.out.print("<" + qName + ">");
	}
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		System.out.print(new String(ch, start, length));
	}
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		System.out.print("</" + qName + ">");
	}
}

dom4j

1、简介

• 得到Document：

  • SAXReader reader = new SAXReader()
    Document document = reader.read(url)
    

  • public Document read(java.net.URL url)throws DocumentException；

2、查询xml

• Element：

  • public Element element(QName qName)
    • 获取标签下的第一个字标签
    • qName：标签名称
  • public java.util.List elements(QName qName)
    • 获取标签下这个名称的所有子标签（一层）
  • public java.util.List elements()
    • 获取标签下面所有一层的子标签
  • public java.lang.String getText()
    • 得到标签下的文本
  • public Element addElement(QName qName)
    • 添加标签

• 查询所有name

  	// 遍历所有的 name
  	public static void TraverseEelement() throws Exception {
  		
  		/**
  		 * 创建解析器
  		 * 得到Document
  		 * 得到根节点
  		 * 
  		 * 得到p1
  		 * 得到p1下面的name
  		 * 得到name下面的文本
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Dom4jPerson.xml");
  		//得到根节点
  		Element RootElement= document.getRootElement();
  		List<Element> FirstElement = RootElement.elements("p1");
  		//遍历
  		for(Element SecondeElement: FirstElement) {
  			
  			Element elementName = SecondeElement.element("name");
  			String strName = elementName.getText();
  			System.out.println(strName);
  		}
  //		Iterator<Element> iter = FirstElement.iterator();
  //		while(iter.hasNext()) {
  //			Element eI = iter.next();
  //			Element eN = eI.element("name");
  //			String strN = eN.getText();
  //			System.out.println(strN);
  //		}
  		
  		
  	}
  

• 查询第一个name

  // 得到第一个name
  	public static void selectSingleName() throws Exception{
  		/**
  		 * 创建解析器
  		 * 得到Document
  		 * 得到根节点
  		 * 
  		 * 得到第一个p1标签
  		 * 得到p1下面的name元素
  		 * 得到name下面的内容
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Dom4jPerson.xml");
  		Element rootElement = document.getRootElement();
  		
  		Element FirstElement = rootElement.element("p1");
  		Element elementName = FirstElement.element("name");
  		String strName = elementName.getText();
  		System.out.println(strName);
  		
  	}
  

• 查询第二个name

  // 得到第二个name
  	public static void selectSecondName() throws Exception{
  		
  		/**
  		 * 创建解析器
  		 * 得到Document
  		 * 得到根节点 
  		 * 
  		 *	得到所有的p1
  		 *	遍历得到第二个p1
  		 *	得到第二个p1下面的name
  		 *	得到name的值
  		 *
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Dom4jPerson.xml");
  		Element rootElement = document.getRootElement();
  		
  		List<Element> listElement = rootElement.elements("p1");
  		//得到第二个p1
  		Element SecondeElement = listElement.get(1);
  		Element elementName = SecondeElement.element("name");
  		String strName = elementName.getText();
  		System.out.println(strName);
  	}
  

3、末尾添加节点

• 回写xml

  • OutputFormat:
    • public static OutputFormat createPrettyPrint()
      • 缩进的格式
    • public static OutputFormat createPrettyPrint()
      • 压缩的格式
  • XMLWriter：
    • public XMLWriter(java.io.OutputStream out,OutputFormat format)throws java.io.UnsupportedEncodingException
      • out: -> new FileOutputStream(“”)
      • format : 格式化的值

4、在指定位置添加节点

/**
	 * 创建解析器
	 * 得到Document
	 * 得到根节点
	 * 获取第一个p1
	 * 获取第一个p1下面的 所有内容
	 * 		**elements(),返回list
	 * 		**创建元素 使用DocumentHelper 类  createElement()
	 * 		**创建文本 sexText()
	 * 		**使用list里面的add()在指定的位置添加元素
	 *  
	 */

	//在age前面添加school
	public static  void addAgeBefore() throws Exception{
		
		/**
		 * 创建解析器
		 * 得到Document
		 * 得到根节点
		 * 获取第一个p1
		 * 获取第一个p1下面的 所有内容
		 * 		**elements(),返回list
		 * 		**创建元素 使用DocumentHelper 类  createElement()
		 * 		**创建文本 sexText()
		 * 		**使用list里面的add()在指定的位置添加元素
		 *  
		 */
		SAXReader reader = new SAXReader();
		Document document = reader.read("src/Dom4jPerson.xml");
		Element rootElement = document.getRootElement();
		
		Element p1 = rootElement.element("p1");
		//获得P1下面所有元素
		List<Element> list = p1.elements();
		//创建元素
		Element school = DocumentHelper.createElement("school");
		// 设置文本
		school.setText("git");
		list.add(1,school);
		//回写xml
		OutputFormat format = OutputFormat.createPrettyPrint();
		XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/Dom4jPerson.xml"), format);
		xmlWriter.write(document);
		xmlWriter.close();
	}

5、dom4j封装方法

6、dom4j实现修改操作

//修改第一个p1下面的age值
	public static void modifyAge() throws Exception{
		
		/**
		 * 创建解析器
		 * 得到Document
		 * 得到根节点
		 * 获取第一个p1 
		 * 获取age
		 * 设置age的值
		 * 回写xml
		 */
		Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
		Element root = document.getRootElement();
		Element p1 = root.element("p1");
		Element age = p1.element("age");
		age.setText("30");
		Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
	}

7、dom4j删除节点

	// 删除school
	public static void deleteSchool() throws Exception{
		/**
		 * 创建解析器
		 * 得到Document
		 * 得到根节点
		 * 获取第一个p1
		 * 
		 * 得到school 
		 * 通过school父节点删除
		 * 回写xml
		 */
		Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
		Element root = document.getRootElement();
		Element p1 = root.element("p1");
		Element school = p1.element("school");
		//school.getParent(); // 获取父节点
		// 父节点删除子节点
		p1.remove(school);
		Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);
	}

9、获取属性

• 获取元素的属性：public java.lang.String attributeValue(java.lang.String name)
  -

	//获取p1下面的属性id1值
	public static void getValues() throws Exception{
		/**
		 * 创建解析器
		 * 得到Document
		 * 得到根节点
		 * 获取第一个p1 
		 * 得到p1里面的属性 
		 */
		Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
		Element root = document.getRootElement();
		Element p1 = root.element("p1");
		//得到p1里面的属性
		String str = p1.attributeValue("id1");
		System.out.println(str);
	}

XPATH

1、简介

• 第一种形式：
  • /AAA/DDD/BBB : 一层一层的 ， AAA下面的DDD下面的BBB
• 第二种形式
  • //BBB : 表示和这个名称相同，表示只要名称是BBB ，都得到
• 第三种形式
  • /* : 所有的元素
• 第四种形式
  • BBB[1] : 表示第一个BBB元素
  • BBB[last()] :表示最后的一个BBB元素
• 第五种形式
  • //BBB[@id] : 表示BBB元素上面有id属性 ，都可以得到
• 第六种形式
  • //BBB[@id=’b1’] : 表示名称是BBB ，在BBB上面有id属性，并且id属性值是b1

2、操作

• 获取多个节点：public java.util.List selectNodes(java.lang.Object context)

  • 参数 XPATH表达式

• 获取一个节点：public Node selectSingleNode(java.lang.Object context)

  • 参数XPATH表达式

• 

案例

• StudentService

  package in.itacat.student.service;
  
  import java.io.FileOutputStream;
  import java.util.Iterator;
  import java.util.List;
  
  import org.dom4j.Document;
  import org.dom4j.Element;
  import org.dom4j.io.OutputFormat;
  import org.dom4j.io.SAXReader;
  import org.dom4j.io.XMLWriter;
  import in.itcast.vo.Student.Student;
  
  public class StudnetService {
  	// 添加
  	public static void addStu(Student student) throws Exception{
  		/**
  		 * 创建解析器
  		 * 得到document
  		 * 获取根节点
  		 * 在根节点上面创建stu标签
  		 * 在stu标签上面依次添加id,name,age
  		 * 在id,name,age上面依次添加文本
  		 * 
  		 * 回写xml
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Student.xml");
  		Element rootElement = document.getRootElement();
  		//添加标签
  		Element stu = rootElement.addElement("stu");
  		
  		Element id = stu.addElement("id");
  		Element name = stu.addElement("name");
  		Element age = stu.addElement("age");
  		// 添加至、值
  		id.setText(student.getId());
  		name.setText(student.getName());
  		age.setText(student.getAge());
  		//回写xml
  		OutputFormat format = OutputFormat.createPrettyPrint();
  		XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/Student.xml"), format);
  		xmlWriter.write(document);
  		xmlWriter.close();
  	}
  	
  	// 删除  根据学生id删除
  	public static void deleteID(String id) throws Exception{
  		/**
  		 * 创建解析器
  		 * 得到document 
  		 * 
  		 * 获取所有的id 
  		 * 使用xpath //id  返回list
  		 * 遍历list
  		 * 判断集合里的id和传递的id是否相同
  		 * 如果相同 把 id所在的stu删除
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Student.xml");
  		Element root = document.getRootElement();
  		
  		List<Element> stu = root.elements("stu"); //获取全部stu
  		for (Element element : stu) {
  			List<Element> listId = element.elements("id"); //获取所有id
  			for (Element element2 : listId) {
  				String IdValues = element2.getText(); // 获取id的值
  				if(IdValues.equals(id)) { // 判断id的值与传入的id值
  					Element parentEle = element2.getParent(); //找到id的父节点 stu
  					Element schoolEle = parentEle.getParent();// 找到stu的父节点 school
  					schoolEle.remove(parentEle); // 通过school 删除stu节点 
  				}
  			}
  		}
  		//回写xml
  		OutputFormat format = OutputFormat.createPrettyPrint();
  		XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/Student.xml"), format);
  		xmlWriter.write(document);
  		xmlWriter.close();
  	}
  	
  	// 查询 根据id 查询学生信息
  	public static Student getStudent(String id) throws Exception{
  		/**
  		 * 创建解析器
  		 * 得到Document
  		 * 获取所有的id  List
  		 * 遍历list 得到每一个id节点
  		 * 判断id节点的值是否与传递的id的值相同
  		 * 如果相同 获取id的父节点stu
  		 * 通过stu获取name 、 age
  		 */
  		SAXReader reader = new SAXReader();
  		Document document = reader.read("src/Student.xml");
  		Element root = document.getRootElement();
  		List<Element> stuEle = root.elements("stu"); //获取全部stu
  		Iterator<Element> iterStu = stuEle.iterator(); // 迭代器
  		Student student = new Student();  // 实例Student对象
  		while(iterStu.hasNext()) {
  			Element element = iterStu.next();
  			List<Element> idEle = element.elements("id"); // 获取全部id
  			Iterator<Element> iterId = idEle.iterator();
  			while(iterId.hasNext()) {
  				Element stuId = iterId.next(); 
  				String valuesId = stuId.getText(); // 获取id文本
  				if(valuesId.equals(id)) {  // 判断
  					Element parentStu = stuId.getParent(); // 获取id父节点
  					Element name = parentStu.element("name"); // 获取name 
  					String strName = name.getText();  // 获取文本
  					Element age = parentStu.element("age"); // 获取age
  					String strAge = age.getText();// 获取文本
  					
  					student.setId(valuesId); //获取对应的值
  					student.setName(strName);
  					student.setAge(strAge);
  				}
  			}
  		}
  		return student;
  	}
  }
  
  

• TestStudent

  package in.itcast.TestStudent;
  
  import in.itacat.student.service.StudnetService;
  import in.itcast.vo.Student.Student;
  
  public class TestStudent {
  	public static void main(String[] args) throws Exception {
  		//addStuTest(); // 添加
  		//delete(); // 删除
  		select();// 查询
  	}
  	// 添加
  	public static void addStuTest() throws Exception {
  		Student student = new Student("1003","wangwu","30");
  		StudnetService.addStu(student);
  	}
  	// 删除
  	public static void delete() throws Exception{
  		StudnetService.deleteID("1001");
  	}
  	// 查询
  	
  	public static void select() throws Exception {
  		Student stu = StudnetService.getStudent("1002");
  		System.out.println(stu.toString());
  	}
  }
  

• Student.xml

  <?xml version="1.0" encoding="UTF-8"?>
  
  <student> 
  	<stu> 
      <id>1001</id>  
      <name>zhangsan</name>  
      <age>19</age> 
    </stu> 
    <stu> 
      <id>1002</id>  
      <name>lisi</name>  
      <age>18</age> 
    </stu>  
    <stu> 
      <id>1003</id>  
      <name>wangwu</name>  
      <age>30</age> 
    </stu> 
  </student>
  

student.setName(strName);

				student.setAge(strAge);
			}
		}
	}
	return student;
}

}

• TestStudent

  package in.itcast.TestStudent;
  
  import in.itacat.student.service.StudnetService;
  import in.itcast.vo.Student.Student;
  
  public class TestStudent {
  	public static void main(String[] args) throws Exception {
  		//addStuTest(); // 添加
  		//delete(); // 删除
  		select();// 查询
  	}
  	// 添加
  	public static void addStuTest() throws Exception {
  		Student student = new Student("1003","wangwu","30");
  		StudnetService.addStu(student);
  	}
  	// 删除
  	public static void delete() throws Exception{
  		StudnetService.deleteID("1001");
  	}
  	// 查询
  	
  	public static void select() throws Exception {
  		Student stu = StudnetService.getStudent("1002");
  		System.out.println(stu.toString());
  	}
  }
  

• Student.xml

  <?xml version="1.0" encoding="UTF-8"?>
  
  <student> 
  	<stu> 
      <id>1001</id>  
      <name>zhangsan</name>  
      <age>19</age> 
    </stu> 
    <stu> 
      <id>1002</id>  
      <name>lisi</name>  
      <age>18</age> 
    </stu>  
    <stu> 
      <id>1003</id>  
      <name>wangwu</name>  
      <age>30</age> 
    </stu> 
  </student>