Although SAX (the Simple API for XML) parsers are handy tools for parsing XML content, developing and maintaining a SAX parser can prove difficult. In this article, Leon Messerschmidt shows you how to use the information contained in XML Schemas to generate source code for a skeleton SAX parser. You also learn techniques to accomplish common XML parsing tasks.

In this detailed tip, Benoit Marchal explains how SAXTransformerFactory -- a class that feeds SAX events directly in an XSLT processor -- buys you greater flexibility when you save XML files. Several reusable Java code samples demonstrate the techniques, which require TrAX.

Learn about the SAX packages and the key JAXP libraries and classes that are required for creating and using a SAX parser. Also learn how to set up JAXP for different versions of Java, and create an application that uses a SAX parser.

We need XML parser because we do not want to do everything in our application from scratch, and we need some "helper" programs or libraries to do something very low-level but very necessary to us.

Each processing instruction the parser reads is passed to the processingInstruction() method in one invocation. This includes processing instructions that occur before and after the root element. The target is given as the first argument and the data as the second argument.

As a Software Consultant for companies such as IBM and Telxon, Shawn Van Dusen recently finished two large-scale projects, both of which included Sax ActiveX Scripting as an integral part of the program.

With the exploding use of XML as a data vehicle, system architects are seeking more flexible ways to convey or read data, and take actions based upon the content of XML documents. XML is being integrated into the infrastructure of B2B transactions, Web-based e-commerce, and business process modeling. Making use of information embedded in XML is fertile ground for new and innovative applications.

The following example demonstrates some basic SAX functionality, and mirrors the example described in the SAX project quickstart guide. The main program creates a SAXParser and arranges for the SAX events to be send to the MySAXApp handler.

When a DOMDocument object is built from SAX events, the document is locked and cannot be modified until the endDocument method is called. The document can, however, be read anytime after startDocument method is called. The following provides an overview of how the document is locked as it is built.

This series looks at several distinct conceptual models that exist for manipulation of XML documents. The Simple API for XML (SAX) is a widely used, and frequently implemented, approach to the procedural and sequential processing of an XML document. We look at what it means to treat an XML document as a series of events, and handled in an event-driven programming context. Source code examples of using SAX are provided, along with pointers to further resources.

This article will introduce the subject of parsing XML files, using as examples the Expat parser and the Xerces parser. In the process we will examine the two event interfaces for XML parsers, SAX1 and SAX2. I will assume that you've read the two previous articles in the series (Introducing XML by David Nash and History of Unicode by myself) and I assume that you have a good understanding of C++.

Ever run into a problem where data is delivered in XML but the client has to be lightweight and as such cannot afford the baggage of the DOM and SAX parsers? An example of this could be an applet running on a web page. Most applets which are widely accepted use Java version 1.1.x. What do you do when you need to parse an XML document using such an applet? My answer, I would write a lightweight XML parser myself. Lets look at the kinds of parsers and decide on a design for our lightweight parser.

The SAX API for XML parsers was originally developed for Java. Please be aware that there is no standard SAX API for C++, and that use of the Xerces-C++ SAX API does not guarantee client code compatibility with other C++ XML parsers.

It's amazing what you can find in the back of your cupboard. Just last weekend, I found a half-bottle of an inexpensive 1991 Merlot that had gotten mixed in with the salad oil and vinegar bottles. How appropriate: Now I have some new red wine vinegar I didn't know I had! Well, we sometimes find old code lying around in the same way, and although it doesn't really spoil, it can get out of date.

XML is hot. Because XML is a form of self-describing data, it can be used to encode rich data models. It's easy to see XML's utility as a data exchange medium between very dissimilar systems. Data can be easily exposed or published as XML from all kinds of systems: legacy COBOL programs, databases, C++ programs, and so on.

By following some simple rules when mapping objects to XML, you can easily read object structures, even complex ones, from XML. See how you can use SAX to eliminate that complexity.

Working with XML in a multitiered Java application has several advantages. You can embed data tags, which serve as placeholders for data that is requested by Web users and supplied by a database, into a Web page. Someone with HTML skills rather than programming skills can do the XML page layout, and the input and output formats—even individual data items—can be changed by modifying a few tags.

Performance is a key concern in all types of applications, but in J2EE-based enterprise applications it can be especially pressing. With XML integration apps, one factor that always figures prominently in performance is the size of the document being manipulated. Simply put, a large in-memory DOM can impose huge demands not only on system memory but CPU time.

No SAX please we’re British [PDF]

We are switching to java to look at SAX event processing. The SAX parser treats the XML file and the tags within it as a series of processing events. In a simple file such as the Hamlet example the SAX parser could be told to look through the file until it encountered a PERSONA event. Once the event is encountered we can instruct the parser to do something with the element, the data and the attributes.