01_XML基础

╰+攻爆jí腚メ 2022-08-20 12:25 201阅读 0赞

**一、XML概述**

XML是指可扩展标记语言(eXtensible Markup Language)，它是一种标记语言

作用：

它被设计的宗旨是用于表示数据的。

XML还经常作为配置文件

**二、XML的语法(记住)**

1、XML的声明

必须出现在第一行,严格意义上的第一行.

最简单的形式：<?xml version="1.0"?>

encoding:指示解析器在解析XML中数据时使用的编码，默认是UTF-8

2、CDATA区：

作用：把标签当做普通的文本对待

语法<!\[CDATA\[文本内容\]\]>

**三、XML的约束（知道）**

约束就是一个规定

格式良好的XML：遵循XML语法的XML

有效的XML：遵循约束文档的XML

**四、DTD约束（理解）**

1、DTD(Document Type Definition)：文档类型定义。

![Image 1][]

2、DTD如果是在一个单独的文件中定义的，文件保存时必须使用UTF-8

3、如何在xml中引入外部的dtd文档（必须会）

3.1dtd文档在本地：<!DOCTYPE 根元素 SYSTEM "DTD文档路径">

3.2dtd文档不在本地：<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL">

4、看懂DTD文档

< ?xml version = "1.0" encoding = "gbk" ? >  
< !DOCTYPE TVSCHEDULE \[  
< !ELEMENT TVSCHEDULE (CHANNEL \+) >  
< !ELEMENT CHANNEL (BANNER,DAY \+) >  
< !ELEMENT BANNER (\#PCDATA) >  
< !ELEMENT DAY (DATE,(HOLIDAY |PROGRAMSLOT \+) \+) >  
< !ELEMENT HOLIDAY (\#PCDATA) >  
< !ELEMENT DATE (\#PCDATA) >  
< !ELEMENT PROGRAMSLOT (TIME,TITLE,DESCRIPTION ?) >  
< !ELEMENT TIME (\#PCDATA) >  
< !ELEMENT TITLE (\#PCDATA) >  
< !ELEMENT DESCRIPTION (\#PCDATA) >  
< !ATTLIST TVSCHEDULE NAME CDATA \#REQUIRED >  
< !ATTLIST CHANNEL CHAN CDATA \#REQUIRED >  
< !ATTLIST PROGRAMSLOT VTR CDATA \#IMPLIED >  
< !ATTLIST TITLE RATING CDATA \#IMPLIED >  
< !ATTLIST TITLE LANGUAGE CDATA \#IMPLIED >  
\] >  
<TVSCHEDULE NAME = "湖北电视台" >  
     <CHANNEL CHAN = "湖北卫视" >  
         <BANNER >旗帜 < /BANNER >  
         <DAY >  
             <DATE > 2013年 < /DATE >  
             <HOLIDAY >十月一日 < /HOLIDAY >  
             <HOLIDAY >五月一日 < /HOLIDAY >  
         < /DAY >  
         <DAY >  
             <DATE > 2012年 < /DATE >  
             <PROGRAMSLOT VTR = "排程1" >  
                 <TIME >时间 < /TIME >  
                 <TITLE  >标题 < /TITLE >  
             < /PROGRAMSLOT >  
             <PROGRAMSLOT >  
                 <TIME >时间 < /TIME >  
                 <TITLE RATING = "下午" LANGUAGE = "普通话" >标题 < /TITLE >  
                 <DESCRIPTION >描述 < /DESCRIPTION >  
             < /PROGRAMSLOT >  
         < /DAY >  
     < /CHANNEL >  
< /TVSCHEDULE >

**五、XML的数据解析**

定义XML时的约束形式：

｜－DTD

｜－Schema

解析XML的方式：

｜－DOM（Document Object Model）解析

优点：W3C推出模型，非常适合增删改查（CRUD）

缺点：必须把XML文件全部读入内存才可以操作

｜－SAX（Simple API for XML）解析

> 　　            优点：在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作

缺点：只能进行查询

解析时用到的开发包：

｜－dom4j

是开源组织推出的解析开发包。最好的，都在用。

｜－JAXP(Java API for XML Processing)

是SUN公司推出的解析标准实现。

org.w3c.dom:提供DOM方式解析XML的标准接口

org.xml.sax:提供SAX方式解析XML的标准接口

javax.xml:提供了解析XML文档的类

｜－JDom

是开源组织推出的解析开发包。

**六、JAXP之DOM解析**

Jaxp DOM解析的基本操作

<?xml version="1.0" encoding="UTF-8" standalone="no"?><书架>

<书>

<书名>Java就业培训教程</书名>

<作者>张三丰</作者>

<售价>33.00元</售价>

</书>

<书>

<书名>高数 </书名>

<作者>小明 </作者>

<售价>21.00元</售价>

</书>

</书架>

**public**    **class**  jaxp\_CRUD\_exercise \{  
      **public**    **static**    **void**  main(String\[\] args)   **throws**  Exception \{  
      //首先得到 doucment,先得到工厂,再由工厂得到DocumentBuilder,最后得到Document.  
        DocumentBuilderFactory dbf = DocumentBuilderFactory. newInstance ();  
        DocumentBuilder db = dbf.newDocumentBuilder();  
        Document document = db.parse(  "src/book.xml" );  
         test7 (document);  
    \}       
//    1、得到某个具体的节点内容:第2本书的主体内容 <书名>葵花宝典</书名>  
      **private**    **static**    **void**   test1(Document document)  \{  
          //根据书名获取其标签  
        NodeList nl = document.getElementsByTagName( "书名" );  
          //第二本书,得到第二个书名标签  
        Node node = nl.item( 1);  
          //获取主体内容  
        String str = node.getTextContent();  
        System. out .println(str);;          
    \}  
//2、遍历所有元素节点:递归。打印遍历到的元素名称,Document继承Node,传递Document进来即可  
      **private**    **static**    **void**   test2(Node node)  \{  
          //判断元素是否为一个元素节点,如果是就打印  
          **if** (node.getNodeType() ==Node. ELEMENT\_NODE )\{  
            System. out .println(node.getNodeName());  
        \}  
          //再得到子类,调用自己进行遍历  
        NodeList nl = node.getChildNodes();  
          **for** ( **int**  x = 0;x <nl.getLength();x \++)\{  
            Node cn = nl.item(x);  
             test2 (cn);  
        \}  
    \}  
//3、修改某个元素节点的主体内容:第2本书售价改为2元  
      **private**    **static**    **void**   test3(Document document) **throws**  Exception \{  
          //根据书名获取其标签  
        NodeList nl = document.getElementsByTagName( "售价" );  
          //第二本书,得到第二个书名标签  
        Node node = nl.item( 1);  
          //获取主体内容  
        node.setTextContent( "2.00元" );  
        Transformer ts = TransformerFactory. newInstance ().newTransformer();  
        ts.transform( **new**  DOMSource(document),   **new**  StreamResult( "src/book.xml" ));  
    \}  
//4、向指定元素节点中增加子元素节点:给第一本书增加一个<内部价>58.00元</内部价>  
      **private**    **static**    **void**   test4(Document document) **throws**  Exception \{  
          //根据书名获取其标签  
        Element e = document.createElement(  "内部价" ); //创建内部价标签  
        e.setTextContent( "58.00元" );  
          //得到第一本元素  
        Node fnode = document.getElementsByTagName( "书" ).item( 0);  
          //把新元素驾到第一本书上.  
        fnode.appendChild(e);  
        Transformer ts = TransformerFactory. newInstance ().newTransformer();  
        ts.transform( **new**  DOMSource(document),   **new**  StreamResult( "src/book.xml" ));  
    \}      
//5、向指定元素节点上增加同级元素节点,售价上面增加批发价  
      **private**    **static**    **void**   test5(Document document) **throws**  Exception \{  
          //创建新元素  
        Element e = document.createElement(  "批发价" ); //创建内部价标签  
        e.setTextContent( "48.00元" );  
          //得到插入点的标签(售价),需要父节点才可以操作子节点  
        Node node = document.getElementsByTagName( "售价" ).item( 0);  
        Node pNode = node.getParentNode();  
        pNode.insertBefore(e, node);  
        Transformer ts = TransformerFactory. newInstance ().newTransformer();  
        ts.transform( **new**  DOMSource(document),   **new**  StreamResult( "src/book.xml" ));  
    \}  
//6、删除指定元素节点:删除批发价  
      **private**    **static**    **void**   test6(Document document) **throws**  Exception \{  
      //1.获取批发价的节点  
    Node node = document.getElementsByTagName( "批发价" ).item( 0);  
      //2.删除节点,必须有批发价的父节点来做  
    node.getParentNode().removeChild(node);  
      //3.写入文件  
    Transformer ts = TransformerFactory. newInstance ().newTransformer();  
    ts.transform( **new**  DOMSource(document),   **new**  StreamResult( "src/book.xml" ));  
    \}  
//7、操作XML文件属性:给第一本书添加属性  出版社="小马"  
      **private**    **static**    **void**  test7(Document document) **throws**  Exception\{  
      //1.获取第一本书的节点  
      //Node node = document.getElementsByTagName("书").item(0);  
    Element e = (Element)document.getElementsByTagName( "书" ).item( 0);  
      //2.给第一本书增加属性  
    e.setAttribute( "出版社" ,   "小马" );  
      //3.写入文件  
    Transformer ts = TransformerFactory. newInstance ().newTransformer();  
    ts.transform( **new**  DOMSource(document),   **new**  StreamResult( "src/book.xml" ));  
    \}  
      
      
\}

**七、JAXP之SAX解析**

![Image 1][]

Jaxp SAX解析（练习：把书的信息封装到JavaBean中）

public    class  MySAX3\_exercise \{  
//把书中的数据封装到JavaBeam中.  
      public    static    void  main(String\[\] args)   throws  Exception \{  
          //得到解析器SAXSparer  
        SAXParser parser = SAXParserFactory. newInstance ().newSAXParser();  
          //得到读取器  
        XMLReader reader = parser.getXMLReader();  
          //定义一个集合,存储JavaBeam  
        List <Book > books =   new  ArrayList() ;  
          //给读取器注册事件处理器,使用  
        reader.setContentHandler( new  MyContentHandler2(books));  
    \}  
\}  
//创建注册事件注册器,把读到的数据存入到JavaBeam中.  
class  MyContentHandler2   extends  DefaultHandler\{  
      //定义一个集合容器,引用主函数中的集合  
      private  List <Book >  books ;  
      public  MyContentHandler2(List <Book > books)\{  
          this . books  =books;  
    \}  
      //定义一个容器类  
      private  Book  book ;  
      //定义一个容器字符串  
      private  String  currentTagName ;  
      public    void  startElement(String uri, String localName,  
            String qName, Attributes attributes)   throws  SAXException \{  
          //如果读到的是书，创建book对象  
          if ( "书" .equals(qName))\{  
             book   =   new  Book();  
        \}  
         currentTagName   = qName;  
    \}  
      public    void  characters( char \[\] ch,   int  start,   int  length)  
              throws  SAXException \{  
          if ( currentTagName .equals(  "书名" ))  
         book .setName( new  String(ch,start,length));  
          if ( currentTagName .equals(  "作者" ))  
         book .setAuthor( new  String(ch,start,length));  
          if ( currentTagName .equals(  "售价" ))  
         book .setPrice( new  String(ch,start,length));  
        \}  
      public    void  endElement(String uri, String localName, String qName)  
              throws  SAXException \{  
          //如果读到的是书，把book对象加到集合中去  
          if ( "书" .equals(qName))\{  
             books .add( book );  
        \}  
         currentTagName   =  null ;  
    \} \}

**八、DOM4J操作**

基本操作（练习：PPT 44 7个练习，不要采用main方法进行测试，请使用单元测试）

**public**    **class**  dom4j\_exercise \{  
      // DOM4J的使用  
      **public**    **static**    **void**  main(String\[\] args)   **throws**  Exception \{  
          // 得到解析器  
        SAXReader reader =   **new**  SAXReader();  
          // 得到Document,  
        Document document = reader.read(  "src/book.xml" );  
          // test1(document);  
          // test2(document.getRootElement());  
         test7 (document);  
    \}  
      // 1、得到某个具体的节点内容:第2本书的作者  
      **private**    **static**    **void**   test1(Document document)   **throws**  Exception  \{  
          // 1.得到根元素  
        Element root = document.getRootElement();  
          // 2.得到根元素书里面所有(书)元素的集合(只得到儿子,不得到孙子),注意不是get方法,是element.  
        List <Element > books =  root.elements( "书" ) ;  
          // 3.得到第二本书  
        Element secondBook = books.get( 1);  
          // 4.得到书中的(作者)元素  
        Element author = secondBook.element(  "作者" );  
        System. out .println(author.getTextTrim());  
    \}  
      // 2、遍历所有元素节点:只打印元素的名称  
      **private**    **static**    **void**   test2(Element element)   **throws**  Exception  \{  
        System. out .println(element.getName());  
          // 一下代码copyDOM4J文档说明Fast Looping  
          **for**  ( **int**  i =  0, size = element.nodeCount(); i  < size; i \++) \{  
            Node node = element.node(i);  
              **if**  (node   **instanceof**  Element) \{  
                 test2 ((Element) node);  
            \}   **else**  \{  
                  // do something....  
            \}  
        \}  
    \}  
      // 3、修改某个元素节点的主体内容  
      // 第二本书售价由2.00元变为1.00元  
      **private**    **static**    **void**   test3(Document document)   **throws**  Exception  \{  
          // 1.得到根元素  
        Element root = document.getRootElement();  
          // 2.得到根元素书里面所有(书)元素的集合(只得到儿子,不得到孙子)注意不是get方法,是element.  
        List <Element > books =  root.elements( "书" ) ;  
          // 3.得到第二本书  
        Element secondBook = books.get( 1);  
          // 4.得到书中的(售价)元素,修改  
        Element price = secondBook.element(  "售价" );  
        price.setText( "1.00元" );  
          // 5.写入到文件.复制DOM4J文档说明Writing a document to a file  
          // OutputFormat format = OutputFormat.createPrettyPrint();//好看的,默认的输出格式.  
        OutputFormat format = OutputFormat. createCompactFormat (); // 不好看的,机器看的  
        format.setEncoding( "UTF-8" );  // 设置编码  
        XMLWriter writer =   **new**  XMLWriter( **new**  FileOutputStream( "src/book.xml" ),  
                format);  
          // XMLWriter writer = new XMLWriter(new  
          // FileOutputStream(" src /book.xml"));  
        writer.write(document);  
        writer.close();  
    \}  
      // 4、向指定元素节点中增加子元素节点 :在第一本书增加内部价节点,48.00元  
      **private**    **static**    **void**   test4(Document document)   **throws**  Exception  \{  
          // 1.创建元素DocumentHelper,这个类可以创建好多东西;  
        Element e = DocumentHelper. createElement ( "内部价" ).addText( "48.00元" );  
          // 2.添加元素到文档中,有父亲才可以添加.  
        document.getRootElement().element( "书" ).add(e);  
          // 3.写入元素  
        XMLWriter writer =   **new**  XMLWriter( **new**  FileOutputStream( "src/book.xml" ));  
        writer.write(document);  
        writer.close();  
    \}  
      // 5、向指定元素节点上增加同级元素节点,在售价上增加批发价58.00元.  
      **private**    **static**    **void**   test5(Document document)   **throws**  Exception  \{  
          // 1.创建元素DocumentHelper,这个类可以创建好多东西;  
        Element e = DocumentHelper. createElement ( "批发价" ).addText( "58.00元" );  
          // 2.添加元素到文档中,得到第一本书的孩子们,他们在一个集合中,操作这个集合即可.  
        Element book = document.getRootElement().element( "书" );  
        List <Element > list =  book.elements() ;  
          // 3.批发价是插入到第三个元素,index为2  
        list.add( 2, e);  
          // 4.写入元素  
        XMLWriter writer =   **new**  XMLWriter( **new**  FileOutputStream( "src/book.xml" ));  
        writer.write(document);  
        writer.close();  
    \}  
      // 6、删除指定元素节点:删除第一本书的批发价  
      **private**    **static**    **void**   test6(Document document)   **throws**  Exception  \{  
          // 1.删除元素,得到第一本书的孩子们,他们在一个集合中,操作这个集合即可.  
        Element book = document.getRootElement().element( "书" );  
        List <Element > list =  book.elements() ;  
          // 2.批发价是插入到第三个元素,index为2  
        list.remove( 2);  
          // 3.写入元素  
        XMLWriter writer =   **new**  XMLWriter( **new**  FileOutputStream( "src/book.xml" ));  
        writer.write(document);  
        writer.close();  
    \}  
      // 7、操作XML文件属性：第二本书添加出版社="传智"  
      **private**    **static**    **void**  test7(Document document)   **throws**  Exception \{  
          // 1.得到根元素  
        Element root = document.getRootElement();  
          // 2.找到第二本书,增加属性,因为是第二本,不是第一本,所以要从集合里区.第一本直接取  
        Element book2 = (Element)root.elements( "书" ).get( 1);  
        book2.addAttribute( "出版社" ,   "小智" );  
          // 3.写入元素  
        XMLWriter writer =   **new**  XMLWriter( **new**  FileOutputStream( "src/book.xml" ));  
        writer.write(document);  
        writer.close();  
    \} \}

**九、JUnit单元测试和debug调试**

**public**    **class**  MyMathTest\{  
      
      **private**    **static**  MyMath  mm ;  
     @BeforeClass  
      **public**    **static**    **void**  aa()\{  
        System. out .println( "aa" );  
         mm   =   **new**  MyMath();  
    \}  
     @AfterClass  
      **public**    **static**    **void**  bb()\{  
        System. out .println( "bb" );  
         mm   =  null ;  
    \}  
//    @Before//表示应该先运行  
//    public void  aa ()\{   
//        System.out.println(" aa ");  
//         mm  = new MyMath();  
//    \}  
//    @After//表示应该后运行  
//    public void  bb ()\{   
//        System.out.println(" bb ");  
//         mm  = null;  
//    \}  
      //测试方法：public 没有返回值的，没有方法参数  
     @Test (timeout = 10)  
      **public**    **void**  testAdd() \{  
          **int**  result  =  mm .add( 1,  2);  
          //不要打印,利用assertEquals方法进行判断  
         assertEquals ( 3, result);  
    \} \}

//测试方法是public,没有返回值的,没有方法参数  
     @Test  
      **public**    **void**  t1()   **throws**  Exception\{  
          //单元测试其实就是在测试方法体中,调用一次要测试的方法后者类即可.  
        SAXReader reader =   **new**  SAXReader();  
        Document document = reader.read(  "src/book.xml" );  
          //向需要测试的方法中传值document.  
        Dom4j\_exercise. test1 (document);  
    \}  
      **public**    **static**    **void**  test1(Document document)   **throws**  Exception \{  
         Element root = document.getRootElement();  
         List <Element > books =  root.elements( "书" ) ;  
         Element secondBook = books.get( 1);  
         Element author = secondBook.element(  "作者" );  
        System. out .println(author.getTextTrim());  
    \}

[Image 1]: