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.

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.

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.

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.

This preview of the second edition of XML by Example by Benoit Marchal gives a solid introduction to SAX, the event-based API for processing XML that has become a de facto standard. This preview tells when to use SAX instead of DOM, gives an overview of commonly used SAX interfaces, and provides detailed examples in a Java-based application with many code samples.

There are two simple methods in my application: one is reading xml file by using DOM method and the other is reading the same file using SAX method. I’m not gonna explain the difference between DOM & SAX, only telling this that in DOM , a parser must read the whole file u r reading before u can read anything. In other words the file is loaded into the memory of your application, where DOM makes an object model of it, then u can traverse throw the elements of this object model & receive/update needed information. SAX method, reads file step by step, so it is a resource benefit .

The Infoset is a nice idea, but it is barely useful if software cannot be written against it. Fortunately, there are two widely accepted programmatic interfaces based on the Infoset that allow documents to be manipulated and [de]serialized at the Infoset level, not at the character-stream/markup level: SAX and DOM.

You may find that your XML documents and their various grammars take on a vernacular of their own. As this vernacular finds its way into your documents, you might need to describe it in an abstract and reusable way. One solution is to use custom XML entities to represent common, reusable XML components.

Benoit Marchal discusses how to read XML documents with SAX, the powerful API, in this sample chapter from XML by Example.

There are five styles of XML APIs. The first style—the very first one to be invented historically—is a push model. The classic example of this is SAX. Another example would be the Xerces Native Interface (XNI). A push API is a streaming API. The parser takes control. The parser reads the document, and the parser tells the client application what it sees when it sees it—a start tag, and end tag, a string of text, a comment, a processing instruction, etc.

MSXML 4.0 adds two new features to the integration of Simple API for XML (SAX) and the Document Object Model (DOM). This article demonstrates how to create a DOMDocument object from SAX events in Microsoft Visual C++.

This Deitel™ article discusses how to process an XML document using the Simple API for XML (SAX). We present a small XML document and implement a Python class that can parse the document with the SAX, using features from the Python standard library. The Python program enables the user to enter the filename of an XML document and a tag name and then searches the document for any matching tags.

Want to automate tedious tasks in SAX programming? XML expert Benoît Marchal introduces the open source HC toolkit, which restores the fun.

In last month's column we began our introduction to XML::SAX::Machines, a group of modules which greatly simplifies the creation of complex SAX application with multiple filters. This month we pick up where we left off by further illustrating how XML::SAX::Machines can be used to remove most of the drudgery of building SAX-based XML processing applications. If you have not read last month's offering, please do so now.

This tutorial introduces programming SAX2 from Visual Basic. The author also explores some of the nice features of an event-based parser, such as the ability to abort parsing if user-defined conditions are met. Source code for the article is downloadable, and can be compiled into an ActiveX component and reused in Visual Basic.