　　(1) 不同技术，XML配置文件的作用也不一样。

　　(2) 比如当前和这个阶段的web.xml，就是用来做Servlet等相关组件配置中心的主配置文件来使用。

2、数据传输：数据传输的媒介

　　(1) 、例如是A公司将他们的数据用JAva语言创建成XML文件，然后B公司用C#语言对XML文件进行解析，就可以得到A公司的保存在XML文件中的数据了。

　　(2) 、我们未来的实际项目开发，前端和后端分工明确，后端(Java）连JDBC，将数据从数据库表中取出，然后将数据传输到前端(HTML)，前端显示这些从数据库表中取出的数据。

　　(3) 、综上：对于数据传输这方面，未来后端为前端做数据传输是经常用到的，我们使用数据传输的媒介来完成，但是在我们的实际项目开发中，我们有更好的方式来代替XML的形式做数据传输，我们用的是JSON。

3、基础语法：

　　(1) 文档必须以<?xml开头，必须以?>结尾

　　(2) 文档声明必须在文档中的0行0列

　　(3) 文档声明的3个属性：

　　　　version属性：指定xml文档版本，必须属性，因为我们不会选择1.1，只会选择1.0.

　　　　encoding属性：指定当前文档的编码，可选属性，默认是utf-8；

　　　　Standalone属性：指定文档独立性。可选属性，默认为yes，表示当前文档是独立文档，如果为no，则是非独立文档，会依赖外部文件。

　　(4) 空元素的标签必须要自己闭合，不然整篇xml文档直接报废的。

　　(5) 良好的xml文档，必须要有一个根元素【有且仅有一个】

(6) 注释： 

　　(7) 对于一些转义字符，我们要使用对应的替代

　　　　<：对应小于号

　　　　>：对应大于号

　　　　&：对应&

　　　　&apos：对应单引号

　　　　"：对应双引号

　　(8) CDATA区

　　　　<![CDATA][xxxxxxxx中间的是我们本来是要用转义字符输出的，写在这里面就不用转义字符，可以直接输出了，不会出现冲突的xxxxxxx]]>

4、 xml文档解析：

　　(1)、sax解析

　　(2)、dom解析

　　(3)、dom4j:实际开发中最常用的开发包：

5、必须使用核心类SaxReader加载xml文档获得Document，通过Document对象获得文档的根元素，然后就可以继续操作。

6、具体的操作步骤

　　a.导入jar包

　　b.创建一个核心对象 SAXReader 　　 --------new SAXReader();　

　　c.将xml文档加载到内存中形成一棵树 --------------Document doc=reader.read(文件)

　　d.获取根节点　　　　　　　　　　 ---------------------Element root=doc.getRootElement();

　　e.通过根节点就可以获取其他节点(文本节点,属性节点, 元素节点)

　　　　获取所有的子元素 -----------------List<Element> list=root.elements()

　　f.element.elementText("id"); 来得到子元素中的内容，通过子元素的节点名字来得到。

7、还有一个dom4j的扩充方法 xPath，可以直接通过xml文件中的单个标签路径来得到信息。

　　事例：

　　Element element_childer = (Element)element_root.selectSingleNode("//body_01//childer_02");

下面是一个我用来实验的小示例：

　　注意：要导入对应的开发包dom4j和jaxen包

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.xml.sax.SAXException;

/**
 * 这个是对xml的读、写进行的操作
 * 使用的是dom4j这个jar来进行的操作
 * 工具：jaxen-1.1-beta-6.jar  dom4j-1.6.1.jar
 * 读的时候使用了两种方法来进行读，具体需求看情况来定
 * @author TurtleZhang 
 *
 */
public class ExerciseXMlDemo {

    public static void main(String[] args) throws IOException, SAXException, DocumentException {
        //1----writer
        writerXml();

        //2----readere
        readerXml_01();

        //3----reader
        readerXml_02();
        
        //3---reader
        readerXml_03();
    }

    /**
     * 模拟往文件中写入xml格式的内容
     * 这个是自己创建好xml格式，填好数据，然后写入xml文件中
     * @throws IOException 
     */
    private static void  writerXml() throws IOException {

        //1----创建一个document文档，用来对xml进行操作写入
        Document document = DocumentHelper.createDocument();      

        //2-----创建了一个根节点，推荐每个xml文档都有一个root，根节点
        Element root = document.addElement("root");

        //3------在root根节点下面创建了一个子节点
        Element body_01 =  root.addElement("body_01");

        //4-------在第二层的子节点【元素】上添加所表示的文本信息
        for(int i=0;i<5;i++) {
            Element childer =  body_01.addElement("childer_0"+i);

            childer.addText(Integer.toString(i));
        }

        //3------重复上面的操作
        Element body_02 = root.addElement("body_02");

        //4-------重复上面的操作
        for(int i=0;i<5;i++) {
            Element childer =  body_02.addElement("childer_0"+i);
            childer.addText(Integer.toString(i));
        }


        //5---进行文件的写入  ,创建写入文件流

        FileOutputStream fileOutputStream = new FileOutputStream("test_01.xml");

        //6---用一个好看的写入格式
        OutputFormat outputFormat=OutputFormat.createPrettyPrint();

        //6---创建，配置用来写入xml文件的xml文件写入流
        XMLWriter xmlWriter=new XMLWriter(fileOutputStream,outputFormat);

        //7-----进行xml文件的写入
        xmlWriter.write(document);

        //8-----写入完成，将文件进行关闭
        xmlWriter.close();

    }

    /**
     * 第一种读取方式，也是传统的读取方式，通过循环来进行读取
     * @throws SAXException 
     * @throws DocumentException 
     */
    @SuppressWarnings("unchecked")
    private static void readerXml_01() throws SAXException, DocumentException {

        //1------创建一个用来读取的核心类
        SAXReader saxReader=new SAXReader();
        
        //2-------读取到对应的xml文档
        Document document= saxReader.read("test_01.xml");

        //3------通过xml文档来读取到根节点
        Element element_Root= document.getRootElement();
        System.out.println("根节点是"+element_Root.getName());

        //4-----通过根节点来得到里面的子节点
        List<Element> element_Bodys= element_Root.elements();

        //下面的代码只是单纯的用来读取数据测试，没有任何实际作用的
        //一般来说是配合xml文档的格式，我们会创建一个与之对应的类来进行数据的读取与保存
        for(Element element : element_Bodys) {
            
            //5----得到节点的名字
            String body=element.getName();
            
            //6----得到节点的值
            String childer_00=element.elementText("childer_00");
            String childer_01=element.elementText("childer_01");
            String childer_02=element.elementText("childer_02");
            String childer_03=element.elementText("childer_03");
            String childer_04=element.elementText("childer_04");

            //7---通过StringBuilder来进行字符串的连接
            StringBuilder stringBuilder=new StringBuilder();

            stringBuilder.append("第一个子节点:");
            stringBuilder.append(body);
            stringBuilder.append("	第一个元素值:");
            stringBuilder.append(childer_00);

            stringBuilder.append("	第二个元素值:");
            stringBuilder.append(childer_01);

            stringBuilder.append("	第三个元素值:");
            stringBuilder.append(childer_02);

            stringBuilder.append("	第四个元素值:");
            stringBuilder.append(childer_03);

            stringBuilder.append("	第无个元素值:");
            stringBuilder.append(childer_04);

            System.out.println("我们读到的集合中的数据为："+stringBuilder.toString());
        }
    }


    /**
     * 小事例
     * @throws DocumentException 
     */
    @SuppressWarnings("unchecked")
    private static void readerXml_02() throws DocumentException {
        
        //1------创建一个用来读取的核心类
        SAXReader saxReader=new SAXReader();
        
        //2-------读取到对应的xml文档
        Document document= saxReader.read("test_01.xml");

        //3------通过xml文档来读取到根节点
        Element element_Root= document.getRootElement();
        System.out.println("根节点是"+element_Root.getName());

        //4-----通过根节点来得到里面的子节点
        List<Element> element_Bodys= element_Root.elements();
        
        //将数据保存到Node类中,，也只是做个测试而已，具体的看需求而定    
        ArrayList<Node> nodes=new  ArrayList<Node>();

        for(Element e: element_Bodys) {
            Node node=new Node();

            node.setChilder_00(Integer.parseInt(e.elementText("childer_00")));
            node.setChilder_01(Integer.parseInt(e.elementText("childer_01")));
            node.setChilder_02(Integer.parseInt(e.elementText("childer_02")));
            node.setChilder_03(Integer.parseInt(e.elementText("childer_03")));
            node.setChilder_04(Integer.parseInt(e.elementText("childer_04")));

            nodes.add(node);
        }        
        for(Node n : nodes) {
            System.out.println(n.toString());
        }
    }

    
    
    /**
     * 第二种读取方式，通过对传统的dom4j的循环读取方式的扩充，是使用指定的标签来进行读取
     * @throws DocumentException 
     */
    private static void readerXml_03() throws DocumentException {

        //1------创建一个用来读取的核心类
        SAXReader reader=new SAXReader();
        
        //2-------读取到对应的xml文档
        Document document=reader.read("test_01.xml");
        
        //3------通过xml文档来读取到根节点
        Element element_Root= document.getRootElement();
        
        //这个时候可以使用扩充功能，就直接使用标签名来进行 元素的取得         selectSingleNode  这个就是单独得到我们指定名字的标签
        Element element = (Element)element_Root.selectSingleNode("//body_01//childer_02");
        //输出测试
        System.out.println("元素名:"+element.getName()+"		元素值为:"+element.getText());
    }
}

总结：在我们实际项目开发中：

　　如果需求为解析出xml中所有的数据，那么我们使用传统的dom4j的形式来完成。

　　如果需求为快速的找到xml中的某一个元素，那么我们使用xpath的形式来完成比较容易

　　XML和JSON都可以完成不同系统之间数据交换。

　　XML体积较大，解析难度较大，所以在现代开发中通常采用 JSON进行数据交换，因为JSON体积小，解析简单，而XML通常充当系统当中的配置文件

注意：

　　1、xpath的形式是传统dom4j形式的扩充，不能独立存在

　　2、xpath的使用必须导入jaxen-1.1-beta-6.jar包才能使用

　　3、jaxen-1.1-beta-6.jar包必须依附于传统的dom4j的Jar包才能使用，不能独立存在。