01_XML基础

一、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)：文档类型定义。

 

 

 

    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解析

    

    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());
    }