 |
|
|
|
|
|
Index of XML standards
The world of XML is vast and growing, with a huge variety of standards and technologies that interact in complex ways. It can be difficult for beginners to navigate the most important aspects of XML, and for users to keep track of new entries and changes in the space. XML is a basic syntax upon which you develop local and global vocabularies. This index provides a detailed cross-reference of many XML standards, including links to additional coverage for each.
|
|
|
|
19 Nov 2009 |
|
| |
Working with XML on Android
Android is a modern, open source operating system and SDK for mobile devices. With it you can create powerful mobile applications. This becomes even more attractive when your applications can access Web services, which means you need to speak the language of the Web: XML. In this article, you will see different options for working with XML on Android and how to use them to build your own Android applications.
|
|
Articles |
|
23 Jun 2009 |
|
| |
High-performance XML parsing in Python with lxml
lxml is a fast yet flexible library for XML processing in Python. It comes
bundled with support for XML Path Language (XPath) and Extensible Stylesheet
Language Transformation (XSLT), and it implements the familiar ElementTree API. In
this article, you focus both on the ease of use provided by lxml and on its
high-performance profile when processing very large XML data.
|
|
Articles |
|
28 Oct 2008 |
|
| |
Deal with errors in XML parsing
XML parsing is a part of nearly every enterprise application. Error handling, though, is absent from most of those same applications. Learn how to use the Simple API for XML (SAX) to deal with errors in your XML parsing -- even if your applications are using the DOM, JAXP, or another API to deal with XML.
|
|
Articles |
|
22 Jul 2008 |
|
| |
Learn 10 good XML usage habits
Make your XML work easier with the ten tips in this article -- ultimately you'll be less prone to errors and more productive.
|
|
Articles |
|
13 May 2008 |
|
| |
Embedding Hamlets
The open source Hamlets framework can help aid your Web development and properly separate content from presentation. The OSGi framework provides an excellent tool for development on embedded devices. Together, the two frameworks work as a team to provide browser-based interactivity to the humblest gadgets -- such as the lowly coffee maker. Read on to find out how it works.
|
|
Articles |
|
19 Jun 2007 |
|
| |
XML for PHP developers, Part 3: Advanced techniques to read, manipulate, and write XML
This final article in a three-part series discusses more techniques for reading, manipulating, and writing XML in PHP5. In it, you will focus on the now familiar APIs DOM and SimpleXML in more sophisticated surroundings, and, for the first time in this three-part series, on the XSL extension.
|
|
Articles |
|
13 Mar 2007 |
|
| |
XML for PHP developers, Part 2: Advanced XML parsing techniques
This second article in a three-part series will discuss XML parsing techniques of PHP5, focusing on parsing large or complex XML documents. It will offer some background about parsing extensions and, specifically, what parsing methods are best suited to what types of XML documents and why.
|
|
Articles |
|
06 Mar 2007 |
|
| |
XML for Perl developers, Part 3: Advanced manipulating and writing techniques
This article, the third in a three-part series, uses the parsing techniques introduced in Part 2 to build tree structures that can be transformed, navigated, and written. You will then see how to feed transformed parse trees into SAX pipelines, further transform them, and write them as text or to SQL databases. Finally you will learn how to reverse this, using database content to drive SAX pipelines.
|
|
Articles |
|
13 Feb 2007 |
|
| |
XML for Perl developers, Part 2: Advanced XML parsing techniques using Perl
This series is a guide to those who need a quick XML-and-Perl solution. Part 1 looked at XML::Simple, a tool to integrate XML into a Perl application. This second article in the series introduces the Perl programmer to the two major schools of XML parsing: tree parsing and event-driven parsing.
|
|
Articles |
|
06 Feb 2007 |
|
| |
XML in 2006
Join Elliotte Rusty Harold for a look back at the most significant XML news from 2006.
|
|
Articles |
|
16 Jan 2007 |
|
| |
Working XML: Understand the various approaches to XML parsing
Even developers who are very knowledgeable on advanced XML matters can lack a firm understanding of the fundamentals. To ensure a solid foundation, this article covers the most basic XML service: parsing. It introduces the various approaches to parsing and highlights their pros and cons.
|
|
Articles |
|
03 Jan 2007 |
|
| |
StAX'ing up XML, Part 3: Using custom events and writing XML
In addition to a low-level cursor-based API, StAX provides a powerful iterator-based method to process XML that uses event objects to communicate information about the parsed stream. Part 2 explored this API in detail and provided some examples of its use. In this article, you'll examine customization techniques that use application-defined events. In particular, you'll see how to create custom event classes and use them to process XML with the event iterator-based API. Last but not least, you'll review the serialization API provided by StAX for writing XML as a stream of tokens as well as event objects.
|
|
Articles |
|
12 Dec 2006 |
|
| |
StAX'ing up XML, Part 2: Pull parsing and events
The event iterator-based API provided by Streaming API for XML (StAX) offers a unique blend of advantages over other XML processing methods in terms of both performance and usability. Part 1 introduced StAX and described in detail its cursor-based API. In this article, delve deeper into the event iterator-based API and explore its benefits to Java(TM) developers.
|
|
Articles |
|
05 Dec 2006 |
|
| |
StAX'ing up XML, Part 1: An introduction to Streaming API for XML (StAX)
The Streaming API for XML (StAX) is the latest standard for processing XML in the Java (TM) language. As a stream-oriented approach, it often proves a better alternative to other methods, such as DOM and SAX, both in terms of performance and usability. This article, the first in a three part series, provides an overview of StAX and describes its cursor-based API for processing XML.
|
|
Articles |
|
29 Nov 2006 |
|
| |
Thinking XML: Good advice for creating XML
The use of XML has become widespread, but much of it is not well formed. When it is well formed, it's often of poor design, which makes processing and maintenance very difficult. And much of the infrastructure for serving XML can compound these problems. In response, there has been some public discussion of XML best practices, such as Henri Sivonen's document, "HOWTO Avoid Being Called a Bozo When Producing XML." Uche Ogbuji frequently discusses XML best practices on IBM developerWorks, and in this column, he gives you his opinion about the main points discussed in such articles.
|
|
Articles |
|
31 Jan 2006 |
|
| |
JAXP validation
The latest version of the Java programming language -- Java 5.0 -- includes an improved, expanded version of the Java API for XML Processing (JAXP). A major addition to JAXP is the new validation API, which allows greater interactivity, support for XML Schema and RELAX NG, and the ability to make on-the-fly changes while validating. All of these improvements finally give Java developers an industrial-strength solution for XML validation. This article details the new API, from its basics to the more advanced features.
|
|
Articles |
|
11 Oct 2005 |
|
| |
Cache and serialize XML Schemas with Xerces-C++
Use Xerces-C++ to validate documents more efficiently. XML plays an increasingly important role in C and C++ applications. To ensure successful interpretation of a document's contents, many of these applications require W3C XML Schemas to validate the documents they process. This article includes examples that demonstrate how to preprocess and cache schemas in advance of or during the validation process, and thus avoid the expensive process of repeatedly processing given XML Schema documents. You'll also learn how to save the processed schemas to disk, so you'll only need to reprocess the original XML Schema documents if they change.
|
|
Articles |
|
29 Jul 2005 |
|
| |
Working XML: Safe coding practices, Part 2
Save yourself hours of debugging and maintenance. Benoit continues to review his notes on horror stories in the use of XML. In the process, he discusses appropriate design techniques for working with XML documents, and how best to integrate XML processing into an application.
|
|
Articles |
|
07 Jul 2005 |
|
| |
IBM XML certification success, Part 2: Prepare for IBM XML certification with more technologies
This is the second part of a three-part tutorial series designed specifically for those interested in taking the IBM Certified Solution Developer Exam for XML and Related Technologies. Here, authors Pradeep Chopra and Hari Vignesh Padmanaban follow up on the lessons in Part 1 by introducing the reader to several more critical XML technologies like XPath, XSLT, XLink, XPointer, CSS, XSL-FO, SAX, and DOM. Furthermore, the authors reinforce the reader's understanding through examples and exercises.
|
|
Tutorials |
|
31 May 2005 |
|
| |
All about JAXP, Part 2
Part 1 of this two-part series introduced the Java API for XML Processing (JAXP) and its parsing and validation features. JAXP also offers Java programmers the ability to transform XML documents using Extensible Stylesheet Language (XSL). Through both direct programmatic access and XSL templating, JAXP makes conversion from one XML format to another an easy task. This article shows you how to use JAXP to transform XML documents and how to cache XSL stylesheets for the best performance possible.
|
|
Articles |
|
31 May 2005 |
|
| |
Tip: Configure SAX parsers for secure processing
Because XML systems often accept and process data from many different sources, it's important to consider the effect bad data may cause if it's intentionally or unintentionally injected into the system. Although validation and well-formedness checking provide a substantial amount of protection compared to traditional binary formats, you also need to consider some issues that are unique to XML. Fortunately, proper configuration of the parser and some reasonable intelligence about what to store can ameliorate most security concerns.
|
|
Articles |
|
27 May 2005 |
|
| |
Web Services APIs for J2ME, Part 2: Java API for XML processing
Become familiar with the Web Services APIs for J2ME. This article, focusing on the JAXP, spotlights the general remote service invocation and XML parsing that saves you from embedding these functions into every application.
|
|
Articles |
|
02 Nov 2004 |
|
| |
Improve performance in your XML applications, Part 3
In this final installment of a three-part series describing best practices for writing XML applications, authors Elena Litani and Michael Glavassevich explain how to use Xerces2-specific features and properties to improve performance. They also give a short overview of the Xerces Native Interface (XNI), compare it with SAX, and discuss the Xerces2 grammar caching API, which can significantly improve performance of applications that require validation against DTDs or XML schemas.
|
|
Articles |
|
02 Sep 2004 |
|
| |
Improve performance in your XML applications, Part 2
In this installment of a three-part series describing best practices for writing XML applications, authors Elena Litani and Michael Glavassevich explain how to improve your SAX and DOM applications' performance by using the Xerces2 implementation. They also include code samples to show you how to improve your application's performance by reusing parser instances.
|
|
Articles |
|
30 Jul 2004 |
|
| |
Improve performance in your XML applications, Part 1
Write your application to get the best possible performance, plus learn which SAX or DOM operations and features affect application performance. In this first of a three-part article, authors Elena Litani and Michael Glavassevich describe best practices for writing XML apps and documents, and for developing applications with the standard SAX and DOM APIs.
|
|
Articles |
|
26 Jul 2004 |
|
| |
XML programming in Java technology, Part 2
In an earlier tutorial, Doug Tidwell looked at the basics of XML parsing in the Java language. He covered the major APIs (DOM, SAX, and JDOM), and went through a number of examples that demonstrated the basic tasks common to most XML applications. In this tutorial, he looks at more difficult things that weren't covered in Part 1, such as working with namespaces, validating XML documents, building XML structures without a typical XML document, converting between one API and another, and manipulating tree structures. He also shows you some of the more esoteric features of DOM, SAX, JDOM, and JAXP.
|
|
Tutorials |
|
09 Jul 2004 |
|
| |
A survey of XML standards: Part 4
The world of XML is vast and growing, with a huge variety of standards and technologies that interact in complex ways. It can be difficult for beginners to navigate the most important aspects of XML, and for users to keep track of new entries and changes in the space. XML is a basic syntax upon which you develop local and global vocabularies. Uche Ogbuji has presented the most important standards relating to XML in three in-depth articles. In this fourth article, he provides a detailed cross-reference of all the covered standards.
|
|
Articles |
|
02 Mar 2004 |
|
| |
A survey of XML standards: Part 2
The world of XML is vast and growing, with a huge variety of standards and technologies that interact in complex ways. It can be difficult for beginners to navigate the most important aspects of XML, and for users to keep track of new entries and changes in the space. Uche Ogbuji continues this series on XML standards by focusing on XML processing technologies.
|
|
Articles |
|
03 Feb 2004 |
|
| |
Tip: Use language-specific tools for XML processing
DOM and SAX are the two best known systems for XML processing, but they are really compromises across programming languages. As such, they do not take advantage of any language's particular strengths. Often it is better to duck conventional wisdom and use special APIs that take advantage of particular strengths.
|
|
Articles |
|
30 Jan 2004 |
|
| |
Tip: Merge XML documents with StAX
Deriving new XML documents from input documents is where the Streaming API for XML (StAX) shines. This tip explores how client applications can utilize the event-based API to efficiently merge two incoming XML documents into one.
|
|
Articles |
|
07 Jan 2004 |
|
| |
XML Matters: The XOM Java XML API
In this installment, David looks at Elliotte Rusty Harold's XOM. Broadly speaking, this is yet another object-oriented XML API, somewhat in the style of DOM, however a number of features set XOM apart, and Harold argues that they are important design elements. Chief among these is a rigorous insistence on maintaining invariants in in-memory objects so that an XOM instance can always be serialized to correct XML. In addition, XOM aims at greater simplicity and regularity than other Java XML APIs.
|
|
Articles |
|
17 Dec 2003 |
|
| |
Tip: Write XML documents with StAX
The Streaming API for XML (StAX) allows not only parsing of XML documents but also writing XML documents to an output stream. This tip shows how client applications can use the low-level, cursor-based StAX API to create XML documents efficiently.
|
|
Articles |
|
17 Dec 2003 |
|
| |
Tip: Screen XML documents efficiently with StAX
With the Streaming API for XML (StAX), you can screen XML documents efficiently without the drawbacks of traditional push parsers. This tip shows you how to retrieve specific information from XML documents and how to stop the parsing process once this information is collected.
|
|
Articles |
|
11 Dec 2003 |
|
| |
Tip: Parsing XML documents partially with StAX
The Streaming API for XML (StAX) $@!LessThan!@$!--, introduced in the previous tip (http://www-106.ibm.com/developerworks/xml/library/x-tipstx),--$@!GreaterThan!@$ provides not only an XML parser that is fast, easy to use, and has a low memory footprint, but one that also provides a filter interface that allows programmers to hide unnecessary document detail from the application's business logic. This tip shows how to apply event filters and stream filters to StAX parsers. As with the first tip, I will demonstrate and explain this using both the iterator-style API and the cursor-based API.
|
|
Articles |
|
02 Dec 2003 |
|
| |
Tip: Implement XMLReader
In this tip, Benoit Marchal explores APIs for XML pipelines. He concludes that the familiar XMLReader interface is appropriate for many XML components.
|
|
Articles |
|
13 Nov 2003 |
|
| |
XML Matters: Investigating SXML and SSAX
In previous installments, David has looked at XML libraries for various programming languages, and their various strengths and weaknesses. This time, he looks at the Lisp/Scheme family of languages that continues to endure in popularity, especially in teaching and among purists. Included in the discussion are the SSAX library for Scheme (an efficient pure-functional parser), the SXML tree library (similar to DOM), and the related tools SXSLT and SXPath, which have been created to work with them. David covers the advantages of parsing in a strongly functional language, and compares SSAX with libraries for other languages.
|
|
Articles |
|
23 Oct 2003 |
|
| |
Tip: Attributes in ContentHandler
The one aspect of data processing with ContentHandler that the author didn't cover in his last tip was attribute processing. While attributes are most commonly used for information transfer between an XML document and an XML processor, they also often contain valuable business data. In this tip, Brett shows you how SAX handles elements and reports those elements, as well as how you can use code to extract element data.
|
|
Articles |
|
21 Aug 2003 |
|
| |
Tip: Elements and text in ContentHandler
With a solid understanding of the SAX ContentHandler interface (which you can obtain by reading my previous tips), you are ready to perform useful tasks with SAX. The most common task, of course, is obtaining the textual content of a specific element, and then doing something with that data. This tip details that process, from locating a certain element to reading its data.
|
|
Articles |
|
14 Aug 2003 |
|
| |
Tip: Get the most from ContentHandlers
This tip breaks down each method in the org.xml.sax.ContentHandler interface, explaining the purpose and usage of each callback, and its relationship to an XML parsing event. You will understand the arguments to each method, and the information passed from a SAX parser to its registered ContentHandler
|
|
Articles |
|
31 Jul 2003 |
|
| |
Understanding SAX
This tutorial examines the use of the Simple API for XML version 2.0.x, or SAX 2.0.x. It is aimed at developers who have an understanding of XML and wish to learn this lightweight, event-based API for working with XML data. It assumes that you are familiar with concepts such as well-formedness and the tag-like nature of an XML document. In this tutorial, you will learn how to use SAX to retreive, manipulate, and output XML data.
|
|
Tutorials |
|
29 Jul 2003 |
|
| |
Tip: Set up a SAX ContentHandler
This tip details the process of creating a SAX ContentHandler, the construct that handles user-defined logic in SAX parsing. You will understand the SAX package structure, see its relation to the SAX ContentHandler class, and get a handle on callback methods and their use in SAX parsing.
|
|
Articles |
|
22 Jul 2003 |
|
| |
Tip: Set up a SAX parser
This is the first in a series of tips that will serve as a comprehensive guide to using XML from the Java programming language. I begin with coverage of the SAX API. This tip reviews getting an instance of a SAX parser and setting various features and properties on that parser.
|
|
Articles |
|
02 Jul 2003 |
|
| |
Tip: Asynchronous SAX
Over asynchronous channels -- such as a socket that produces data over a long duration -- SAX is a wonderfully lightweight programming technique for parsing incoming messages.
|
|
Articles |
|
14 May 2003 |
|
| |
Tip: Output large XML documents, Part 5
In this, the last in a five-part series of tips on outputting large XML documents, Brett McLaughlin provides several practical examples of using the SAX DataWriter class to output XML.
|
|
Articles |
|
23 Apr 2003 |
|
| |
Tip: Output large XML documents, Part 4
This tip introduces the XMLWriter class, a specialized SAX filter that handles output of stream-based XML. The tip also examines DataWriter, a subclass of XMLWriter that offers even more output capabilities. Both classes are examined in the context of handling the output of large XML documents and datasets.
|
|
Articles |
|
17 Apr 2003 |
|
| |
Tip: Output large XML documents, Part 3
This tip delves further into the use of XML filters, as introduced in the previous tip. You will see several practical examples of filters, including utilities that filter out all elements, all attributes, or particular elements or attributes in an XML document. Each is provided as a reusable filter.
|
|
Articles |
|
09 Apr 2003 |
|
| |
Tip: Output large XML documents, Part 2
This tip begins to detail ways to handle large XML documents. You will learn what an XMLFilter is, and how it builds upon the core SAX API to offer advanced data filtering. This is the first piece in the puzzle of handling large datasets, allowing you to extract only relevant data from an XML document for output.
|
|
Articles |
|
02 Apr 2003 |
|
| |
Tip: Output large XML documents, Part 1
This tip details the problems associated with outputting large XML documents, starting with an examination of the options for XML output. It then looks at DOM and XML output, along with possible solutions to the memory consumption associated with extended DOM usage. You'll get an understanding of why outputting XML is so tricky, and a solid grasp of the output alternatives that are available.
|
|
Articles |
|
26 Mar 2003 |
|
| |
Tip: SAX filters for flexible processing
SAX filters allow you to construct complex XML processing behaviors from simple, independent modules. In this tip, Uche Ogbuji introduces this important XML processing technique.
|
|
Articles |
|
01 Mar 2003 |
|
| |
SAX-like apps in PHP
Nicholas Chase demonstrates a SAX-like method in PHP that allows developers to work with both local and remote XML files.
|
|
Articles |
|
01 Mar 2003 |
|
| |
Tip: SAX and document order -- deliver maximally contiguous text
Previous tips in this series have explored how SAX can help delineate the relationships that exist between nodes in your XML documents. The tips have examined the use of document order and document order indices (DOIs) to track both parent-to-child and sibling-to-sibling relationships. This tip concludes the series with a look at character data and text nodes.
|
|
Articles |
|
01 Feb 2003 |
|
| |
Tip: SAX and document order -- track sibling relationships
Previous tips in this series have been using examples of SAX code to explore the concept of document order and the use of document order indices (DOIs) to model hierarchy in XML documents. This tip continues that exploration with a look at sibling relationships.
|
|
Articles |
|
01 Feb 2003 |
|
| |
Tip: SAX and document order
Focus on document order, SAX, and document order indices (DOIs) as Howard Katz discusses document order in an XML context. He presents simple SAX code that shows a practical application of DOIs in a search engine.
|
|
Articles |
|
01 Jan 2003 |
|
| |
Tip: SAX and document order -- track parent-child relationships
The tips in this series explore the concept of document order and the use of so-called document order indices in SAX. This tip looks at the use of DOIs in modeling parent-child relationships in XML documents. Such DOI representations of document hierarchy are useful in building applications, such as DOMs and query engines, that need to navigate through XML trees.
|
|
Articles |
|
01 Jan 2003 |
|
| |
Tip: Basics of bootstrapping with DOM, Part 2
In this tip, you'll learn about a better way to bootstrap in your DOM applications. This builds upon the previous tip, which examined the abilities that DOM natively provides for this task.
|
|
Articles |
|
01 Dec 2002 |
|
| |
Tip: Basics of bootstrapping with DOM, Part 1
This tip, the first in a series on bootstrapping with DOM, explains what bootstrapping is, explores the problems associated with it, and lays out the basics for use in DOM Levels 1 and 2.
|
|
Articles |
|
01 Nov 2002 |
|
| |
Tip: Use a SAX filter to manipulate data
This tip explains how to create and use a SAX filter to control how data is processed.
|
|
Articles |
|
01 Oct 2002 |
|
| |
Tip: Customized validation in SAX
This tip explains how to use a partial validation approach, rather than the full-blown validation that's included in parsing APIs. By validating only what is absolutely required, you can save tons of processing time.
|
|
Articles |
|
01 Aug 2002 |
|
| |
Tip: Load resources from the classpath
This tip describes how to use the EntityResolver interface to resolve entities using the local Java classpath.
|
|
Articles |
|
01 Aug 2002 |
|
| |
Tip: Using SAX InputSource effectively
This tip explains how using an InputStream to feed XML to the SAX API is significantly more efficient and safer than using a Reader as input. It also briefly touches on the impact of such a choice on internationalization.
|
|
Articles |
|
01 Aug 2002 |
|
| |
Tip: XSL transformations to and from a SAX stream
This tip shows you how to use SAX streams as both the source and destination of an XSL transformation.
|
|
Articles |
|
01 Jul 2002 |
|
| |
Tip: Stop a SAX parser when you have enough data
A SAX parser can be instructed to stop midway through a document without losing the data already collected. This is one of the most commonly mentioned advantages of a SAX parser over a DOM parser, which generally creates an in-memory structure of the entire document. In this tip, you'll parse a list of recently updated weblogs, stopping when you've displayed all those within a particular time range.
|
|
Articles |
|
01 Jun 2002 |
|
| |
Working XML: Compiling the proxy
In this column, Benoit provides the front end for the Handler Compiler, HC, and encounters unexpected problems with the DFA. A stable but less than optimal solution makes it possible to release a first version of HC for further testing.
|
|
Articles |
|
01 Mar 2002 |
|
| |
Working XML: Compiling the paths and automating tests
This month, our columnist discusses the compilation algorithm. He also invests a bit of time automating tests with JUnit.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Working XML: Compiling XPaths
This month our columnist describes how he implements the DFA construction algorithm, giving the first concrete example of using the compiler to recognize XPath.
|
|
Articles |
|
01 Jan 2002 |
|
| |
Working XML: Building a compiler for the SAX ContentHandler
This installment of the column describes the requirements for the Java project and analyzes its overall design. The new project, called HC (short for Handler Compiler), will take some drudgery out of event-based XML parsing by automatically generating the SAX ContentHandler for a list of XPaths.
|
|
Articles |
|
01 Nov 2001 |
|
| |
Working XML: Wrapping up XM version 1
In this month's column, developer and author Benoît Marchal adds final features to the first release of XM, a low-cost open-source content management solution based on XSLT (in Java). New features in this revision manage download pages and tables of contents via a directory reader that makes use of SAX and XMLFilter.
|
|
Articles |
|
01 Oct 2001 |
|
| |
XML Matters: Transcending the limits of DOM, SAX, and XSLT
Consider Haskell in lieu of DOM, SAX, or XSLT for processing XML data. The library HaXml creates representations of XML documents as native recursive data structures in the functional language Haskell. HaXml brings with it a set of powerful higher order functions for operating on these "datafied" XML documents. Many of the HaXml techniques are far more elegant, compact, and powerful than the ones found in familiar techniques like DOM, SAX, or XSLT. Code samples demonstrate the techniques.
|
|
Articles |
|
01 Oct 2001 |
|
| |
Working XML: Processing instructions and parameters
This month our hardworking columnist adds support for multiple style sheets to the XM content-management project. In so doing, he taps into TrAX URIResolver and writes his own parser for pseudo-attributes. As usual, the complete source code is available in the developerWorks Open source zone.
|
|
Articles |
|
01 Sep 2001 |
|
| |
SAX, the power API
Benoit Marchal gives a solid introduction to SAX, the event-based API for processing XML that has become a de facto standard.
|
|
Articles |
|
01 Aug 2001 |
|
| |
Tip: Using SAXTransformerFactory
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.
|
|
Articles |
|
01 Aug 2001 |
|
| |
Tip: Validation and the SAX ErrorHandler interface
In this tip, Brett McLaughlin explores SAX's validation capabilities and explains how to turn XML document validation on and off. He also covers the ErrorHandler interface, which enables you to receive notification of errors in your applications and act on that notification. Code samples demonstrate how to request validation and how to create and register an error handler in SAX.
|
|
Articles |
|
01 Jun 2001 |
|
| |
Tip: Using an entity resolver
Brett McLaughlin discusses how to use external entity references to include external content in an XML document, and how to use the SAX EntityResolver interface. Code samples illustrate the interface, document its use, and demonstrate how to register the entity resolver in your parser.
|
|
Articles |
|
01 Jun 2001 |
|
| |
Tip: Converting from SAX
Brett McLaughlin explains how to use SAX to communicate with applications that require DOM and JDOM inputs. It's a useful technique: With the flurry of XML APIs available, developers now have to be able to easily move from one to another, and then on to another. The sample code provides a concrete example of converting from SAX to JDOM.
|
|
Articles |
|
01 Apr 2001 |
|
| |
Tip: Converting from JDOM
Learning to work with JDOM? Well, no API is an island, and in this tip you'll learn how to convert with ease from JDOM to SAX and DOM for fluent programming of XML applications that use all three APIs. The code samples provide examples of converting from JDOM to SAX and from JDOM to DOM.
|
|
Articles |
|
01 Apr 2001 |
|
| |
Tip: Converting from DOM
In this tip, you'll learn how to convert DOM structures to SAX and JDOM to allow communication with applications that do not use DOM. The code listings demonstrate how to convert from DOM to an output stream for use by SAX, and how to convert from DOM to JDOM.
|
|
Articles |
|
01 Apr 2001 |
|
| |
Tip: Achieving vendor independence with SAX
While newer XML developers are learning to achieve vendor independence with JAXP, SAX veterans have been vendor neutral for years. This tip explains how to use SAX and a SAX helper class to achieve vendor independence in your SAX-based applications.
|
|
Articles |
|
01 Mar 2001 |
|
| |
Sun's Java API for XML Parsing, Version 1.1
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.
|
|
Articles |
|
01 Dec 2000 |
|
| |
XML Matters: On the 'Pythonic' treatment of XML documents as objects(II)
In the second installment of his new "XML Matters" column -- and as part of his ongoing quest to create a more seamless integration between XML and Python -- David Mertz presents the xml_objectify module. David describes how to use xml_objectify and the advantages of using this "Pythonic" module for working with XML documents as objects.
|
|
Articles |
|
01 Aug 2000 |
|
| |
