The DOM Level 3 Core functionality is not exposed in the regular
Xerces distribution.
To get access to the DOM Level 3, extract source code from CVS and
build Xerces with the target jars-dom3. The build will generate
the xmlParserAPIs.jar that includes DOM Level 3 interfaces in
org.w3c.dom and org.w3c.dom.ls packages,
xercesImpl.jar that includes partial DOM Level 3 implementation
and xercesSamples.jar that includes sample code
(see samples.dom.DOM3).
You can use DOM Level 3 Load/Save interfaces with the default Xerces distribution. To access the DOM Level 3 Core functionality you need to extract the code from CVS and build Xerces with the jars-dom3 target.
How do I create a SAX parser?
You can create a SAX parser by using the Java APIs for
XML Processing (JAXP). The following source code shows
how:
How can I make sure that my DOM document in memory conforms to a schema?
DOM revalidation is supported via W3C DOM Level 3 Core
Document.normalizeDocument().
This release only supports revalidation against XML Schemas.
Revalidation against DTDs or any other schema type is not implemented.
To revalidate the document you need:
Build DOM Level 3 Xerces jars
(see How do I access the DOM Level 3 functionality).
Create the DOMBuilder (see Creating DOM parser)
or use DOM methods to create a tree in memory.
Set validate feature using setNormalizationFeature
method.
Make sure your document has xsi:schemaLocation or
xsi:noSchemaLocation
attributes at the document root that specify the location of schema(s)
against which validation should occur.
The documentURI must be set. Locations of the schema documents
will be resolved relative to the documentURI.
You should register an error handler with the parser by supplying
a class which implements the org.xml.sax.ErrorHandler
interface. This is true regardless of whether your parser is a
DOM based or SAX based parser.
You can register an error handler on a DocumentBuilder
created using JAXP like this:
If you are using DOM Level 3
you can register an error handler with the DOMBuilder by supplying
a class which implements the org.w3c.dom.DOMErrorHandler
interface.
You can also register an error handler on a SAXParser using JAXP
like this:
How can I control the way that entities are represented in the DOM?
The DOM Level 3 feature entities (or corresponding Xerces http://apache.org/xml/features/dom/create-entity-ref-nodes feature)
control how entities appear in the DOM tree. When one of those features
is set to true (the default), an occurance of an entity reference
in the XML document will be represented by a subtree with an
EntityReference node at the root whose children represent the
entity expansion.
If the feature is false, an entity reference in the XML document
is represented by only the nodes that represent the entity
expansion.
In either case, the entity expansion will be a DOM tree
representing the structure of the entity expansion, not a text
node containing the entity expansion as text.
Why does "non-validating" not mean "well-formedness
checking only"?
Using a "non-validating" parser does not mean that
only well-formedness checking is done! There are still many
things that the XML specification requires of the parser,
including entity substitution, defaulting of attribute values,
and attribute normalization.
This table describes what "non-validating" really
means for Xerces-J parsers. In this table, "no DTD"
means no internal or external DTD subset is present.
non-validating parsers
validating parsers
DTD present
no DTD
DTD present
no DTD
DTD is read
Yes
No
Yes
Error
entity substitution
Yes
No
Yes
Error
defaulting of attributes
Yes
No
Yes
Error
attribute normalization
Yes
No
Yes
Error
checking against model
No
No
Yes
Error
How do I associate my own data with a node in the DOM tree?
The class org.apache.xerces.dom.NodeImpl provides a
void setUserData(Object o) and an Object
getUserData() method that you can use to attach any object
to a node in the DOM tree.
Beware that you should try and remove references to your data on
nodes you no longer use (by calling setUserData(null),
or these nodes will not be garbage collected until the entire
document is garbage collected.
If you are using Xerces with the DOM Level 3 support
you can use org.w3c.dom.Node.setUserData() and register your own
UserDataHandler.
How do I more efficiently parse several documents sharing a
common DTD?
By default, the parser does not cache DTD's. The common DTD,
since it is specified in each XML document, will be re-parsed
once for each document.
However, there are things that you can do to make the
process of reading DTD's more efficient:
First, have a look at the grammar caching/preparsing FAQ:
keep your DTD and DTD references local
use internal DTD subsets, if possible
load files from server to local client before parsing
Cache document files into a local client cache. You should do an
HTTP header request to check whether the document has changed,
before accessing it over the network.
Do not reference an external DTD or internal DTD subset at all.
In this case, no DTD will be read.
Use a custom EntityResolver and keep common
DTDs in a memory buffer.
How can I parse documents in a pull-parsing fashion?
Since the pull-parsing API is specific to Xerces, you have to use
Xerces-specific way to create parsers, and parse documents.
You first need to create a parser configuration that implements the
XMLPullParserConfiguration interface. Then you need to
create a parser from this configuration. To parse documents, method
parse(boolean) should be called.
In the above example, a SAXParser is used to to pull-parse an
XMLInputSource. DOMParser can be used in a similar way. A flag
continueParse is used to indicate whether to continue
parsing the document. The application can stop the parsing by
setting this flag to false.