Java and XML

362 Pages·2000·2.177 MB·English

by  McLaughlin B.

Team[oR] 2001
[x] java
Java and XML
Java and XML
Copyright © 2000 O'Reilly & Associates, Inc. All rights reserved.
Printed in the United States of America.
Published by O'Reilly & Associates, Inc., 101 Morris Street, Sebastopol, CA 95472.
The Java™ Series is a trademark of O'Reilly & Associates, Inc. Java™ and all Java-based
trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc., in the
United States and other countries. O'Reilly & Associates, Inc. is independent of Sun Microsystems.
The O'Reilly logo is a registered trademark of O'Reilly & Associates, Inc. Many of the designations
used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where
those designations appear in this book, and O'Reilly & Associates, Inc. was aware of a trademark
claim, the designations have been printed in caps or initial caps. The association between the image
of a Tupperware SHAPE-O® and Java™ and XML is a trademark of O'Reilly & Associates, Inc.
SHAPE-O® is a registered trademark of Dart Industries Inc. (Tupperware Worldwide) and is used
with permission.
While every precaution has been taken in the preparation of this book, the publisher assumes no
responsibility for errors or omissions, or for damages resulting from the use of the information
contained herein.

© 2001, O'Reilly & Associates, Inc.

page 2
Preface............................................................................... 5
Organization ................................................................... 6
Who Should Read This Book?........................................ 8
Software and Versions.................................................... 8
Conventions Used in This Book...................................... 9
Comments and Questions .............................................. 9
Acknowledgments........................................................... 10
Chapter 1. Introduction .................................................... 11
What Is It?....................................................................... 12
How Do I Use It?............................................................. 19
Why Should I Use It?...................................................... 21
What’s Next? .................................................................. 33
Chapter 2. Creating XML .................................................. 33
An XML Document.......................................................... 34
An XML Document.......................................................... 35
The Content.................................................................... 36
What’s Next? .................................................................. 43
Chapter 3. Parsing XML.................................................... 43
Getting Prepared ............................................................ 43
SAX Readers .................................................................. 45
Content Handlers............................................................ 49
Error Handlers ................................................................ 64
Error Handlers ................................................................ 70
"Gotcha!"......................................................................... 76
What’s Next? .................................................................. 79
Chapter 4. Constraining XML........................................... 79
Why Constrain XML Data? ............................................. 79
Document Type Definitions............................................. 82
XML Schema .................................................................. 94
What’s Next? .................................................................. 106
Chapter 5. Validating XML................................................ 106
Configuring the Parser.................................................... 106
Output of XML Validation................................................ 110
The DTDHandler Interface.............................................. 114
"Gotcha!"......................................................................... 116
What’s Next? .................................................................. 118
Chapter 6. Transforming XML.......................................... 118
The Purpose ................................................................... 119
The Components ............................................................ 120
The Syntax...................................................................... 123
What’s Next? .................................................................. 140
Chapter 7. Traversing XML .............................................. 140
Getting the Output .......................................................... 141
Getting the Input ............................................................. 143
The Document Object Model (DOM) .............................. 144
"Gotcha!"......................................................................... 158
What’s Next? .................................................................. 160
Chapter 8. JDOM............................................................... 160
Parsers and the Java API for XML Parsing .................... 161
JDOM: Another API? ...................................................... 164
What’s in a Name?............................................................ 164
Getting a Document........................................................ 166
Using a Document .......................................................... 169
Outputting a Document................................................... 177
What’s Next? .................................................................. 184
Chapter 9. Web Publishing Frameworks ........................ 184
Selecting a Framework ................................................... 185
Installation....................................................................... 187
Using a Publishing Framework ....................................... 193
XSP................................................................................. 204
Cocoon 2.0 and Beyond ................................................. 217
What’s Next? .................................................................. 219
Chapter 10. XML-RPC....................................................... 219
RPC Versus RMI ............................................................ 220
Saying Hello.................................................................... 222
Putting the Load on the Server....................................... 232
The Real World............................................................... 246
What’s Next? .................................................................. 249
Chapter 11. XML for Configurations ............................... 249
EJB Deployment Descriptors.......................................... 250
Creating an XML Configuration File................................ 252
Reading an XML Configuration File................................ 257
The Real World............................................................... 265
What’s Next? .................................................................. 273
Chapter 12. Creating XML with Java............................... 273
Loading the Data ............................................................ 273
Modifying the Data.......................................................... 282
XML from Scratch........................................................... 287
The Real World............................................................... 288
What’s Next? .................................................................. 295
Chapter 13. Business-to-Business.................................. 295
The Foobar Public Library .............................................. 296
mytechbooks.com........................................................... 304
Push Versus Pull ............................................................ 311
The Real World............................................................... 322
What’s Next? .................................................................. 322
Chapter 14. XML Schema................................................. 323
To DTD or Not To DTD................................................... 323
Java Parallels ................................................................. 325
What’s Next? .................................................................. 332
Appendix A. API Reference.............................................. 332
A.1 SAX 2.0 .................................................................... 332
A.2 DOM Level 2 ............................................................ 343
A.3 JAXP 1.0 .................................................................. 349
A.4 JDOM 1.0 ................................................................. 351
Appendix B. SAX 2.0 Features and Properties .............. 358
B.1 Core Features .......................................................... 358
B.2 Core Properties ........................................................ 360
Java and XML
Preface
XML, XML, XML, XML. You can see it on hats and t-shirts, read about it on the cover of every
technical magazine on the planet, and hear it on the radio or the occasional Gregorian chant album. .
. . Well, maybe it hasn't gone quite that far yet, but don't be surprised if it does. XML, the
Extensible Markup Language, has seemed to take over every aspect of technical life, particularly in
the Java™ community. An application is no longer considered an enterprise-level product if XML
isn't being used somewhere. Legacy systems are being accessed at a rate never before seen, and
companies are saving millions and even billions of dollars on system integration, all because of
three little letters. Java developers wake up with fever sweats wondering how they are going to
absorb yet another technology, and the task seems even more daunting when embarked upon; the
road to XML mastery is lined with acronyms: XML, XSL, XPath, RDF, XML Schema, DTD, PI,
XSLT, XSP, JAXP™, SAX, DOM, and more. And there isn't a development manager in the world
who doesn't want his or her team learning about XML today!
When XML became a formal specification at the World Wide Web Consortium in early 1998,
relatively few were running in the streets claiming that the biggest thing since Java itself (arguably
bigger!) had just made its way onto the technology stage. Barely two years later, XML and a
barrage of related technologies for manipulating and constraining XML have become the mainstay
of data representation for Java systems. XML promises to bring to a data format what Java brought
to a programming language: complete portability. In fact, it is only with XML that the promise of
Java is realized; Java's portability has been seriously compromised as proprietary data formats have
been used for years, enabling an application to run on multiple platforms, but not across businesses
in a standardized way. XML promises to fill this gap in complete interoperability for Java programs
by removing these proprietary data formats and allowing systems to communicate using a standard
means of data representation.
This is a book about XML, but it is geared specifically towards Java developers. While both XML
and Java are powerful tools in their own right, it is their marriage that this book is concerned with,
and that gives XML its true power. We will cover the various XML vocabularies, look at creating,
constraining, and transforming XML, and examine all of the APIs for handling XML from Java
code. Additionally, we cover the hot topics that have made XML such a popular solution for
dynamic content, messaging, e-business, and data stores. Through it all, we take a very narrow
view: that of the developer who has to put these tools to work. A candid look at the tools XML
provides is given, and if something is not useful (even if it is popular!), we will address it and move
on. If a particular facet of XML is a hidden gem, we will extract the value of the item and put it to
use. Java and XML is meant to serve as a handbook to help you, and is neither a reference nor a
book geared towards marketing XML.
Finally, the back half of this book is filled with working, practical code. Although available for
download, the purpose of this code is to walk you through creating several XML applications, and
you are encouraged to follow along with the examples rather than skimming the code. We introduce
a new API for manipulating XML from Java as well, and complete coverage and examples are
included. This book is for you, the Java developer, and it is about the real world; it is not a
theoretical or fanciful flight through what is "cool" in the industry. We abandon buzzwords when
possible, and define them clearly when not. All of the code and concepts within this book have been
entered by hand into an editor, prodded and tested, and are intended to aid you on the path to
mastering Java and XML.
page 5
Java and XML
Organization
This book is structured in a very particular way: the first half of the book (Chapter 1 through
Chapter 7) focuses on getting you grounded in XML and the core Java APIs for handling XML.
Although these chapters are not glamorous, they should be read in order, and at least skimmed even
if you are familiar with XML. We cover the basics, from creating XML to transforming it. Chapter
8 serves as a halfway point in the book, covering an exciting new API for handling XML within
Java, JDOM. This chapter is a must-read, as the API is being publicly released as this book goes to
production, and this is the reference for JDOM 1.0 (as I wrote the API with Jason Hunter
specifically for solving problems in using Java and XML!). The remainder of the book, Chapter 9
through Chapter 14, focuses on specific XML topics that continually are brought up at conferences
and tutorials I am involved with, and seeks to get you neck-deep in using XML in your applications,
now! Finally, there are two appendixes to wrap up the book. Here's a summary of the contents:
Chapter 1
We look at what all the hype is about, examine the XML alphabet soup, and spend time
discussing why XML is so important to the present and future of enterprise development.
Chapter 2
We start looking at XML by building an XML document from the ground up. Examination
of the major XML constructs, such as elements, attributes, entities, and processing
instructions is included.
Chapter 3
The Simple API for XML (SAX), our first Java API for handling XML, is introduced and
covered in this chapter. The parsing lifecycle is detailed, and the events that can be reported
by SAX and used by developers are demonstrated.
Chapter 4
In this chapter, we look at the two ways to impose constraints on XML documents:
Document Type Definitions (DTDs) and XML Schema. We will dissect the differences and
analyze when one should be used over the other.
Chapter 5
Complementing Chapter 4, this chapter looks at how to use the SAX skills previously
learned to enforce validation constraints, as well as how to react when constraints are not
met by XML documents.
Chapter 6
In this chapter, the Extensible Stylesheet Language (XSL) and the other critical components
for transforming XML from one format into another are introduced. We cover the various
methods available for converting XML into other textual formats, and look at using
formatting objects to convert XML into binary formats.
Chapter 7
page 6
Java and XML
Continuing to look at transforming XML documents, we discuss XSL transformation
processors and how they can be used to convert XML into other formats. We also examine
the Document Object Model (DOM) and how it can be used for handling XML data.
Chapter 8
We begin by looking at the Java API for XML Parsing ( JAXP), and discuss the importance
of vendor-independence when using XML. I then introduce the JDOM API, discuss the
motivation behind its development, and detail its use, comparing it to SAX and DOM.
Chapter 9
This chapter looks at what a web publishing framework is, why it matters to you, and how to
choose a good one. We then cover the Apache Cocoon framework, taking an in-depth look
at its feature set and how it can be used to serve highly dynamic content over the Web.
Chapter 10
In this chapter, we cover Remote Procedure Calls (RPC), their relevance in distributed
computing as compared to RMI, and how XML makes RPC a viable solution for some
problems. We then look at using XML-RPC Java libraries and building XML-RPC clients
and servers.
Chapter 11
In this chapter, we look at using configuration data in an XML format and why that format
is so important to cross-platform applications, particularly as it relates to distributed
systems.
Chapter 12
Although this topic is covered in part in other chapters, here we look at the process of
generating and mutating XML from Java and how to perform these modifications from
server-side components such as Java servlets, and outline concerns when mutating XML.
Chapter 13
This chapter details a "case study" of creating inter- and intra-business communication
channels using XML as a portable data format. Using multiple languages, we build several
application components for different companies that all interact with each other using XML.
Chapter 14
We revisit XML Schema here, looking at why the XML Schema specification has garnered
so much attention and how reality measures up to the promise of the XML Schema concept,
and examining why Java and XML Schema are such complementary technologies.
Appendix A
This appendix details all the classes, interfaces, and methods available for use in the SAX,
DOM, JAXP, and JDOM APIs.
page 7
Java and XML
Appendix B
This appendix details the features and properties available to SAX 2.0 parser
implementations.
Who Should Read This Book?
This entire book is based on the premise that XML is quickly becoming an essential part of Java
programming. The chapters are written to instruct you in the use of XML and Java, and other than
in the introduction, they do not focus on if you should use XML. I believe that if you are a Java
developer, you should use XML, without question. For this reason, if you are a Java programmer,
want to be a Java programmer, manage Java programmers, or are responsible for or associated with
a Java project, this book is for you. If you want to advance, want to become a better developer, want
to write cleaner code, want to have projects succeed on time and under budget, need to access
legacy data, need to distribute system components, or just want to know what the XML hype is
about, this book is for you.
I tried to make as few assumptions about you as possible; I don't believe in setting the entry point
for XML so high that it is impossible to get started. However, I also believe that if you spent your
money on this book, you want more than the basics. For this reason, I assumed only that you know
the Java language and understand some server-side programming concepts (such as Java servlets
and Enterprise JavaBeans™). If you have never coded Java before or are just getting started with
the language, you may want to read through Learning Java, by Pat Niemeyer and Jonathan
Knudsen (O'Reilly & Associates), before starting this book. I do not assume that you know anything
about XML, and so I start with the basics. However, I do assume that you are willing to work hard
and learn quickly; for this reason, we move rapidly through the basics so that the bulk of the book
can deal with advanced concepts. Material is not repeated unless appropriate, so you may need to
re-read previous sections or be prepared to flip back and forth, as previously covered concepts are
used in later chapters. If you want to learn XML, know some Java, and are prepared to enter some
example code into your favorite editor, you should be able to get through this book without any real
problem.
Software and Versions
This book covers XML 1.0 and the various XML vocabularies in their latest form as of April 2000.
Because various XML specifications that are covered are not final, minor inconsistencies may be
present between printed publications of this book and the current version of the specification in
question.
All of the Java code used is based on the Java 1.1 platform, with the exception of the JDOM 1.0
coverage. This variance with regard to JDOM is noted in the text in Chapter 8, and addressed there.
The Apache Xerces parser, Apache Xalan processor, and Apache FOP libraries were the latest
stable versions available as of April 2000, and the Apache Cocoon web publishing framework used
was Version 1.7.3. The XML-RPC Java libraries used were Version 1.0 beta 3. All software used is
freely available and can be obtained online from http://java.sun.com, http://xml.apache.org, and
http://www.xml-rpc.com.
The source code for the examples in this book, including the com.oreilly.xml utility classes, is
contained completely within the book itself. Both source and binary forms of all examples
(including extensive Javadoc not necessarily included in the text) are available online from
http://www.oreilly.com/catalog/javaxml and http://www.newInstance.com. All of the examples that
page 8
Java and XML
could run as servlets, or be converted to run as servlets, can be viewed and used online at
http://www.newInstance.com.
The complete JDOM 1.0 distribution, including the specification, reference implementation, source
code, API documentation, and binary release, is available for download online at
http://www.jdom.org. Additionally, a CVS tree is being set up to host the JDOM code and allow
community contribution and comment. See http://www.jdom.org for details on accessing JDOM
from CVS.
Conventions Used in This Book
I use the following font conventions in this book.
Italic is used for:
• Unix pathnames, filenames, and program names
• Internet addresses, such as domain names and URLs
• New terms where they are defined
Constant Width is used for:
• Command lines and options that should be typed verbatim
• Names and keywords in Java programs, including method names, variable names, and class
names
• XML element names and tags, attribute names, and other XML constructs that appear as
they would within an XML document
Constant Width Bold
is used for:
• Additions to code examples
• Parts of code examples that are discussed specifically in the text
Comments and Questions
Please address comments and questions concerning this book to the publisher:
O'Reilly & Associates, Inc.
101 Morris Street
Sebastopol, CA 95472
[phone] (in the U.S. or Canada)
[phone] (international or local)
[phone] (fax)
You can also send us messages electronically. To be put on our mailing list or to request a catalog,
send email to:
[email protected]
To ask technical questions or comment on the book, send email to:
[email protected]
page 9