J2EE进阶之schema约束，JAXP的SAX解析，DOM4J的解析,XPATH的支持七

比眉伴天荒 2024-02-17 23:28 21阅读 0赞

## **XML之schema约束，JAXP的SAX解析，DOM4J的解析,XPATH的支持** ##

### schema约束 ###

* schema和DTD的对比
            * 符合XML的语法
            * DOM或者SAX可以容易解析schema的文档
            * schema文档对名称空间支持的比较好
            * 支持更多数据类型，自定义新的数据类型
    
        * 扩展名是.xsd
        * 只有一个根节点，节点的名称是schema
    
        * 名称空间（想java的包）

demo1

schema代码

1 <?xml version="1.0" encoding="UTF-8"?>
      2 
     20 <schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.itcast.cn/javaee13" elementFormDefault="qualified">
     21     
     22     
     23     <element name="书架">
     24         
     25         <complexType>
     26             
     27             <sequence maxOccurs="unbounded">
     28                 <element name="书">
     29                     
     30                     <complexType>
     31                         
     32                         <sequence>
     33                             
     34                             <element name="书名" type="string"></element>
     35                             <element name="作者" type="string"></element>
     36                             <element name="售价" type="double"></element>
     37                             <element name="简介" type="string"></element>
     38                         </sequence>
     39                         
     40                         
     41                         <attribute name="出版社" type="string" use="required" ></attribute>
     42                     </complexType>
     43                 </element>
     44             </sequence>
     45         </complexType>
     46     </element>
     47 </schema>

xml代码

1 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
      2 
     13 
     14 <书架 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     15         xmlns="http://www.itcast.cn/javaee13"
     16         xsi:schemaLocation="http://www.itcast.cn/javaee13 book.xsd"
     17     >
     18     <书 出版社="清华出版社">
     19         <书名>javaweb开发大全</书名>
     20         <作者>班长</作者>
     21         <售价>99.8</售价>
     22         <简介>这书不错啊</简介>
     23     </书>
     24     <书 出版社="清华出版社">
     25         <书名>javaweb开发大全</书名>
     26         <作者>班长</作者>
     27         <售价>99.8</售价>
     28         <简介>这书不错啊</简介>
     29     </书>
     30 </书架>

### JAXP的SAX解析（用的比较少） ###

* 区别：DOM容易产生内存溢出，可以做增删改的操作，SAX相反。
    
        * SAX的解析
            * 解析器
    
            * 事件处理器
                * 自己编写类继承DefaultHandler，重写三个方法

demo案例

1 package test2;
      2 
      3 import javax.xml.parsers.ParserConfigurationException;
      4 import javax.xml.parsers.SAXParser;
      5 import javax.xml.parsers.SAXParserFactory;
      6 
      7 import org.xml.sax.Attributes;
      8 import org.xml.sax.SAXException;
      9 import org.xml.sax.helpers.DefaultHandler;
     10 /**
     11  * 
     12  * @author Angus
     13  *
     14  */
     15 public class JaxpSaxTest {
     16 
     17     public static void main(String[] args) {
     18         try {
     19             run1();
     20         } catch (Exception e) {
     21             e.printStackTrace();
     22         }
     23     }
     24     
     25     /**
     26      * SAX的入门
     27      * @throws Exception 
     28      * @throws ParserConfigurationException 
     29      */
     30     public static void run1() throws Exception{
     31         // 解析器
     32         // 获取解析器的工厂
     33         SAXParserFactory factory = SAXParserFactory.newInstance();
     34         // 获取解析器对象
     35         SAXParser parser = factory.newSAXParser();
     36         // 解析XML的文档
     37         parser.parse("src/book2.xml", new MyHandler2());
     38         
     39         // 事件处理器
     40         // 自己编写
     41     }
     42 
     43 }
     44 
     45 
     46 /**
     47  * 获取作者标签下的文本内容
     48  * @author Administrator
     49  *
     50  */
     51 class MyHandler2 extends DefaultHandler{
     52     
     53     // 设置标志位
     54     private boolean flag = false;
     55     
     56     private int count = 0;
     57     
     58     /**
     59      * 获取作者标签下的文本内容
     60      */
     61     public void startElement(String uri, String localName, String qName,
     62             Attributes attributes) throws SAXException {
     63         // 解析到作者
     64         //System.out.println(qName);
     65         if("作者".equals(qName)){
     66             flag = true;
     67             count++;
     68         }
     69     }
     70     
     71     public void characters(char[] ch, int start, int length)
     72             throws SAXException {
     73         // 通过某种方式，控制打印，只解析到作者的标签的时候，打印文本内容
     74         if(flag && count == 1){
     75             System.out.println(new String(ch,start,length));
     76         }
     77     }
     78 
     79     public void endElement(String uri, String localName, String qName)
     80             throws SAXException {
     81         // 把标志位恢复
     82         flag = false;
     83     }
     84     
     85 }
     86 
     87 
     88 /**
     89  * 自己的事件处理器
     90  * @author Administrator
     91  *
     92  */
     93 class MyHandler extends DefaultHandler{
     94 
     95     /**
     96      * 解析开始标签，解析器默认调用该方法，把解析的内容作为参数
     97      */
     98     public void startElement(String uri, String localName, String qName,
     99             Attributes attributes) throws SAXException {
    100         System.out.println("开始标签："+qName);
    101     }
    102     
    103     /**
    104      * 解析的文本的内容，调用该方法
    105      */
    106     public void characters(char[] ch, int start, int length)
    107             throws SAXException {
    108         String str = new String(ch,start,length);
    109         System.out.println(str);
    110     }
    111 
    112     /**
    113      * 解析结束标签，调用该方法
    114      */
    115     public void endElement(String uri, String localName, String qName)
    116             throws SAXException {
    117         System.out.println("结束标签："+qName);
    118     }
    119     
    120 }
    121 
    122 
    123 
    124 
    125 
    126 
    127 
    128 
    129 
    130 
    131 
    132 
    133 
    134

### DOM4J的解析XML（应用比较多）（必会） ###

* 开源的jar包
    
        * 下载jar包    （dom4j-1.6.1.jar），需要把jar包导入到工程中
        * 复制到 WebRoot -- WEB-INF -- lib （WEB的项目）
        * 查看API，编写代码

### XPATH的支持 ###

* 引入XPATH的jar包（jaxen-1.1-beta-6.jar）
    
        * 必须只能使用两个方法，支持xpath
            * selectNodes()         获取结合
            * selectSingleNode()    获取一个Node对象
    
        * xpath的语法
            * document.selectNodes("/书架")       
    
            * /     /AAA/CCC        找到是CCC的节点
    
            * //    无论层级关系  //BBB   找到BBB的节点
    
            * *     全部          //* 所有
    
            * [1]或者[last()]     /AAA/BBB[1]

DOM4j 解析和XPATH demo:

1 package test2;
      2 
      3 import java.io.FileOutputStream;
      4 import java.util.List;
      5 
      6 import org.dom4j.Document;
      7 import org.dom4j.DocumentHelper;
      8 import org.dom4j.Element;
      9 import org.dom4j.Node;
     10 import org.dom4j.io.OutputFormat;
     11 import org.dom4j.io.SAXReader;
     12 import org.dom4j.io.XMLWriter;
     13 
     14 /**
     15  * DOM4J的解析xml
     16  * @author Administrator
     17  *
     18  */
     19 public class Dom4jTest {
     20     
     21     public static void main(String[] args) {
     22         try {
     23             run6();
     24         } catch (Exception e) {
     25             e.printStackTrace();
     26         }
     27     }
     28     
     29     /**
     30      * 对XPATH的支持
     31      * @throws Exception
     32      */
     33     public static void run6() throws Exception{
     34         // 解析器
     35         SAXReader reader = new SAXReader();
     36         // 解析xml
     37         Document document = reader.read("src/book2.xml");
     38         // 使用xpath
     39         //List<Node> nodes = document.selectNodes("/书架/书/作者");
     40         List<Node> nodes = document.selectNodes("//作者");
     41         Node node = nodes.get(1);
     42         System.out.println(node.getText());
     43     }
     44     
     45     /**
     46      * 修改文本的内容
     47      * @throws Exception
     48      */
     49     public static void run5() throws Exception{
     50         
     51     }
     52     
     53     /**
     54      * 删除某个节点
     55      * @throws Exception
     56      */
     57     public static void run4() throws Exception{
     58         
     59     }
     60     
     61     
     62     /**
     63      * 在指定的位置添加子节点
     64      * 需求：在第二本书，作者之前添加子节点
     65      * @throws Exception
     66      */
     67     public static void run3() throws Exception{
     68         // 解析器
     69         SAXReader reader = new SAXReader();
     70         // 解析xml
     71         Document document = reader.read("src/book2.xml");
     72         // 获取根节点
     73         Element root = document.getRootElement();
     74         // 获取第二本书
     75         Element book2 = (Element) root.elements("书").get(1);
     76         // 获取第二本书下所有的子节点    elements()方法，返回List<Element>
     77         List<Element> list = book2.elements();
     78         // 自己创建一个Element对象，DocumentHelper.createElement("狗");
     79         Element dog = DocumentHelper.createElement("狗");
     80         dog.setText("大狗");
     81         // 把创建的元素对象，手动加入到list结合中    list.add(index,E);
     82         list.add(1,dog);
     83         
     84         OutputFormat format = OutputFormat.createPrettyPrint();
     85         // 回写
     86         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book2.xml"),format);
     87         writer.write(document);
     88         writer.close();
     89     }
     90     
     91     
     92     /**
     93      * 末尾添加子节点
     94      * 在第二本书下添加子节点
     95      * @throws Exception
     96      */
     97     public static void run2() throws Exception{
     98         // 解析器
     99         SAXReader reader = new SAXReader();
    100         // 解析xml
    101         Document document = reader.read("src/book2.xml");
    102         // 获取根节点
    103         Element root = document.getRootElement();
    104         // 先获取第二本书
    105         Element book2 = (Element) root.elements("书").get(1);
    106         // 调用addElement方法，添加子节点（添加文本）
    107         book2.addElement("猫").setText("我是猫");
    108         
    109         // 需要格式化的输出器
    110         OutputFormat format = OutputFormat.createPrettyPrint();
    111         format.setEncoding("UTF-8");
    112         //OutputFormat format = OutputFormat.createCompactFormat();
    113         // 回写
    114         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book2.xml"),format);
    115         // 回写
    116         writer.write(document);
    117         // 关闭流
    118         writer.close();
    119     }
    120     
    121     /**
    122      * 需求：查询作者标签的文本内容
    123      * @throws Exception 
    124      */
    125     public static void run1() throws Exception{
    126         // 创建SAX解析器的对象  
    127         SAXReader reader = new SAXReader();
    128         // 解析XML，read的  方法，返回document对象
    129         Document document = reader.read("src/book2.xml");
    130         // 获取根节点
    131         Element root = document.getRootElement();
    132         // 获取所有的书
    133         List<Element> books = root.elements("书");
    134         // 获取第二本书
    135         Element book2 = books.get(1);
    136         // 获取作者的标签
    137         Element author = book2.element("作者");
    138         // 获取文本内容
    139         System.out.println(author.getText());
    140     }
    141 
    142 }