精华内容
下载资源
问答
  • Jaklin repo 的子模块
  • JAXP使用实例

    2020-02-11 14:40:52
    一、JAXP简单介绍 jaxp是javaSE的一部分,它的解析器在JDK的javax.xml.parsers包里面。 四个类:分别是针对dom和sax解析使用的类 dom: DocumentBuilder:解析器类 这是一个抽象类,不能new。此类的实例可以从...

    一、JAXP简单介绍
    jaxp是javaSE的一部分,它的解析器在JDK的javax.xml.parsers包里面。
            四个类:分别是针对dom和sax解析使用的类

    dom:
    DocumentBuilder:解析器类
     这是一个抽象类,不能new。此类的实例可以从DocumentBuderFactory.newDocumentBuilder()方法获取。包含一个方法,可以解析xml(parse("xml路径");)返回类型为Document。因为返回的Document是一个接口,Document父节点是Node,所以在Document里面找不到想要的方法,可以到Node里面去找。
     DocumentBuderFactory:解析器工厂
    抽象类,不能newInstance方法获取。
    sax:
     SAXParser:解析器类
     SAXParserFactory:解析器工厂
    一、JAXP使用实例
    此次实例使用的xml文件为:

    <?xml version="1.0" encoding="UTF-8" standalone="no"?><person>
        <p1>
            <name>张三</name>
            <age>20</age>
        </p1>
        <p1>
            <name>李四</name>
            <age>30</age>
        </p1>
    </person>
    使用JAXP查询节点
    代码(操作过程均详细描述)
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
            selectAll();
        }
    private static void selectAll() throws ParserConfigurationException, SAXException, IOException {
            // 查询所有name元素的值
            /*
             * 1、创建解析器工厂 
             * 2、根据解析器工厂创建解析器 
             * 3、解析xml返回document
             */
            // 1、创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            // 2、根据解析器工厂创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            // 3、解析xml放回document
            Document document = builder.parse("./WebContent/person.xml");
            // 得到name元素
            NodeList list = document.getElementsByTagName("name");
            // 遍历集合
            for (int i = 0; i < list.getLength(); i++) {
                Node name1 = list.item(i);
                // 得到标签里的内容
                String s = name1.getTextContent();
                System.out.println(s);
            }
        }
    }
     

    操作结果

     

    使用JAXP查询节点
    代码
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
            selectSingle();
        }
     
        private static void selectSingle() throws ParserConfigurationException, SAXException, IOException {
     
            // 查询xml中第一个name元素的值
            /*
             * 1、创建解析器工厂 2、根据解析器工厂创建解析器 3、解析xml放回document
             * 
             * 4、得到所有的name元素 5、使用返回集合,里面方法item下标获取具体的元素 6、得到具体的值,使用getTextContent
             */
            // 1、创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            // 2、根据解析器工厂创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            // 3、解析xml放回document
            Document document = builder.parse("./WebContent/person.xml");
            // 4、得到name元素
            NodeList list = document.getElementsByTagName("name");
            // 5、得到第一个元素
            Node name1 = list.item(0);
            String s = name1.getTextContent();
            System.out.println("第一个name元素值为:" + s);
        }
    }
     

    操作结果

    使用JAXP查添加节点
    代码
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
                  updateNode();
        }
     
    private static void updateNode() throws Exception {
            //在第一个p1下面(末尾)添加<sex></sex>
                    /*
                     * 1、创建解析器工厂
                     * 2、根据解析器工厂创建解析器
                     * 3、解析xml放回document
                     * 4、得到所有的p1,然后得到第一个p1,使用item方法下标得到
                     * 5、创建sex标签createElement
                     * 6、创建文本createTextNode
                     * 7、把文本添加到sex下面appendChild
                     * 8、把sex添加到第一个p1下面
                     * 9、回写xml(重要!!!)
                     */
                     
                    // 1、创建解析器工厂
                    DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
                    // 2、根据解析器工厂创建解析器
                    DocumentBuilder builder = builderFactory.newDocumentBuilder();
                    // 3、解析xml放回document
                    Document document = builder.parse("./WebContent/person.xml");
                    //得到所有的p1
                    NodeList list = document.getElementsByTagName("p1");
                    // 5、得到第一个元素
                    Node p1 = list.item(0);
                    //6、创建标签
                    Element sex1=document.createElement("sex");
                    //7、创建文本
                    Text text1=document.createTextNode("nv");
                    //8、把文本添加到sex1下面
                    sex1.appendChild(text1);
                    p1.appendChild(sex1);
                    //9、回写xml
                    TransformerFactory transformerFactory = TransformerFactory.newInstance();
                    Transformer transformer=transformerFactory.newTransformer();
                
                    transformer.transform(new DOMSource(document), new StreamResult("./WebContent/person.xml"));
        }
    }
     

    操作结果

    使用JAXP修改节点
    代码
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
     
            updateNode();
     
        }
        public static void updateNode() throws Exception {
            // 1、创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            // 2、根据解析器工厂创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            // 3、解析xml放回document
            Document document = builder.parse("./WebContent/person.xml");
            // 4、得到sex item方法
            NodeList list = document.getElementsByTagName("sex");
            Node sex1 = list.item(0);
            sex1.setTextContent("male");
            // 5、回写xml
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
     
            transformer.transform(new DOMSource(document), new StreamResult("./WebContent/person.xml"));
            System.out.println("执行完成!!!");
     
        }
    }
     

    操作结果

    使用JAXP删除节点
    代码
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
            deleteNode();
        }
        
        private static void deleteNode()throws  Exception{
            // 1、创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            // 2、根据解析器工厂创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            // 3、解析xml放回document
            Document document = builder.parse("./WebContent/person.xml");
            // 4、得到sex item方法
            Node sex1 = document.getElementsByTagName("sex").item(0);
            // 5、 获取sex的父节点
            Node p1 =sex1.getParentNode();
            // 6、 删除使用父节点删除 removeChild方法
            p1.removeChild(sex1);
            // 7、回写xml
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.transform(new DOMSource(document), new StreamResult("./WebContent/person.xml"));
            System.out.println("执行完成!!!");
     
        }
    }
     

    操作结果

    使用JAXP遍历节点
    代码
    public class Testjaxp {
        public static void main(String[] args) throws Exception {
     
            listElement();
        }
     
        // 遍历节点把xml所有元素的名称打印出来
        private static void listElement() throws Exception {
            // TODO Auto-generated method stub
            // 1、创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            // 2、根据解析器工厂创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            // 3、解析xml放回document
            Document document = builder.parse("./WebContent/person.xml");
            // 4、得到根结点
            list1(document);
            // 5、 得到根节点子节点
            // 6、 得到根节点的子节点
     
        }
     
        private static void list1(Node node) {
            // 判断是元素类型时候才打印
            if (node.getNodeType() == node.ELEMENT_NODE) {
                System.out.println(node.getNodeName());
            }
            // 得到一层子节点
            NodeList list = node.getChildNodes();
            // 遍历
            for (int i = 0; i < list.getLength(); i++) {
                //得到每一个节点
                Node node1 = list.item(i);
                list1(node1);
            }
     
        }
    }
     

    操作结果
               

     

    最后,需要导的包如下:

    import java.io.IOException;
     
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerException;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
     
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.w3c.dom.Text;
    import org.xml.sax.SAXException;
                    

    展开全文
  • java源码sxml-jaxp sxml-jaxp是一个工具库,用于将 SXML 启发的 XML 表示与 Java XML 基础结构一起使用。 它在内部使用 JAXP,因此它不依赖于任何特定的 XML 库,尽管作者已使用 OpenJDK 默认的 Xerces/Xalan 和 ...
  • Sun的JAXP和Sun的解析器 Sun打包JAXP的方式和默认情况下JAXP使用的解析器导致了很多解析器/ API的混乱。 在早期版本的JAXP中,Sun包括JAXP API(我刚才提到的那六个类,还有一些用于转换) 和一个名为Crimson的解析...

    Java技术和XML可以说是过去五年中最重要的编程开发。 结果,用于使用Java语言的XML的API激增了。 两种最受欢迎​​的文档对象模型(DOM)和XML的简单API(SAX)引起了极大的兴趣,紧随其后的是JDOM和数据绑定API(请参阅参考资料 )。 彻底了解这些API中的一两个是一项艰巨的任务。 正确使用所有这些使您成为专家。 但是,越来越多的Java开发人员发现他们不再需要广泛的SAX和DOM知识,这在很大程度上要归功于Sun Microsystems的JAXP工具包。 用于XML处理的Java API(JAXP)使即使是初次使用Java的程序员也可以管理XML,同时仍然为高级开发人员提供了很多便利。 就是说,即使是使用JAXP的高级开发人员也常常会对他们所依赖的API产生误解。

    本文假定您具有SAX和DOM的一些基本知识。 如果您不熟悉XML解析,则可能想先通过在线资源阅读SAX和DOM,或者略读我的书(请参阅参考资料 )。 您无需精通回调或DOM Node ,但至少应了解SAX和DOM在解析API。 对它们之间的差异有一个基本的了解也将有所帮助。 掌握了这些基础知识之后,本文将变得更加有意义。

    JAXP:API还是抽象?

    严格来说,JAXP是一个API,但更准确地说是一个抽象层 。 它没有提供解析XML的新方法,也没有添加到SAX或DOM中,也没有为Java和XML处理提供新功能。 (如果您现在不敢相信,那么您正在阅读正确的文章。)相反,JAXP使使用DOM和SAX来处理一些困难的任务变得更加容易。 它还使您可以以与供应商无关的方式处理使用DOM和SAX API时可能遇到的一些特定于供应商的任务。

    没有SAX,DOM或其​​他XML解析API, 就无法解析XML 。 我已经看到许多要求将SAX,DOM,JDOM和dom4j与JAXP进行比较的请求,但是进行这样的比较是不可能的,因为前四个API的用途与JAXP完全不同。 SAX,DOM,JDOM和dom4j都解析XML。 JAXP提供了一种获取这些解析器及其所公开数据的方法,但没有提供解析XML文档的新方法。 如果要正确使用JAXP,理解这一区别至关重要。 它还很可能使您领先于许多其他XML开发人员。

    如果您仍然不确定,请确保您拥有JAXP发行版(请参阅Going bigtime )。 启动Web浏览器并加载JAXP API文档。 导航到位于javax.xml.parsers包中的API的解析部分。 令人惊讶的是,您只会找到六个班级。 这个API有多难? 所有这些类都位于现有解析器的顶部。 其中两个仅用于错误处理。 JAXP比人们想象的要简单得多。 那么,为什么所有的困惑呢?

    Sun的JAXP和Sun的解析器

    Sun打包JAXP的方式和默认情况下JAXP使用的解析器导致了很多解析器/ API的混乱。 在早期版本的JAXP中,Sun包括JAXP API(我刚才提到的那六个类,还有一些用于转换) 和一个名为Crimson的解析器。 深红色是com.sun.xml软件包的一部分。 在JDK中包含的更新版本的JAXP中,Sun重新包装了Apache Xerces解析器(请参阅参考资料 )。 但是,在这两种情况下,解析器都是JAXP发行版的一部分,而不是JAXP API的一部分。

    这样考虑:JDOM随Apache Xerces解析器一起提供。 该解析器不是JDOM的一部分,而是由JDOM使用的,因此它被包括在内以确保JDOM可以立即使用。 相同的原则适用于JAXP,但并未明确宣传:JAXP带有一个解析器,因此可以立即使用。 但是,许多人将Sun的解析器中包含的类称为JAXP API本身的一部分。 例如,有关新闻组的一个常见问题曾经是:“如何使用JAXP附带的XMLDocument类?它的目的是什么?” 答案有些复杂。

    首先, com.sun.xml.tree.XMLDocument类不是JAXP的一部分。 它是Sun的Crimson解析器的一部分,包装在JAXP的早期版本中。 因此,这个问题从一开始就令人误解。 其次,JAXP的主要目的是在与解析器打交道时提供供应商独立性。 使用JAXP,您可以将相同的代码与Sun的XML解析器,Apache的Xerces XML解析器和Oracle的XML解析器一起使用。 因此,使用特定于Sun的类违反了使用JAXP的要点。 您是否开始看到这个主题变得如何混乱? JAXP发行版中的解析器和API结合在一起,并且一些开发人员将类和功能误认为是另一类的一部分,反之亦然。

    现在,您不仅可以看到所有混乱,还可以继续学习一些代码和概念。

    从SAX开始

    SAX是一种用于处理XML的事件驱动方法。 它包含许多回调。 例如,每次SAX解析器遇到元素的开始标记时,就会调用startElement()回调。 对字符数据调用characters()回调,然后对元素的end标签调用endElement() 。 存在更多用于文档处理,错误和其他词法结构的回调。 你明白了。 SAX程序员实现定义这些回调的SAX接口之一。 SAX还提供了一个名为DefaultHandler的类(在org.xml.sax.helpers包中),该类实现所有这些回调,并提供所有回调方法的默认的空实现。 (您将在下一节“ 处理 DOM”中对DOM的讨论中看到这一点很重要。)SAX开发人员只需要扩展此类,然后实现需要插入特定逻辑的方法即可。 因此,SAX中的关键是为这些各种回调提供代码,然后让解析器在适当的时候触发每个回调。 这是典型的SAX例程:

    1. 使用特定供应商的解析器实现创建SAXParser实例。
    2. 注册回调实现(例如,通过使用扩展DefaultHandler的类)。
    3. 开始解析,然后等待回调实现被触发。

    JAXP的SAX组件为完成所有这些操作提供了一种简单的方法。 如果没有JAXP,则必须直接从供应商类(例如org.apache.xerces.parsers.SAXParser )实例化SAX解析器实例,或者它必须使用名为XMLReaderFactory的SAX帮助器类(也在org.xml.sax.helpers包)。 第一种方法的问题很明显:它不是供应商中立的。 第二个问题是工厂要求使用解析器类的String名称作为参数(同样是Apache类org.apache.xerces.parsers.SAXParser )。 您可以通过将另一个解析器类作为String传入来更改解析器。 使用这种方法,如果您更改解析器名称,则无需更改任何导入语句,但仍然需要重新编译该类。 这显然不是最佳方案。 能够在不重新编译类的情况下更改解析器会容易得多。

    JAXP提供了更好的替代方案:它使您可以将解析器作为Java系统属性来提供。 当然,从Sun下载发行版时,您将获得使用Sun的Xerces版本的JAXP实现。 更改解析器-比如,Oracle的解析器-要求更改类路径设置,从一个解析器实现移动到另一个,但它不需要重新编译代码。 这就是JAXP所具有的魔力(抽象)。

    看看SAX解析器工厂

    JAXP SAXParserFactory类是能够轻松更改解析器实现的关键。 您必须创建该类的新实例(稍后我将介绍)。 创建新实例后,工厂将提供一种获取具有SAX功能的解析器的方法。 在幕后,JAXP实现会处理与供应商相关的代码,使您的代码愉快地不受污染。 该工厂还具有其他一些不错的功能。

    除了创建SAX解析器实例的基本工作之外,工厂还允许您设置配置选项。 这些选项影响通过工厂获得的所有解析器实例。 在JAXP 1.3提供的两种最常用的选项是与一组命名空间意识setNamespaceAware(boolean awareness) ,并用打开DTD验证setValidating(boolean validating) 。 请记住,一旦设置了这些选项,它们将影响方法调用后从工厂获得的所有实例。

    设置好工厂后,调用newSAXParser()将返回JAXP SAXParser类的现成实例。 此类包装基础的SAX解析器(SAX类org.xml.sax.XMLReader的实例)。 它还可以保护您避免对解析器类使用任何特定于供应商的添加。 (还记得本文前面有关XmlDocument的讨论吗?)此类允许开始实际的解析行为。 清单1显示了如何创建,配置和使用SAX工厂:

    清单1.使用SAXParserFactory
    import java.io.OutputStreamWriter;
    import java.io.Writer;
    
    // JAXP
    import javax.xml.parsers.FactoryConfigurationError;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParserFactory;
    import javax.xml.parsers.SAXParser;
    
    // SAX
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    public class TestSAXParsing {
        public static void main(String[] args) {
            try {
                if (args.length != 1) {
                    System.err.println ("Usage: java TestSAXParsing [filename]");
                    System.exit (1);
                }
                // Get SAX Parser Factory
                SAXParserFactory factory = SAXParserFactory.newInstance();
                // Turn on validation, and turn off namespaces
                factory.setValidating(true);
                factory.setNamespaceAware(false);
                SAXParser parser = factory.newSAXParser();
                parser.parse(new File(args[0]), new MyHandler());
            } catch (ParserConfigurationException e) {
                System.out.println("The underlying parser does not support " +
                                   " the requested features.");
            } catch (FactoryConfigurationError e) {
                System.out.println("Error occurred obtaining SAX Parser Factory.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    class MyHandler extends DefaultHandler {
        // SAX callback implementations from ContentHandler, ErrorHandler, etc.
    }

    清单1中 ,您可以看到在使用工厂时可能会发生两个特定于JAXP的问题:无法获取或配置SAX工厂,以及无法配置SAX解析器。 由FactoryConfigurationError表示的第一个问题通常在无法获取JAXP实现或系统属性中指定的解析器时发生。 当所使用的解析器中的请求的功能不可用时,将发生由ParserConfigurationException表示的第二个问题。 两者都易于处理,并且在使用JAXP时不会造成任何困难。 实际上,您可能希望编写代码来尝试设置一些功能并优雅地处理某些功能不可用的情况。

    获得工厂,关闭名称空间支持并打开验证后,将获得一个SAXParser实例。 然后开始解析。 SAX解析器的parse()方法采用我前面提到的SAX HandlerBase帮助器类的实例,您的自定义处理程序类对此实例进行了扩展。 请参阅代码分发,以查看带有完整Java清单的此类的实现(请参见下载 )。 您还传递了要解析的File 。 但是, SAXParser类包含的功能远不止单个方法。

    使用SAX解析器

    一旦有了SAXParser类的实例,就可以做很多事情,而不仅仅是将其传递给File进行解析。 由于大型应用程序中组件的通信方式,因此并不总是安全地假设对象实例的创建者是其用户。 一个组件可能会创建SAXParser实例,而另一个组件(可能由另一位开发人员编码)可能需要使用同一实例。 因此,JAXP提供了确定解析器设置的方法。 例如,您可以使用isValidating()来确定解析器是否将执行验证,或者使用isNamespaceAware()来查看解析器是否可以处理XML文档中的名称空间。 这些方法可以为您提供有关解析器可以执行的操作的信息,但是仅具有SAXParser实例的用户(而不是SAXParserFactory本身)无法更改这些功能。 您必须在解析器工厂级别执行此操作。

    您还可以通过多种方法来请求文档的解析。 而不是仅仅接受File和SAX DefaultHandler情况下, SAXParserparse()方法也可以接受SAX InputSource ,一个Java InputStreamURL以字符串形式,都带有DefaultHandler实例。 因此,您仍然可以解析以各种形式包装的文档。

    最后,您可以获取基础的SAX解析器( org.xml.sax.XMLReader的实例),并通过SAXParsergetXMLReader()方法直接使用它。 获得此基础实例后,即可使用常规的SAX方法。 清单2显示了SAXParser类(JAXP中用于SAX解析的核心类)的各种用法的示例:

    清单2.使用JAXP SAXParser
    // Get a SAX Parser instance
    SAXParser saxParser = saxFactory.newSAXParser();
    // Find out if validation is supported
    boolean isValidating = saxParser.isValidating();
    // Find out if namespaces are supported
    boolean isNamespaceAware = saxParser.isNamespaceAware();
    // Parse, in a variety of ways
    // Use a file and a SAX DefaultHandler instance
    saxParser.parse(new File(args[0]), myDefaultHandlerInstance);
    // Use a SAX InputSource and a SAX DefaultHandler instance
    saxParser.parse(mySaxInputSource, myDefaultHandlerInstance);
    // Use an InputStream and a SAX DefaultHandler instance
    saxParser.parse(myInputStream, myDefaultHandlerInstance);
    // Use a URI and a SAX DefaultHandler instance
    saxParser.parse("http://www.newInstance.com/xml/doc.xml",
                    myDefaultHandlerInstance);
    // Get the underlying (wrapped) SAX parser
    org.xml.sax.XMLReader parser = saxParser.getXMLReader();
    // Use the underlying parser
    parser.setContentHandler(myContentHandlerInstance);
    parser.setErrorHandler(myErrorHandlerInstance);
    parser.parse(new org.xml.sax.InputSource(args[0]));

    到目前为止,我已经谈论了很多有关SAX的内容,但是我还没有发表任何引人注目的或令人惊讶的内容。 JAXP的新增功能很少,特别是在涉及SAX的地方。 这种最小的功能使您的代码更具可移植性,并允许其他开发人员通过任何与SAX兼容的XML解析器自由或商业地使用它。 而已。 将SAX与JAXP结合使用仅需更多。 如果您已经知道SAX,那么您的使用率大约为98%。 您只需要学习两个新类和几个Java异常,就可以开始学习了。 如果您从未使用过SAX,那么现在就很容易开始。

    处理DOM

    如果您认为需要休息一下以应对DOM的挑战,则可以节省一些时间。 在JAXP中使用DOM与在SAX中使用DOM几乎相同。 您要做的就是更改两个类名和一个返回类型,您就在那儿。 如果您了解SAX的工作原理以及DOM是什么,那么您将没有任何问题。

    DOM和SAX之间的主要区别在于API本身的结构。 SAX由一组基于事件的回调组成,而DOM具有内存中的树结构。 使用SAX,永远不会有任何数据结构可以使用(除非开发人员手动创建一个)。 因此,SAX无法使您修改XML文档。 DOM确实提供了此功能。 org.w3c.dom.Document类表示XML文档,并且由表示元素,属性和其他XML构造的DOM节点组成。 因此,JAXP无需触发SAX回调。 它仅负责从解析中返回DOM Document对象。

    看看DOM解析器工厂

    有了对DOM的基本了解以及DOM和SAX之间的区别,您不需要了解更多。 清单3中的代码看起来与清单1中的SAX代码非常相似。 首先,获得DocumentBuilderFactory (以清单1中的SAXParserFactory相同的方式)。 然后将工厂配置为处理验证和名称空间(与在SAX中相同)。 接下来,从工厂中检索DocumentBuilder实例(类似于SAXParser实例)(以相同的方式SAXParser您就知道了)。 然后可以进行解析,并且将得到的DOM Document对象移交给打印DOM树的方法:

    清单3.使用DocumentBuilderFactory
    import java.io.File;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    import java.io.Writer;
    
    // JAXP
    import javax.xml.parsers.FactoryConfigurationError;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.DocumentBuilder;
    
    // DOM
    import org.w3c.dom.Document;
    import org.w3c.dom.DocumentType;
    import org.w3c.dom.NamedNodeMap;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    public class TestDOMParsing {
    
        public static void main(String[] args) {
            try {
                if (args.length != 1) {
                    System.err.println ("Usage: java TestDOMParsing " +
                                        "[filename]");
                    System.exit (1);
                }
    
                // Get Document Builder Factory
                DocumentBuilderFactory factory = 
                    DocumentBuilderFactory.newInstance();
    
                // Turn on validation, and turn off namespaces
                factory.setValidating(true);
                factory.setNamespaceAware(false);
    
                DocumentBuilder builder = factory.newDocumentBuilder();
                Document doc = builder.parse(new File(args[0]));
    
                // Print the document from the DOM tree and
                //   feed it an initial indentation of nothing
                printNode(doc, "");
    
            } catch (ParserConfigurationException e) {
                System.out.println("The underlying parser does not " +
                                   "support the requested features.");
            } catch (FactoryConfigurationError e) {
                System.out.println("Error occurred obtaining Document " +
                                   "Builder Factory.");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        private static void printNode(Node node, String indent)  {
            // print the DOM tree
        }
    
    }

    此代码可能会引起两个问题(例如JAXP中的SAX): FactoryConfigurationErrorParserConfigurationException 。 每种情况的原因都与SAX相同。 实现类中存在问题(导致FactoryConfigurationError ),或者提供的解析器不支持所请求的功能(导致ParserConfigurationException )。 在这方面,DOM和SAX之间的唯一区别是,使用DOM可以将DocumentBuilderFactory替换为SAXParserFactory ,将DocumentBuilder替换为SAXParser 。 就这么简单。 (您可以查看完整的代码清单,其中包括用于打印DOM树的方法;请参阅Download 。)

    使用DOM解析器

    一旦有了DOM工厂,就可以获取DocumentBuilder实例。 DocumentBuilder实例可用的方法与SAX实例可用的方法非常相似。 主要区别在于parse()方法的变体未采用SAX DefaultHandler类的实例。 相反,它们返回表示已解析的XML文档的DOM Document实例。 唯一的不同是为类SAX功能提供了两种方法:

    • setErrorHandler() ,它采用SAX ErrorHandler实现来处理解析中可能出现的问题
    • setEntityResolver() ,它采用SAX EntityResolver实现来处理实体解析

    清单4显示了这些方法的示例:

    清单4.使用JAXP DocumentBuilder
    // Get a DocumentBuilder instance
    DocumentBuilder builder = builderFactory.newDocumentBuilder();
    // Find out if validation is supported
    boolean isValidating = builder.isValidating();
    // Find out if namespaces are supported
    boolean isNamespaceAware = builder.isNamespaceAware();
    // Set a SAX ErrorHandler
    builder.setErrorHandler(myErrorHandlerImpl);
    // Set a SAX EntityResolver
    builder.setEntityResolver(myEntityResolverImpl);
    // Parse, in a variety of ways
    // Use a file
    Document doc = builder.parse(new File(args[0]));
    // Use a SAX InputSource
    Document doc = builder.parse(mySaxInputSource);
    // Use an InputStream
    Document doc = builder.parse(myInputStream, myDefaultHandlerInstance);
    // Use a URI 
    Document doc = builder.parse("http://www.newInstance.com/xml/doc.xml");

    如果您对DOM的本部分感到有些无聊,那么您并不孤单。 我发现写起来有点无聊,因为将您对SAX的了解应用于DOM非常简单。

    执行验证

    在Java 5.0(和JAXP 1.3)中,JAXP引入了一种验证文档的新方法。 验证不是在SAX或DOM工厂上简单地使用setValidating()方法,而是在新的javax.xml.validation包内将验证分为几个类。 我将需要比本文更多的空间来详细说明验证的所有细微差别-包括W3C XML Schema,DTD,RELAX NG模式和其他约束模型-但是如果您已经有了一些约束,那么使用起来就非常容易新的验证模型,并确保您的文档与之匹配。

    首先,将约束模型(大概是磁盘上的某个文件)转换为JAXP可以使用的格式。 将文件加载到Source实例中。 (我将在第2部分中更详细地介绍Source ;现在,只知道它代表磁盘上某个位置的文档,DOM Document或几乎所有其他内容。)然后,创建一个SchemaFactory并使用SchemaFactory.newSchema(Source)加载模式SchemaFactory.newSchema(Source) ,它返回一个新的Schema对象。 最后,使用该Schema对象,使用Schema.newValidator()创建一个新的Validator对象。 清单5应该使我刚才所说的一切更加清楚:

    清单5.使用JAXP验证框架
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document doc = builder.parse(new File(args[0]));
    
    // Handle validation
    SchemaFactory constraintFactory = 
        SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    Source constraints = new StreamSource(new File(args[1]));
    Schema schema = constraintFactory.newSchema(constraints);
    Validator validator = schema.newValidator();
    
    // Validate the DOM tree
    try {
        validator.validate(new DOMSource(doc));
        System.out.println("Document validates fine.");
    } catch (org.xml.sax.SAXException e) {
        System.out.println("Validation error: " + e.getMessage());
    }

    一旦掌握了它,这将非常简单。 自己输入此代码,或查看完整列表(请参阅下载 )。

    更改解析器

    更改JAXP工厂类使用的解析器很容易。 更改解析器实际上意味着更改解析器工厂,因为所有SAXParserDocumentBuilder实例都来自这些工厂。 工厂确定要加载哪个解析器,因此必须更改工厂。 要更改SAXParserFactory接口的实现,请设置Java系统属性javax.xml.parsers.SAXParserFactory 。 如果未定义此属性,则返回默认实现(无论供应商指定的解析器如何)。 相同的原则适用于您使用的DocumentBuilderFactory实现。 在这种情况下,将查询javax.xml.parsers.DocumentBuilderFactory系统属性。

    摘要

    阅读本文之后,您几乎已经了解了JAXP的全部范围:

    • 提供SAX的挂钩
    • 提供对DOM的挂钩
    • 允许解析器轻松更改

    要了解JAXP的解析和验证功能,您将花费很少的技巧。 使JAXP投入使用的最困难的部分是更改系统属性,通过工厂而不是解析器或构建器设置验证,并弄清JAXP 不是什么。 JAXP在两个流行的Java和XML API之上提供了一个有用的可插入性层。 它使您的代码供应商变得中立,并允许您从解析器更改为解析器,而无需重新编译解析代码。 因此,下载JAXP并开始吧! 第2部分将向您展示JAXP如何帮助您转换XML文档。


    翻译自: https://www.ibm.com/developerworks/java/library/x-jaxp/index.html

    展开全文
  • [2021-10-14 11:12:05.382] [ERROR] [main] [Configuration.java:2730]- [Failed to set setXIncludeAware(true) for parser org.apache.xerces.jaxp.DocumentBuilderFactoryImpl@4cbad1d4] java.lang....

    环境:jdk1.8.0_291
    项目引入了jaxen-1.1-beta-6.jar包
    项目启动报了如下的错:

    [2021-10-14 11:12:05.382] [ERROR] [main] [Configuration.java:2730]- [Failed to set setXIncludeAware(true) for parser org.apache.xerces.jaxp.DocumentBuilderFactoryImpl@4cbad1d4]
    java.lang.UnsupportedOperationException:  setXIncludeAware is not supported on this JAXP implementation or earlier: class org.apache.xerces.jaxp.DocumentBuilderFactoryImpl
    	at javax.xml.parsers.DocumentBuilderFactory.setXIncludeAware(DocumentBuilderFactory.java:584)
    	at org.apache.hadoop.conf.Configuration.loadResource(Configuration.java:2728)
    	at org.apache.hadoop.conf.Configuration.loadResources(Configuration.java:2696)
    	at org.apache.hadoop.conf.Configuration.getProps(Configuration.java:2579)
    	at org.apache.hadoop.conf.Configuration.set(Configuration.java:1257)
    	at org.apache.hadoop.conf.Configuration.set(Configuration.java:1229)
    	at com.code.common.hdfs.HDFSClient.init(HDFSClient.java:71)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement.invoke(InitDestroyAnnotationBeanPostProcessor.java:366)
    	at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleMetadata.invokeInitMethods(InitDestroyAnnotationBeanPostProcessor.java:311)
    	at org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization(InitDestroyAnnotationBeanPostProcessor.java:134)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(AbstractAutowireCapableBeanFactory.java:409)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1620)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:555)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:483)
    	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)
    	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
    	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)
    	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:761)
    	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:867)
    	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:543)
    	at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh(EmbeddedWebApplicationContext.java:122)
    	at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:693)
    	at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:360)
    	at org.springframework.boot.SpringApplication.run(SpringApplication.java:303)
    	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1118)
    	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1107)
    	at com.dragonsoft.cicada.datacenter.DataCenterWebApplication.main(DataCenterWebApplication.java:21)
    

    这个问题主要是:jaxen的包里面DocumentBuilderFactoryImpl没有实现DocumentBuilderFactory的setXIncludeAware这个方法。

    细节分析:
    org.apache.hadoop.conf.Configuration里面的loadResource方法中,构建DocumentBuilderFactory实例,一步一步跟进去看:
    在这里插入图片描述
    在这里插入图片描述

    static <T> T find(Class<T> type, String fallbackClassName)
            throws FactoryConfigurationError
        {
            final String factoryId = type.getName();
            dPrint("find factoryId =" + factoryId);
    
            // Use the system property first
            try {
                String systemProp = ss.getSystemProperty(factoryId);
                if (systemProp != null) {
                    dPrint("found system property, value=" + systemProp);
                    return newInstance(type, systemProp, null, true);
                }
            }
            catch (SecurityException se) {
                if (debug) se.printStackTrace();
            }
    
            // try to read from $java.home/lib/jaxp.properties
            try {
                if (firstTime) {
                    synchronized (cacheProps) {
                        if (firstTime) {
                            String configFile = ss.getSystemProperty("java.home") + File.separator +
                                "lib" + File.separator + "jaxp.properties";
                            File f = new File(configFile);
                            firstTime = false;
                            if (ss.doesFileExist(f)) {
                                dPrint("Read properties file "+f);
                                cacheProps.load(ss.getFileInputStream(f));
                            }
                        }
                    }
                }
                final String factoryClassName = cacheProps.getProperty(factoryId);
    
                if (factoryClassName != null) {
                    dPrint("found in $java.home/jaxp.properties, value=" + factoryClassName);
                    return newInstance(type, factoryClassName, null, true);
                }
            }
            catch (Exception ex) {
                if (debug) ex.printStackTrace();
            }
    
            // Try Jar Service Provider Mechanism
            T provider = findServiceProvider(type);
            if (provider != null) {
                return provider;
            }
            if (fallbackClassName == null) {
                throw new FactoryConfigurationError(
                    "Provider for " + factoryId + " cannot be found");
            }
    
            dPrint("loaded from fallback value: " + fallbackClassName);
            return newInstance(type, fallbackClassName, null, true);
        }
    
    

    这个方法,先会去从系统属性中获取资源名称,如果没有则尝试从$java.home/lib/jaxp.properties文件读取资源,如果还没有则通过应用类加载器找到类实例。因为我的系统属性没有这个资源名称,也没有jaxp.properties这个配置文件,所以会通过应用类加载器加载jaxen包下的类实例,DocumentBuilderFactory的setXIncludeAware这个方法,所以报了这个错。

    解决方法:

    方法一:(不建议)

    在你使用的jdk安装路径下的/jre/lib下面

    如果存在jaxp.properties则将其中内容改为下面的配置就可以了javax.xml.parsers.SAXParserFactory=com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl
    javax.xml.parsers.DocumentBuilderFactory=com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl

    如果不存在javafx.properties,创建文件,把内容复制粘贴进去,添加到/jre/lib下面

    方法二:
    创建一个包名路径与xercesImpl-2.6.2.jar里面DocumentBuilderFactoryImpl相同的类,然后在这个类里面实现setXIncludeAware的方法,然后重编译之后,将这个新类的class文件替换到xercesImpl-2.6.2.jar 里面。

    展开全文
  • jaxp的四个jar包

    热门讨论 2010-05-05 13:57:42
    jaxp-api.jar sax.jar dom.jar xercesImpl.jar
  • 1、JAXP的DOM方式API文档(*****) 2、JAXP的DOM方式操作(查找和添加节点)(*****) 3、JAXP的DOM方式操作(遍历、修改和删除节点)(*****) =================================================================...
    1、JAXP的DOM方式API文档(*****)
    2、JAXP的DOM方式操作(查找和添加节点)(*****)
    3、JAXP的DOM方式操作(遍历、修改和删除节点)(*****)
    ====================================================================
    1、jaxp的api的查看
        ** jaxp是javase的一部分
        ** jaxp解析器在jdk的javax.xml.parsers包里面
        ** 四个类:分别是针对dom和sax解析使用的类 
                DocumentBuilderFactory、DocumentBuilder、SAXParserFactory、SAXParser
        *** dom:
            DocumentBuilderFactory: 解析器工厂
                - 这个类是一个抽象类,不能new,
                newInstance() 获取 DocumentBuilderFactory 的实例。
            DocumentBuilder  : 解析器类
                - 这个类也是一个抽象类,不能new,
                    此类的实例可以从 DocumentBuilderFactory.newDocumentBuilder() 方法获取
                - 一个方法,可以解析xml, parse("xml路径") 返回是 Document 整个文档
                - 返回的document是一个接口,父节点是Node,如果在document里面找不到想要的方法,到Node里面去找
            在document里面方法
                getElementsByTagName(String tagname)
                    -- 这个方法可以得到标签
                    -- 返回集合 NodeList
                createElement(String tagName)
                    -- 创建标签
                createTextNode(String data)
                    -- 创建文本
                appendChild(Node newChild)
                    -- 把文本添加到标签下面
                removeChild(Node oldChild)
                    -- 删除节点
                getParentNode()
                    -- 获取父节点
                NodeList list
                    - getLength() 得到集合的长度
                    - item(int index)下标取到具体的值
                    for(int i=0;i<list.getLength();i++) {
                        list.item(i)
                    }
                Node节点是Document、Element、文本对象、属性对象的父亲。
                    getTextContent()
                    - 得到标签里面的内容
        *** sax:
            SAXParserFactory: 解析器工厂
            SAXParser:解析器类
    
    2、使用jaxp实现查询操作
        *** 查询xml中所有的name元素的值
        * 步骤
        //查询所有name元素的值
        1、创建解析器工厂
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        2、根据解析器工厂创建解析器
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
        3、解析器解析xml返回 Document对象
           Document document = documentBuilder.parse("src/person.xml");
        4、得到所有的name元素
            NodeList nodeList = document.getElementsByTagName("name");
        5、返回集合,遍历集合,得到每一个name元素
            - 遍历 getLength()、item()
            - 得到元素里面值 使用 getTextContent()
            for(int i=0;i<list.getLength();i++) {
                Node node = list.item(i); //第i个节点,下标从0开始
                String str = node.getTextContent(); //节点里面的值
            }
    3、使用jaxp添加节点
        *** 在第一个p1下面(末尾)添加 <sex>nv</sex>
        **步骤
            1、创建解析器工厂
                DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            2、根据解析器工厂创建解析器
                DocumentBuilder builder = builderFactory.newDocumentBuilder();
            3、解析xml,返回document
                Document document = builder.parse("src/person.xml");
            4、得到第一个p1
                - 得到所有p1,使用item方法下标得到
                NodeList list = document.getElementsByTagName("p1");
                Node p1 = list.item(0);
            5、创建sex标签 createElement
                Element sex1 = document.createElement("sex");
            6、创建文本 createTextNode
                Text text1 = document.createTextNode("nv");
            7、把文本添加到sex下面 appendChild
                sex1.appendChild(text1);
            8、把sex添加到第一个p1下面
                p1.appendChild(sex1);
            9、回写xml ! 以上修改的都是修改的读到内存中的Document对象,必须回写到硬盘上才能更改!
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
    4、使用jaxp修改节点
        /*
        * 1、创建解析器工厂
        * 2、根据解析器工厂创建解析器
        * 3、解析xml,返回document
        * 4、得到sex item方法
        * 5、修改sex里面的值  setTextContent方法
        * 6、回写xml
        * */
        //创建解析器工厂
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        //创建解析器
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
        //得到document
            Document document = builder.parse("src/person.xml");
        //得到sex
            Node sex1 = document.getElementsByTagName("sex").item(0);
        //修改sex值
            sex1.setTextContent("nan");
        //回写xml
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
    
    5、使用jaxp删除节点
        *** 删除<sex>nan</sex>节点
        ** 步骤
            /*
            * 1、创建解析器工厂
            * 2、根据解析器工厂创建解析器
            * 3、解析xml,返回document
            * 4、获取sex元素
            * 5、获取sex的父节点
            * 6、删除使用父节点删除 removeChild方法
            * 7、回写xml
            * */
            //创建解析器工厂
                DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            //创建解析器
                DocumentBuilder builder = builderFactory.newDocumentBuilder();
            //得到document
                Document document = builder.parse("src/person.xml");
            //得到sex元素
                Node sex1 = document.getElementsByTagName("sex").item(0);
            //得到sex1父节点
                Node p1 = sex1.getParentNode();
            //删除操作
                p1.removeChild(sex1);
            //回写xml
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                transformer.transform(new DOMSource(document), new StreamResult("src/person.xml"));
    
    6、使用jaxp遍历节点
        ** 把xml中的所有元素名称打印出来
        ** 步骤
        /*
        * 1、创建解析器工厂
        * 2、根据解析器工厂创建解析器
        * 3、解析xml,返回document
        * ====使用递归实现=====
        * 4、得到根节点
        * 5、得到根节点子节点
        * 6、得到根节点子节点的子节点
        * */
        ** 遍历的方法:递归遍历的方法
        private static void list1(Node node) {
            //判断是元素类型时候才打印
            if(node.getNodeType() == Node.ELEMENT_NODE) {
                System.out.println(node.getNodeName());
            }
            //得到一层子节点
            NodeList list = node.getChildNodes();
            //遍历list
            for(int i=0;i<list.getLength();i++) {
                //得到每一个节点
                Node node1 = list.item(i);
                //继续得到node1的子节点
                //node1.getChildNodes()
                list1(node1);
            }
        }
    
    
    展开全文
  • 1、jaxp解析器api的查看 jaxp解析器在jdk的javax.xml.parsers包里 四个类:分别针对dom和sax解析使用的类 针对dom类: DocumentBuilderFactory:解析器工厂 抽象类,不能new 需要用newInstance() 获取 ...
  • JAXP解析XML文件之DOM解析常用的XML解析器1) JAXP2) DOM4J3) JDOM4) Digester什么是JAXPJAXP 开发包是J2SE的一部分,它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成在javax.xml.parsers 包中,...
  • 通过两个步骤解决: 1.启动时添加参数 (1)首先,右键点击项目→... ... ...-Djavax.xml.parsers.DocumentBuilderFactory=com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl -Djavax.xml.parsers.SA
  • XML 解析之 jaxp 解析器

    2017-09-20 22:56:00
    jaxp 解析器, 由 SUN 公司提供的针对 dom 和 sax 的解析器 dom4j 解析器, 由 dom4j 组织提供的针对 dom 和 sax 的解析器 jaxp 解析器 jaxp 解析器在 JDK 的 javax.xml.parsers 包里面 DOM 解析使用到的...
  • XML解析开发包 :Jaxp(sun公司),Jdom,dom4j,XStream 用JAXP虽然是最不常用的一种解析方式,但是因为他是sun公司的标准,所以还是要简单学习一下。 一、JAXP解析XML—数据读取 jaxp包是j2se的一部分,在javax....
  • RESTful ServerTrack 使用 jetty、jersey 和 jaxp 在 java 中实现 建造: 要求:java8 和 maven3 - maven 的魔力将拉取所有的东西,所以其余的特定 jars 都在 pom.xml 中。 要构建项目,请打开一个终端窗口,cd 到...
  • JAXP解析XML

    千次阅读 2019-03-11 12:50:08
    JAXP解析XML JAXP代码实现步骤 ① 获取Document 我们在进行XML的时候,首先要拿到的肯定是实体文件在内存中的对象,API中叫Document JDK文档中Document是个接口类型,不能通过new等方式去获取到 获取解析器工厂...
  • 解析JAXP-源码

    2021-02-10 04:25:23
    解析JAXP
  •  Jaxp、Jdom、dom4j   JAXP 开发包是J2SE的一部分,它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成 在 javax.xml.parsers 包中,定义了几个工厂类,程序员调用这些工厂类,可以得到对xml文档...
  • XML有3中解析方式:Jaxp、Jdom和dom4j 这个是sun公司提供的简单的Jaxp解析方式。
  • XML解析 1 引入 xml文件除了给开发者看,更多的情况使用[程序读取xml文件]的内容。... 1)JAXP (oracle-Sun公司官方) 2)JDOM工具(非官方) 3)Dom4J工具(非官方) 三
  • jing-jaxp-test-源码

    2021-05-02 10:34:16
    喝杯咖啡,然后进行mvn test 。 使用Jing通过JAXP API验证带有名称空间的XML文件。 展位有效和无效的xml文件都经过测试。 与相关
  • 使用SAX的优势在于其解析速度较快,相对于DOM而言占用内存较少。这篇文章主要介绍了Java中使用jaxp进行sax解析,需要的朋友可以参考下
  • 十月 31, 2018 3:17:28 下午 org.apache.catalina.core.ApplicationDispatcher invoke SEVERE: Servlet.service() for servlet jsp threw ...java.lang.ClassNotFoundException: org/apache/xerces/jaxp/Documen...
  • 关于JAXP, JAXB, SAX, StAX, DOM等名词解释   DOM(Document Object Model):SAX和DOM最先出来的两种解析器。是一种tree-based API。DOM的特点是,把整个XML内容读取内存中进行处理。  优点:可以随机进行对...
  • 主要介绍了使用jaxp进行dom解析的相关资料,需要的朋友可以参考下
  • javax.servlet.ServletException: javax.xml.parsers.FactoryConfigurationError: Provider org.apache.xerces.jaxp.DocumentBuilderFactoryImpl not found at org.apache.jasper.servlet.JspServlet.service(Jsp...
  • jaxp解析xml

    2018-01-28 15:01:38
    因为jaxp是sun公司推出的一个解析xml的技术,所以在解析xml时,不用像dom4j一样导入jar包。jaxp用到的东西都包含在jre中。使用jaxp的局限性较大,比如不能创建一个xml文件,只能读取已有的文件。 这里简单介绍jaxp...
  • 自从上一个 JAXP 重要版本(JAXP 1.1)发布以来,过去三年中,这些规范没有一个是保持原封不动的,因此 JAXP 也升级到 1.3 版,以使这些规范能够进入 J2SE 和 J2EE。 XML 标准的演化 W3C 在 2004 年初最终确定...
  • 利用Jaxp实现对xml的增删改查 创建xml文件 创建一个jaxp类 创建一个测试类 <person> <p1> <name>zhangsanname> <age>20age> <gender>femalegender> <gender>malegender>p1> <p1> <name>lisiname> <age>18age> <age>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,266
精华内容 8,506
关键字:

JAXP