[October 05, 2000] Java API for XML Parsing Release 1.0 is a library which provides core functionality necessary in most Java based applications of the Extensible Markup Language (XML) 1.0. library corresponds to the core part of an XML based application framework. On that core can be built services and applications. These are briefly presented here to help developers understand the intended role of this library. Core: Core functionality includes pluggability of parsers, parsing XML documents (including optional validation) and constructing in-memory tree structured object models of such documents. Both the parsing and object model APIs have an API structure consisting of an interface (currently SAX 1.0 and the DOM Level 1 core, respectively) and the JAXP APIs have an API structure consisting of abstract classes providing a thin layer for pluggability of parsers.The reference implementation of the above packages is currently in the com.sun.xml.* portion of the Java package namespace. Services: A variety of facilities can be built on top of core APIs, but are sufficiently specialized that not all environments supporting XML would require them. For example, Extensible Stylesheet Language (XSL) provides a way to translate XML into other XML structures, including ones which are legal HTML or which use 'flow objects' to support publication quality rendering. (HTML can not support that quality of document rendering.) A package supporting the transformation parts of XSL could be useful in many environments, including XML document servers. A package supporting 'flow/formmating' objects from the XSL specification would be useful where high quality rendering was needed, including publishing applications with 'what you see is what you get' (WYSIWYG) editing. Some services such as WebDAV might use XML internally, and not expose it. Other examples of XML-based services include support for XML based linking (XPointer/XLink), a variety of services supporting integration with relational or object databases, specialized vertical market toolsets, and messaging frameworks. Messaging frameworks could include support for XML-based data marshaling, asynchronous messaging systems such as the Java Messaging Service (JMS), and synchronous messaging systems (categorized as "Remote Procedure Calls", RPCs) including those constructed directly on top of HTTP/HTTPS messaging. Applications: Applications build on the core, often building on higher level services. Two broad categories of particular interest include web-based information publishing systems, and business-to-business electronic commerce frameworks bringing older Electronic Data Interchange (EDI) technology into the Internet in applications such as supply chain integration. Applications may have server side components, client side ones, or both. Web based server side components will often be built using Java Servlets or JavaServer Pages. Another category of applications is developer tools, perhaps supporting database integration or providing a better coupling between object level modeling (e.g., with UML) and XML DTDs/Schemas."
| Last modified: January 13, 2004 |
| Java API for XML Parsing (JAXP) |
Principal References
JAXP project summary - Version 1.1
Java API for XML Parsing. Java API for XML Parsing (JAXP) Optional Package provides basic functionality for reading, manipulating, and generating XML documents through pure Java APIs. Download.
[November 23, 1999] "JAXP Specification v1.0 Public Draft 1." Announcement. The Java API for XML Parsing Specification v1.0 has now been released as Public Draft 1. The Java API for XML Parsing (JAXP) Optional Package provides basic functionality for reading, manipulating, and generating XML documents through pure Java APIs. This API optional package provides a standard way for any XML-conformant parser to be accessed by an application. The reference implementation uses the high performance Java Project X as its default XML parser. However, the software's pluggable architecture allows any XML conformant parser to be used."
The GNU JAXP Project. "GNU JAXP, a part of the GNU Classpath Extensions project, is a free implementation of the standard XML processing APIs for Java."
java.sun.com - Java Technology and XML
Articles, Papers, News
[May 13, 2003] "Transparently Cache XSL Transformations with JAXP. Boost Performance and Retain Usability by Implementing Implicit Caching Inside Transformer Factories." By Alexey Valikov. In JavaWorld (May 02, 2003). ['When using XSLT (Extensible Stylesheet Language Transformations) in Web environments, where numerous concurrent threads repeatedly use transformations, implementing a stylesheet cache drastically boosts performance. However, using a stylesheet cache on top of normal JAXP (Java API for XML Parsing) is often not convenient or suitable for pure JAXP users. This article introduces the idea of pushing cache functionality inside transformer factory implementations, making cache usage absolutely transparent.'] "No doubt, XSLT (Extensible Stylesheet Language Transformations) is a powerful technology that has many applications in the XML world. In particular, numerous Web developers can take advantage of XSLT at the presentation layer to gain convenience and flexibility. However, the price of these advantages is higher memory and CPU load, which makes developers more attentive to optimization and caching techniques when using XSLT. Caching is even more important in Web environments, where numerous threads share stylesheets. In these cases, proper transformation caching proves vital for performance. A usual recommendation when using the Java API for XML Processing (JAXP) is to load transformations into a Templates object and then use this object to produce a Transformer rather than instantiate a Transformer object directly from the factory. That way, a Templates object may be reused to produce more transformers later and save time on stylesheet parsing and compilation... [However,] although this technique positively influences performance... it is not convenient for the developer... you must care about observing the date of the last stylesheet modification, reloading outdated transformations, providing safe and efficient multithreaded access to the stylesheet cache, and many other small details. Even a natural move -- encapsulating all the required functionality into a standalone transformer cache implementation -- will not save a developer from third-party modules, which use standard JAXP routines without any caching... There is, however, a simple and elegant solution to this problem. As long as JAXP allows us to replace a used implementation of the TransformerFactory, why don't we simply write a factory that would have intrinsic caching capabilities? [With this factory implementation] you have one less headache: you no longer have to worry about loading, caching, and reloading stylesheets. You are guaranteed that third-party libraries that use standard JAXP will use caching as well. You can be sure of no concurrent cache access conflicts, and the cache will not be a bottleneck. There are, however, several disadvantages... First, this factory caches only those stylesheets loaded from files. The reason is because, while we can easily check the timestamp of the file's last modification, this is not always possible for other sources. Another problem remains with stylesheets that import or include other stylesheets. Modification of the imported or included stylesheet will not let the main stylesheet reload. Finally, extending an existing factory implementation binds you to a certain XSLT processor (unless you write a caching extension for every factory you might use). Happily, in most cases, these issues are not crucial, and we can take advantage of factory-based caching: transparency, convenience, and performance..."
[August 23, 2001] "Working with XML: The Java API for Xml Parsing (JAXP) Tutorial." By Eric Armstrong. Announced by Eric Armstrong 2001-08-22. Version 1.1. 494 pages. ['A PDF version of the JAXP 1.1 tutorial is now available. HTML versions of all XML, DTD, and XSL files were created to make those files viewable in PDF (as well as in a normal browser). The tutorial pages now contain additional inks to those files. The planned work on the JAXP 1.1 tutorial is now complete.'] "This tutorial covers the following topics: Part I: Understanding XML and the Java XML APIs explains the basics of XML and gives you a guide to the acronyms associated with it. It also provides an overview of the Java TM XML APIs you can use to manipulate XML-based data, including the Java API for XML Parsing ((JAXP). To focus on XML with a minimum of programming, follow The XML Thread, below. Part II: Serial Access with the Simple API for XML (SAX) tells you how to read an XML file sequentially, and walks you through the callbacks the parser makes to event-handling methods you supply. Part III: XML and the Document Object Model (DOM) explains the structure of DOM, shows how to use it in a JTree, and shows how to create a hierarchy of objects from an XML document so you can randomly access it and modify its contents. This is also the API you use to write an XML file after creating a tree of objects in memory. Part IV: Using XSLT shows how the XSL transformation package can be used to write out a DOM as XML, convert arbitrary data to XML by creating a SAX parser, and convert XML data into a different format. Additional Information contains a description of the character encoding schemes used in the Java platform and pointers to any other information that is relevant to, but outside the scope of, this tutorial... Scattered throughout the tutorial there are a number of sections devoted more to explaining the basics of XML than to programming exercises: A Quick Introduction to XML; Writing a Simple XML File; Substituting and Inserting Text; Defining a Document Type; Defining Attributes and Entities; Referencing Binary Entities; Defining Parameter Entities; Designing an XML Document..." [cache]
[February 27, 2001] "Working with XML: The Java API for XML Parsing (JAXP) Tutorial." By Eric Armstrong. [Updated: "Remember that all the package names have changed! So none of the examples will work, for the moment. However, most of the information is still applicable."] This tutorial covers the following topics: (1) Part I: Understanding XML and the Java XML APIs explains the basics of XML and gives you a guide to the acronyms associated with it. It also provides an overview of the Java XML APIs you can use to manipulate XML-based data. To focus on XML with a minimum of programming, follow The XML Thread, below. (2) Part II: Serial Access with the Simple API for XML (SAX) tells you how to read an XML file sequentially, and walks you through the callbacks the parser makes to event-handling methods you supply. (3) Part III: XML and the Document Object Model (DOM) explains the structure of DOM, shows how to use it in a JTree, and shows how to create a hierarchy of objects from an XML document so you can randomly access it and modify its contents. This is also the API you use to write an XML file after creating a tree of objects in memory. (4) Additional Information contains a description of the character encoding schemes used in the Java platform and pointers to any other information that is relevant to, but outside the scope of, this tutorial..."
[February 09, 2001] "JavaTalk: DOM and the Java API for XML." By John Wetherill. In SunServer Magazine Volume 15, Number 2 (February 2001), page 6. "The Java API for XML Processing (JAXP) encompasses three distinct Java APIs designed to process XML content using Java technology. These include SAX (Simple API for XML), DOM (Document Object Model), and XSLT (Extensible Stylesheet Language Transformations). Last month we looked at SAX, which serially parses an XML document. This column will examine the details of DOM and contrast it with SAX. DOM was defined by the W3C (unlike SAX which was created by participants in the XML-DEV mailing list), and has evolved into a standard. It is comparatively easy to use and provides the developer with a tree structure representing XML content. This structure can be manipulated directly by the application and is ideal for interactive applications that need to access and modify XML content directly. DOM has no specific ties to the Java language as it was defined to be platform and language neutral. Several DOM bindings currently exist, including Java, ECMAScript (a standardized JavaScript), and a language-neutral IDL based binding. This article will focus on the Java binding. Because the tree-structure representing the entire XML content is maintained in-memory, DOM-based applications can be CPU- and memory- intensive. Generally SAX, with its serial call-back mechanism for XML parsing, is more suitable for performance-sensitive server applications. DOM, on the other hand, is more appropriate for interactive applications which need to access the entire XML content at once. JAXP is an abstract layer on top of DOM, defining a pluggable architecture for XML-compliant parsers. The specific XML parser that is used can change without requiring any modifications to the application source code. JAXP provides a standard way to interpret, manipulate and save XML content, as well as a mechanism to translate XML and apply style sheets. Currently the specification for JAXP is part of the JCP, and was due to be finalized and ship early this year. A useful distinction to make between DOM and SAX centers on the lifecycle of a program using each. The lifecycle of a SAX-based application is equal to that of the parsing process. Here the application will receive callbacks during parsing, and will typically exit when parsing completes. By contrast, the lifecycle of a DOM-based application begins when parsing is complete. The DOM application will receive a node for the tree representing the entire document. Given this information, the application can traverse the document tree, then write, modify and store the XML content..."
[January 19, 2001] "JavaTalk: Parsing XML using the Java API for XML Processing (JAXP)." By John Wetherill (Staff engineer, Sun Microsystems). In SunServer Magazine Volume 15, Number 1 (January 2001), pages 5-6. ['If you're an enterprise Java developer, chances are good that you will at one point be required to incorporate XML in a Java program. Naturally, there are many Java XML APIs available today -- one of these is JAXP, the Java API for XML Processing.'] "XML is platform-neutral, hierarchical, human-readable, easily parsable by machine, and thus is the ideal format data exchange in e-commerce and B2B applications. If you're an enterprise Java developer, chances are good that you will at one point be required to incorporate XML in a Java program. Naturally, there are many Java XML APIs available today, with more coming. Let's dive right in and take a look at one of these: JAXP, the Java API for XML Processing, recently developed under the Java Community Process. JAXP is an abstract layer that sits on top of two existing XML APIs: SAX (Simple XML API) and DOM (Document Object Model). Here we will focus only on using JAXP with SAX. A followup article will look at the use of JAXP with DOM, as well as other APIs to process XML from Java... SAX, developed by participants in the XML-DEV mailing list, uses a callback approach to serially parse an XML document. A parser engine interprets the XML content and makes callbacks on methods in a document handler. One drawback of the original SAX specification is that the vendor-provided parser engine must be obtained in a vendor-specific manner, and programs written to that engine are not portable across arbitrary parsers. This is where JAXP comes in. JAXP is an abstract layer that sits on top of SAX, and uses the factory-design pattern to provide vendor-neutral access to the SAX parser. SAX defines two components which handle the interpretation of an XML document: a parser, which is a vendor supplied engine that does the grunt-work of reading and interpreting the XML, and a DocumentHandler, which receives callbacks from the parser during the parsing process. In general, writing a SAX-based Java program to parse XML content involves a DocumentHandler class containing handler methods that respond to the callbacks generated by the parser, obtaining the parser, and telling the parser which DocumentHandler to use during parsing... JAXP supports the input of XML from InputStreams, Files, URIs and SAX input sources, providing a basis for accessing XML from a huge variety of application contexts. For more information, and to obtain Sun's JAXP reference implementation, visit: java.sun.com/xml."
[December 04, 2000] "Sun Announces XML for Java Interface Specs." By Peter Sayer. In InfoWorld (December 04, 2000). "Sun Microsystems published details on Monday of two new interfaces to link its Java programming language to XML. The two new Java APIs -- JAXM (Java API for XML Messaging) and JAXP (Java API for XML Parsing) -- and a slew of supporting acronyms deal with the messaging and parsing of XML. Work on the APIs is still continuing, and Sun described the information released Monday as "early access" versions of the specifications. The APIs, along with the still incomplete JAXB (Java API for XML Data Binding), form the core of Sun's support for XML in the Java 2 platform, the company said in a statement. All three technologies are being developed through the Java Community Process (JCP), an organization set up by Sun to manage the evolution of Java. JAXM enables packaging, routing, and transport of XML and other messages using HTTP, SMTP, and FTP, and will be useful to programmers building robust, secure e-commerce applications, Sun said. Future versions of the API will support other messaging methods, including those being defined in the ebXML (electronic business XML) initiative framework by OASIS (Organization for the Advancement of Structured Information Standards) and the UN/CEFACT (United Nations Center for Trade Facilitation and Electronic Business). Sun said it expects the final version of JAXM to be ready in early 2001, and hopes to make the specification available through "a credible open-source organization, such as the Apache Software Foundation." The other API, JAXP, enables Java applications to read, manipulate, and generate XML documents. The draft version of the specification is available through JCP and supports XML standards including the recently released Document Object Model (DOM) Level 2, Sun said. It expects to ship the final version in the first quarter of next year. The third, as-yet unreleased API, is intended to help develop and maintain XML-enabled applications with a minimum of effort. JAXB maps XML documents to Java objects. It will include a compiler that can automatically generate Java classes from XML schemas without developers having to write any parsing code. The compiler will automatically check XML messages for errors and validity..."
[December 01, 2000] "Sun's Java API for XML Parsing, Version 1.1. JAXP Revisited." By Brett McLaughlin (Enhydra Strategist, Lutris Technologies). From IBM developerWorks, XML zone. December 1, 2000. ['In this follow-up article on JAXP, Sun's Java API for XML Parsing, the author analyzes the newest version, 1.1, which includes updated support for the SAX and DOM standards. With the addition of TRaX, JAXP 1.1 provides Java and XML developers an indispensable tool in writing vendor-neutral code for parsing and transforming XML documents.'] "I'm a member of the expert group for JAXP 1.1, and we're nearing completion on the 1.1 specification. While most 'point releases' (in which a version moves from 1.0 to 1.1, or 2.2 to 2.3) result in minor, or at least simple, changes to existing APIs, the 1.1 release of JAXP is significantly different than its predecessor. In fact, I'll spend only about one third of this article covering new methods on existing classes and functionalities; the rest of the article will focus on completely new classes and features of the 1.1 version of JAXP. In other words, there's just so much new in JAXP 1.1 that I couldn't wait to give you a taste of what's coming... The most anticipated change from JAXP 1.0 to 1.1 is the updated support for the popular SAX and DOM standards. SAX, the Simple API for XML, had a version 2.0 release in May of 2000 that provided greatly enhanced support for XML namespaces, among other items. This namespace support enables the use of numerous other XML vocabularies, such as XML Schema, XLink, and XPointer. While it was possible to use these vocabularies in SAX 1.0, the burden was on the developer to split an element's local (or qualified) name from its namespace, and keep track of namespaces throughout the document. SAX 2.0 provides this information to the developer, dramatically simplifying the process of carrying out these programming tasks. The same goes for DOM Level 2: namespace support, as well as a wealth of other methods on the DOM classes, is available. While DOM Level 2 has not been finalized, JAXP 1.1 supports the specification as it now stands. As minor changes get introduced in the final stages of the DOM standard, JAXP will, of course, include these modifications. The good news is that these changes are generally transparent to the developer using JAXP... The public draft of the specification, in its final form, should be available close to the end of the year 2000. The actual reference implementation should follow shortly, with all loose ends tied up by the first quarter of 2001. You'll want to be careful when looking up resources on JAXP since the current draft of the specification (as of early November 2000) does not include the TRaX API..."
[November 25, 2000] "Java API for XML Processing. Version 1.1. Public Review 2." By Rajiv Mordani, James Duncan Davidson, and Scott Boag. November 18, 2000. Updated Java API for XML Processing 1.1, Public Review 2 - JSR-000063. 132 pages. "This document describes the Java API for XML Processing, Version 1.1. This version of the specification introduces basic support for parsing and manipulating XML documents through a standardized set of Java Platform APIs. When this specification is final there will be a Reference Implementation which will demonstrate the capabilities of this API and will provide an operational definition of the specification. A Technology Compatibility Kit (TCK) will also be available that will verify whether an implementation of this specification is compliant. These are required as per the Java Community Process 2.0 (JCP 2.0). This specification is intended for use by: (1) Parser Developers wishing to implement this version of the specification in their parser. (2) Application Developers who use the APIs described in this specification and wish to have a more complete understanding of the API..." Other references for the Sun Java API for XML Parsing (JAXP): (1) Version 1.1 specification; (2) download; (3) Java Technology and XML.
[November 01, 2000] "All About JAXP. Sun's Java API for XML Parsing." By Brett McLaughlin (Enhydra Strategist, Lutris Technologies). From IBM developerWorks, XML zone. November 1, 2000. ['This close examination of JAXP, Sun's Java API for XML, helps clear up the confusion about the specific nature of JAXP and the purpose it serves. This article covers basic concepts of JAXP, demonstrates why it is needed in the XML parsing space, and shows how the parser used by JAXP can easily be changed. It also drills down into SAX and DOM, two popular JAXP-related Java and XML APIs.'] "Java and XML have made news in every area of technology and are arguably the most important developments of 1999 and 2000 for software developers. As a result, the number of Java and XML APIs has proliferated. The two most popular, DOM and SAX, have generated a tremendous amount of interest, while JDOM and data-binding APIs have followed. Understanding even one or two of these thoroughly is quite a task; using all of them correctly makes you quite a guru. But in the last year, another API has made a big impression: Sun's Java API for XML, more commonly known as JAXP. This development isn't too surprising considering Sun didn't have any XML-specific offerings for its platform. What is surprising is the lack of understanding about JAXP. Most developers who use it have a misconception about the very API they are depending on... Strictly speaking, JAXP is an API, but it is more accurately called an abstraction layer. It does not provide a new means of parsing XML, add to SAX or DOM, or provide new functionality to Java and XML handling. (If you're in disbelief at this point, you're reading the right article!) Instead, it makes it easier to deal with some difficult tasks with DOM and SAX. It also makes it possible to handle some vendor-specific tasks that are encountered when using the DOM and SAX APIs in a vendor-neutral way. While I'll go through all of these features individually, the thing you really need to get a handle on is that JAXP does not provide parsing functionality! Without SAX, DOM, or another XML parsing API, you cannot parse XML. I have seen many requests for a comparison of DOM, SAX, or JDOM to JAXP. Making these comparisons is impossible because the first three APIs serve a completely different purpose than JAXP. SAX, DOM, and JDOM all parse XML. JAXP provides a means to get to these parsers and results. It doesn't offer a new way to parse the document itself. This is a critical distinction to make if you're going to use JAXP correctly. It will also most likely put you miles ahead of many of your fellow XML developers... Other than not having SAX 2.0 and DOM Level 2 support, JAXP provides a helpful pluggability layer over two popular Java and XML APIs. It makes your code vendor-neutral and allows you to change from parser to parser without ever recompiling your parsing code. So download JAXP from Sun, Apache XML, or anywhere else you can get your hands on it, and go to it! Stay tuned for JAXP 1.1, with important additions like support for SAX 2 and DOM 2, XSLT, and more..."
See also: Java Project X [Sun XML Library]
See also: Xapi-J - A Standardized XML API in Java
