JAXP

That was the initial reason for JAXP to exist: to remove any chance of you putting that sort of information directly into your code.

JAXP initially had the goal to remove some of the vendor-specific details, related to which XML parser was used, from SAX and DOM code.

This shouldn't be too much of a surprise: XPath is a core part of JAXP now, and JAXP provides integrated DOM support as well.

JAXP lets you do a lot more than just pass in files, as you'll learn in the next section, Input and output.

Both are easy to deal with and shouldn't pose any difficulty when using JAXP.

JAXP would still have the benefit of making translation between SAX and DOM easy, but this would be a nice nod to the XML community.

First, convert your constraint model -- presumably a file on disk somewhere -- into a format that JAXP can use.

In Part 1, you saw that you can replace the default JAXP parser implementation with your own implementation by changing a system property.

In this version of JAXP, the changes to the javax. xml. transform package mainly focus on fixing bugs and clarifying some parts of the API.

To understand JAXP's parsing and validation features, you'll wade through very little tricky material.

As you learned in Part 1, JAXP is a layer over SAX and DOM that enables Java programmers to perform vendor-neutral XML parsing.

JAXP will help you transform XML, but it won't get you to a binary format.

Get a factory class to provide instances of a vendor-specific JAXP implementation.

It's easy to change out the parser that the JAXP factory classes use.

Using a Sun-specific class, then, violates the point of using JAXP.

But JAXP's dullness has lulled developers away from looking to it for new features.

With this added flexibility, you can insert JAXP into any of your XML event chains.

It also integrates easily with your existing JAXP code, making the addition of schema validation a snap.

You are certainly encouraged to check these out in the latest JAXP specification online (see the Resources section).

As shown in Listing 7, it is fairly simple to initiate the XSLT transformation using JAXP and the XSLT engine shipped with the JDK.

It simply takes in XML on the command line and then loads that XML into a DOM tree using the JAXP DOM APIs.

What isn't moot, and worth continuing discussion, is what JAXP is now, and how it's being used.

As minor changes get introduced in the final stages of the DOM standard, JAXP will, of course, include these modifications.

Class, rather than letting a JAXP or SAX implementation handle this task for you.

That's beyond the scope of this article, but for details you can refer to the JAXP tutorial at Sun.

Read Part 1 of this two-part series, which introduces JAXP and its parsing and validation features.

In other words, there's just so much new (and good) in JAXP 1. 1 that I couldn't wait to give you a taste of what's coming.

In normal JAXP processing, everything begins with a factory.

In its early incarnations, JAXP was little more than a thin veneer over SAX and DOM -- and over outdated versions of those APIs, at that.

This step is needed only if you want to select a specific DOM to be used by JAXP; otherwise, it uses a default implementation.

For this reason, JAXP provides methods to determine the parser's settings.

Many of the changes to the JAXP API have centered around parsing, which makes sense, given that the "P" in JAXP stands for "parsing. "

Second, a major purpose of JAXP is to provide vendor independence when dealing with parsers.

Behind the scenes, the JAXP implementation takes care of the vendor-dependent code, keeping your code happily unpolluted.

Understanding this distinction is critical if you're going to use JAXP correctly.

JAXP provides a standardized interface for parsing and transforming XML documents.

If your parser is not JAXP 1. 2-compliant, it throws a SAXNotRecognizedException exception when you try to set the property.

Understanding XSL's basic program flow is crucial to grasping how JAXP handles transformations.

In theory, the last option should make it easier to interact with other JAXP technologies, such as SAX and DOM.

The same principle applies for JAXP, but it isn't as clearly publicized: JAXP comes with a parser so it can be used immediately.

The source object allows any APIs that understand JAXP sources to read the data.

JAXP was initially intended merely to provide convenience and vendor-neutrality to SAX and DOM.

JAXP can accept XML as a file or as a stream wrapped around a file, for obvious reasons.

As you may recall from JAXP 1. 0, the SAXParserFactory class allows configuration of SAXParser instances returned from the factory.

That said, even advanced developers who use JAXP often have misconceptions about the very API they depend on.

While DOM Level 2 has not been finalized, JAXP 1. 1 supports the specification as it now stands.

JDBC 4. 0 allows the XML data to be accessed through strings, reader and writer streams, or JAXP sources and results.

JAXP is not a general transformation engine.

Strictly speaking, JAXP is an API, but it is more accurately called an abstraction layer.

And JAXP's goal was simple: to make using SAX and the DOM easier, in particular in the area of vendor neutrality.

Instead, JAXP makes it easier to use DOM and SAX to deal with some difficult tasks.

Not only does JAXP break out the final linefeed separately, it also decomposes the first chunk of text into three separate pieces.

If you're rusty on how to get a DOM tree from various sources using JAXP, check out Resources for some helpful links.

In both cases, though, the parser is part of the JAXP distribution, but not part of the JAXP API.

JAXP 1. 3 completes the mapping by defining the missing types as a part of the Java platform.

Saxon implements the TrAX (transformation API for XML) interface defined as part of the JAXP 1. 1 Java extensions.

This lack of updated standards has been one of the biggest criticisms of JAXP 1. 0.

In fact, many developers (maybe even you) use SAX, DOM, or JDOM without even touching JAXP.

However, many people refer to the classes included in Sun's parser as part of the JAXP API itself.

Just about a month ago, I wrote a piece entitled " All About JAXP. "

You can use any JAXP-compliant parser framework for these values.

So far, this is just standard JAXP and DOM, nothing really new.

It is part of Sun's Crimson parser, packaged in earlier versions of JAXP.

This package has existed since JAXP 1. 0. It defines a vendor-neutral API for parsing and validating XML documents using SAX or DOM.

Now, with JAXP 1. 3, you can parse, validate, and transform XML without ever writing a line of vendor-specific code.

More and more, JAXP is no longer wraps SAX and DOM, but actually replaces them.

The flexibility of JAXP lies in how you can represent XML.

JAXP 1. 2, a maintenance release for JAXP, fills in the blanks by providing a standard mechanism on the Java platform.

The JAXP 1. 3 specification defines a simple API that allows applications to compile and cache schemas.

Demonstrates how to use the new properties in JAXP 1. 2 To validate a document through a SAX parser.

Part 2 will show you how JAXP can help you transform XML documents.

If your parser is not JAXP 1. 2-compliant, it will throw an IllegalArgumentException exception.

A compliant JAXP implementation must support W3C XML Schema. Supporting other languages, such as RELAX NG, is optional.

JAXP is a lot simpler than people think.

JAXP 1. 3 requires that all three be implemented by conforming parsers.

The most anticipated change from JAXP 1. 0 to 1. 1 is the updated support for the popular SAX and DOM standards.

Set the properties for the schema language and schema source (this is new to JAXP 1. 2 and schema).

But the most significant changes in JAXP 1. 1 center around XML transformations, which I will cover later in this article.

This tip shows you how to implement robust document validation with XML schema and JAXP 1. 2.

Still, the core ideas outlined here will appear in JAXP 1. 1 in some form.

The previous version of JAXP only supported SAX 1. 0 and DOM Level 1.

To test Listing 2, you need a JAXP 1. 2-compliant parser.

I'm a member of the expert group for JAXP 1. 1, and we're nearing completion on the 1. 1 specification.

JAXP 1. 3, which will be part of J2SE 5 and J2EE 4, is the first major release of this API in over three years.

The bad news is that until JAXP 1. 3 is finalized, no standard API can do that.

In Java 5. 0 (and JAXP 1. 3), JAXP introduces a new way to validate documents.

Like the parsing portion of JAXP, performing XML transformations requires three basic steps

As with its input counterpart, you'll generally use JAXP's concrete Result implementations

JAXP 1. 2 Also defines schema support for the DOM parser, as shown in

Listing 2 shows examples of the various uses of the SAXParser class, the core class in JAXP for SAX parsing

As simple as all of this is, using JAXP this way has two significant limitations