XML可扩展的标记语言 CDATA标记 XML的解析 SAX解析 使用JDOM的解析 DOM4J

XML：可扩展的标记语言
HTML：超文本标记语言

xml与HTML的区别
比较的内容         HTML           XML
可扩展性        不具备扩展性     具备扩展性

侧重点         侧重于显示信息    侧重于描述信息

语法要求       不要求标记的嵌套  严格要求嵌套、配对                        
              不要求标记的配对  遵循一定的结构顺序的              
              不要求标记之间
              具有一定的顺序
              
可读性         难于阅读、维护   结构清晰的便于阅读以及维护

数据和显示关系  内容与描述混合   内容的描述与显示相分离
               在一起

保值性         不具备保值性       具有保值性

XML文件的组成：
由前导区以及数据区组成的

• 前导区有以下三种属性构成：
  version:表示使用的XML版本，一般都是从1.0开始
  encoding:页面中使用文字的编码，如果有中文则要指定相对应的支持中文的编码。
  standalone:此XML文件是否独立运行，需要进行显示可以使用CSS或XSL控制。
  注意：在进行XML前导区声明的时候，其中的3个属性必须按照固定的顺序编写。
• 数据区：
  所有的数据区必须有一个根元素，一个根元素下面可以存放多个子元素，
  但是要求每一个元素都必须完结，每一个标记都是区分大小写的。

CDATA标记：
用来标识文件数据，当XML解析器处理到CDATA标记的时候，它不会解析该段数据中的任何符号以及标记，只是将原数据原封不动的传递给应用程序。
CDATA标记的语法：<![CDATA[不需要解析的内容]]>

XML的解析：
在XML中由于更多的是描述信息的内容，所以在得到一个XML文档后应该利用程序按照其中元素的定义名称取出对应的内容，这样的操作就称为XML的解析。

在XML的解析中，W3C给我们定义SAX和DOM两种解析方式。
DOM解析操作：
将我们的XML文档，当做一个DOM树状结构的模型，通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称为随机访问机制。
优点 ：可以随意访问DOM结构中的任何的一部分数据
缺点：将所有的数据一次性的转换为DOM结构的树，存放在内存中，因此当数据很大，或者是结构很复杂的时候，对于内存的需求比较大。

想要使用DOM方式进行XML的解析，需要以下的接口：
1.document:此接口代表了整个XML文档，表示整颗DOM树的根。提供可对文档中数据进行访问的方法。
2.node：表示文档树中的每一个节点
3.nodelist:表示文档树中的一组节点

实例：DOM方式生成XML文件

<?xml version="1.0" encoding="GBK" ?>
<addresslist>
       <linkman>
              <name>张三</name>
              <email>12345@qq.com</email>
       </linkman>
</addresslist>

步骤：
1.建立DocumentBuilderFactory对象
2.建立DocumentBuilder
3.建立Document对象
注意：生成XML文件的时候，我们创建的空白的Document对象。
4.创建DOM结构中的节点
5.对标签设置内容以及关系
6.建立TranformerFactory对象，用来创建Transformer
7.建立Transformer对象，利用此对象提供的transformer方法将DOM对象输出到文件中。
8.设置输出的XML文件的字符集格式
9.建立DOMSource对象,用此对象可以选择将哪一个DOM结果进行输出。
10.建立StreamResult对象,用来执行将文档内容输出到哪一个文件中
11.调用Transformer的transformer方法进行输出

public class DomCreateXML{
    public static void main(String[] args){
        createXML();
    }
    public static void createXML(){
      //1.建立DocumentBuilderFactory对象
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      try{
      //2.建立DocumentBuilder
      DocumentBuilder builder = DocumentBuilder.newDocumentBuilder();
      //3.建立Document 
      Document doc = builder.newDocument();
      //4.创建DOM结构中的节点
      Element addresslist = doc.createElement("addresslist");
      Element linkman = doc.createElement("linkman");
      Element name= doc.createElement("name");
      Element email= doc.createElement("email");
      //5.对标签设置内容以及关系
      name.appendChild(doc.createTextNode("张三"));
      email.appendChild(doc.createTextNode("12345@qq.com"));
      linkman.appendChild(name);
      linkman.appendChild(email);
      addresslist .appendChild(linkman);
      doc.appendChild(addresslist);
      //6.建立TranformerFactory对象，用来创建Transformer
      TranformerFactory tf = TranformerFactory.newInstance();
      //7.建立Transformer对象，利用此对象提供的transformer方法将DOM对象输出到文件中
      Transformer t = tf.newTransformer();
      //8.设置输出的XML文件的字符集格式
      t.setOutputProperty(OutputKeys.ENCODING,"GBK");
      //9.建立DOMSource对象,用此对象可以选择将哪一个DOM结果进行输出
      DOMSource ds = new DOMSource(doc);
      //10.建立StreamResult对象,用来执行将文档内容输出到哪一个文件中
      StreamResult sr = new StreamResult(new File("d:"+File.separator+"linkman.xml"));
      //11.调用Transformer的transformer方法进行输出
      t.transform(ds,sr);
      }catch (SAXException e) {
          //TODO Auto-generated catch block
          e.printStackTrace();
        }catch (SAXException e) {
          //TODO Auto-generated catch block
          e.printStackTrace();
        }catch (SAXException e) {
          //TODO Auto-generated catch block
          e.printStackTrace();
        }    
    }
}

如果想要利用DOM方式进行解析，需要按照以下的步骤进行：
1.建立DocumentBuilderFactory
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
2.建立DocumentBuilder
DocumentBuilder builder = DocumentBuilder.newDocumentBuilder();
3.建立Document
注意：解析的时候是从文件中进行解析，所以在解析时候获取Document对象时，我们需要指定从哪一个文件中进行解析。
4.建立NodeList或Node

import java.io.File;
import java.io.IOException; 
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;
import org.xml.sax.SAXException;
 
public class DOMParse {
       public static void main(String[] args) {
              printInfo();
       }

       public static void printInfo(){
              //1.建立DocumentBuilderFactory
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
              //2.建立DocumentBuilder
            DocumentBuilder builder = null;
              try {
                  builder = factory.newDocumentBuilder();
                //3.创建Document对象
                  Document doc = builder.parse(new File("d:"+File.separator+"Demo2.xml"));
                
                  NodeList names = doc.getElementsByTagName("name");                               
                  for(int i=0;i<names.getLength();i++){
                         Node name = names.item(i);
                         System.out.println(name.getNodeName()+":"+name.getTextContent());
                    }
                  NodeList ids = doc.getElementsByTagName("id");                                 
                  for(int i=0;i<ids.getLength();i++){
                         Node id = ids.item(i);
                         System.out.println(id.getNodeName()+":"+id.getTextContent());
                    }   
                                                                                
           //找到所有的linkman标签
//           NodeList linkmans = doc.getElementsByTagName("linkman");
//           for(int i=0;i<linkmans.getLength();i++){
//           Node linkman = linkmans.item(i);
//           NodeList childs = linkman.getChildNodes();
//               for(int j=0;j<childs.getLength();j++){
//                 Node child = childs.item(j);
//                 if(!child.getTextContent().trim().equals("")){                                            
//                   System.out.println(child.getNodeName()+":"+child.getTextContent());
//                 }                                                                          
//             }
//              System.out.println("---------------------");
//         }    
                       
         }catch (ParserConfigurationException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }catch (SAXException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }catch (IOException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }                                          
       }
       public static void printName(){
              //1.建立DocumentBuilderFactory
              DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
              //2.建立DocumentBuilder
              DocumentBuilder builder = null;
                            try{
                                   builder = factory.newDocumentBuilder();
                                   //3.创建Document对象
                                   Document doc = builder.parse(new File("d:"+File.separator+"Demo2.xml"));
                                   NodeList names = doc.getElementsByTagName("name");
                                   //遍历
                                   for(int i=0;i<names.getLength();i++){
                                          Node name = names.item(i);
                                          System.out.println(name.getNodeName()+":"+name.getTextContent());
                                   }                            
                            }catch (ParserConfigurationException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }catch (SAXException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }catch (IOException e) {
                                   //TODO Auto-generated catch block
                                   e.printStackTrace();
                            }                                        
       }
}

SAX解析：
SAX解析采用的一种顺序的模式进行访问，是一种快速读取XML数据的方式。
SAX解析器在开始工作的时候，会在某一个时刻，产生某一个事件，例如在读取到文档开始的时候，会产生文档开始读取事件，在读到元素开始的时候，会产生元素开始读取事件等等，SAX解析器对于不同的事件，都有自己的事件处理程序，我们只需要编写事件处理程序就可以了。

SAX解析的步骤：
1.自定义一个类，继承DefaultHandler，重写这个类中相关的事件处理方法。

public class MySax extends DefaultHandler{

    public void startDocument() throws SAXException{
    System.out.println("<?xml version=\"1.0\" encoding=\"GBK\" standalone=\"no\"?>");
    }
    
    public void endDocument() throws SAXException{
    System.out.println("文档读取结束");
    }
    
    public void startElement(String uri, String localName, String qName, Attributes attributes）throws SAXException{
    System.out.println("<");
    System.out.println(qName); 
    if(attributes!=null){
        for(int i = 0 ; i<attributes.getLength() ; i++){
         System.out.print(" "+attributes.getQName(i)+"="+attributes.getValue(i));        
            }
       }
    System.out.println(">");
    }
    
    public void endElement(String uri, String localName, String qName) throws SAXException{
    System.out.println("</"+qName+">");
    }
    
    public void characters(char[] ch, int start, int length) throws SAXException{
    String str = new String(ch,start,length);
    System.out.println(str);
    }
}

2.编写一个测试类
3.建立SAXParserFacotry对象
4.建立SAXParser对象
5.调用SAXParser对象的parse方法对文件进行解析，其中方法有两个参数：
第一个参数代表从哪一个文件中读取，第二个参数代表使用哪一个解析器进行读取

public class SaxParse{
    public static void main(String[] args){
      //1.建立SAXParserFacotry对象
      SAXParserFacotry factory = SAXParserFacotry.newInstance();
      try{
      //2.建立SAXParser对象
      SAXParser parser= factory.newSAXParser();
      //3.调用SAXParser对象的parse方法对文件进行解析
      parser.parse(new File("d:"+File.separator+"linkman.xml"),new MySax());
      }catch (ParserConfigurationException e) {
        //TODO Auto-generated catch block
        e.printStackTrace();
      }catch (ParserConfigurationException e) {
        //TODO Auto-generated catch block
        e.printStackTrace();
      }  
   }
}

SAX解析与DOM解析的区别：

区别              DOM解析                SAX解析

操作          将所有文件读取到      顺序读取所需要的文件的内容
              内存中形成DOM树      不会一次性全部读取完毕
              如果文件量过大       不受文件大小的限制                        
              则无法使用
              
访问限制       DOM树在内存中形成    由于采用部分读取，只能对
              可以随意访问树中      文件按顺序从头到尾解析一遍
              的任何一个部分        不支持对文件的随意读取 
              没有次数的限制     
                                                                            
修改          任意修改文件树内容     只能读取不能修改
                          
复杂度           易于理解，易于开发   开发上比较复杂                            
                                    需要用户自定义解析器
                                    
对象模型       系统自动为使用者     对开发人员更加灵活
              创建DOM树，XML对象   可以使用SAX建立
              模型由系统提供       自己的XML对象模型 

使用JDOM的解析
JDOM是使用Java语言编写的用于读写操作XML的一套组件。
www.jdom.org
使用JDOM主要的操作类如下：
1.Document:定义了一个XML文件的各种操作，用户可以通过它所提供的方法存取根元素以及存取处理命令层次的相关信息。
2.DOMBuilder:用来建立一个JDOM结构树
3.Element:定义了一个XML元素的各种操作，用户可以通过它所提供的方法得到元素的文字内容、属性值以及子节点
4.Attribute:表示了XML文件元素中属性的各个操作。
5.XMLOutputter:会将一个JDOM结构的树格式化成为一个XML文件。

实例：生成如下的XML文档

<?xml version="1.0" encoding="GBK"?>
<addresslist>
       <linkman id="001">
              <name>张三</name>
              <email>1234@qq.com</email>
       </linkman>
</addresslist>

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List; 
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.XMLOutputter;
 
public class JDomDemo {
       public static void main(String[] args) {
              readXML();
       }
       
       public static void createXML(){
              //1.创建XML文件中所有的标签对象
              Element addresslist = new Element("addresslist");
              Element linkman = new Element("linkman");
              Element name = new Element("name");
              Element email = new Element("email");
              //2.设置每一个标签的属性内容
              Attribute attr = new Attribute("id", "001");
              linkman.setAttribute(attr);
              linkman.setAttribute("class", "002");
              name.setText("张三");
              email.setText("1234@qq.com");
              //3.设置标签与标签之间的关系
              linkman.addContent(name);
              linkman.addContent(email);
              addresslist.addContent(linkman);
              //4.创建XMLOutputter对象
              XMLOutputter out = new XMLOutputter();
              //5.设置字符集格式
              out.setFormat(out.getFormat().setEncoding("GBK"));
              //6.调用XMLOutputter对象给我们提供的output方法进行输出
              try{
                     out.output(addresslist,new FileOutputStream(new File("d:"+File.separator+"JDOM.xml")));
              }catch (FileNotFoundException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }catch (IOException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }             
       }

       public static void readXML(){
              //1.创建SAXBuilder
              SAXBuilder builder = new SAXBuilder();             
              try{
                    //2.得到Document对象
                     Document doc = builder.build(new File("d:"+File.separator+"JDOM.xml"));
                     //3.获取根标签对象
                     Element rootElement = doc.getRootElement();
                     //4.得到跟标签下所有的子标签
                     printElement(rootElement);
                                                                                
//                   for(int i=0;i<list.size();i++){
//                                 Element linkman = list.get(i);
//                                 Attribute id = linkman.getAttribute("id");
//                                 String name = linkman.getChildText("name");
//                                 String email = linkman.getChildText("email");
//                                 System.out.println("id:"+id.getValue());
//                                 System.out.println("name:"+name);
//                                 System.out.println("email:"+email);
//                   }
              }catch (JDOMException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }catch (IOException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }              
       }       

       public static void printElement(Element element){
              List<Element> list = element.getChildren();
              if(list.size()>0){
                     for(int i=0;i<list.size();i++){
                            Element e = list.get(i);
                            printElement(e);                            
                     }
              }else{
                     System.out.println(element.getName()+":"+element.getText());
              }              
       }
}

DOM4J：
DOM4J也是一组XML操作的组件包，主要用于读写XML文件。
DOM4J提供的主要的接口：
1.Attribute:代表标签的属性
2.Branch:为能够包含子节点的节点
3.CDATA：定义CDATA区域
4.Character：是一个标识接口，标识基于字符的节点。
5.Comment:定义了XML的注释
6.Document：定义了XML的文档
7.Element:定义XML的元素
8.Text：定义XML的文本节点

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Iterator; 
import org.dom4j.Attribute;
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;
 
public class Dom4JDemo { 

       public static void main(String[] args) {
              readXML();
       }

       public static void createXML(){
              //1.定义Document对象
              Document doc = DocumentHelper.createDocument();
              //2.向document文档中添加元素的同时设置元素之间的关系
              Element addresslist = doc.addElement("addresslist");
              Element linkman = addresslist.addElement("linkman");
              linkman.addAttribute("id", "001");
              Element name = linkman.addElement("name");
              name.setText("张三");
              Element email = linkman.addElement("email");
              email.setText("1234@qq.com");
              //3.定义一个OutputFormat对象
              OutputFormat format  = OutputFormat.createPrettyPrint();
              format.setEncoding("GBK");
              //4.得到XMLWriter对象
              try {
                     XMLWriter writer = new XMLWriter(new FileOutputStream(new File("d:"+File.separator+"DOM4J.xml")));
                     writer.write(doc);
                     writer.close();
              }catch (UnsupportedEncodingException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }catch (FileNotFoundException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }catch (IOException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }              
       }       
       
       public static void readXML(){
              //1.定义读取的文件
              File file = new File("d:"+File.separator+"DOM4J.xml");
              //2.定义SAXReader对象
              SAXReader reader = new SAXReader();             
              try{
                     //3.得到Document对象
                     Document doc = reader.read(file);
                     //4.获取跟标签
                     Element rootElement = doc.getRootElement();
                     Iterator<Element> iter = rootElement.elementIterator();
                     while(iter.hasNext()){
                                   Element linkman = iter.next();
                                   System.out.println("姓名:"+linkman.elementText("name"));
                                   System.out.println("邮箱:"+linkman.elementText("email"));
                     }
              }catch (DocumentException e) {
                     //TODO Auto-generated catch block
                     e.printStackTrace();
              }
       } 
}