Java Examples in a Nutshell: A Tutorial Companion to Java in a Nutshell

by David Flanagan

Overview

The author of the best-selling Java in a Nutshell has created an entire book of real-world Java programming examples that you can learn from. If you learn best "by example," this is the book for you.This third edition covers Java 1.4 and contains 193 complete, practical examples: over 21,900 lines of densely commented, professionally written Java code, covering 20 distinct client-side and server-side APIs. It includes new chapters on the Java Sound API and the New I/O API. The chapters on XML and servlets have been rewritten to cover the latest versions of the specifications and to demonstrate best practices for Java 1.4. New and updated examples throughout the book demonstrate many other new Java features and APIs.Java Examples in a Nutshell is a companion volume to Java in a Nutshell, Java Foundation Classes in a Nutshell, and Java Enterprise in a Nutshell. It picks up where those quick references leave off, providing a wealth of examples for both novices and experts. This book doesn't hold your hand; it simply delivers well-commented working examples with succinct explanations to help you learn and explore Java and its APIs.Java Examples in a Nutshell contains examples that demonstrate:

• Core APIs, including I/O, New I/O, threads, networking, security, serialization, and reflection
• Desktop APIs, highlighting Swing GUIs, Java 2D graphics, preferences, printing, drag-and-drop, JavaBeans, applets, and sound
• Enterprise APIs, including JDBC (database access), JAXP (XML parsing and transformation), Servlets 2.4, JSP 2.0 (JavaServer Pages), and RMI

The book begins with introductory examples demonstrating structured and object-oriented programming techniques for new Java programmers. A special index at the end of the book makes it easy to look up examples that use a particular Java class or accomplish a desired task. In between, each chapter includes exercises that challenge readers and suggest further avenues for exploration.

Product Details

ISBN-13:	9780596552329
Publisher:	O'Reilly Media, Incorporated
Publication date:	01/21/2004
Series:	In a Nutshell (O'Reilly)
Sold by:	Barnes & Noble
Format:	eBook
Pages:	722
File size:	5 MB

About the Author

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O'Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and son in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a simple website at http://www.davidflanagan.com.

Read an Excerpt

Chapter 19: XML

Contents:

Parsing with JAXP and SAX 1
Parsing with SAX 2
Parsing and Manipulating with JAXP and DOM
Traversing a DOM Tree
Traversing a Document with DOM Level 2
The JDOM API
Exercises

XML, or Extensible Markup Language, is a meta-language for marking up text documents with structural tags, similar to those found in HTML and SGML documents. XML has become popular because its structural markup allows documents to describe their own format and contents. XML enables "portable data," and it can be quite powerful when combined with the "portable code" enabled by Java.

Because of the popularity of XML, there are a number of tools for parsing and manipulating XML documents. And because XML documents are becoming more and more common, it is worth your time to learn how to use some of those tools to work with XML. The examples in this chapter introduce you to simple XML parsing and manipulation. If you are familiar with the basic structure of an XML file, you should have no problem understanding them. Note that there are many subtleties to working with XML; this chapter doesn't attempt to explain them all. To learn more about XML, try Java and XML, by Brett McLaughlin, or XML Pocket Reference, by Robert Eckstein, both from O'Reilly & Associates.

The world of XML and its affiliated technologies is moving so fast that it can be hard just keeping up with the acronyms, standards, APIs, and version numbers. I'll try to provide an overview of the state of various technologies in this chapter, but be warned that things may have changed, sometimes radically, by the time you read this material.

Parsing with JAXP and SAX 1

The first thing you want to do with an XML document is parse it. There are two commonly used approaches to XML parsing: they go by the acronyms SAX and DOM. We'll begin with SAX parsing; DOM parsing is covered later in the chapter. At the very end of the chapter, we'll also see a new, but very promising, Java-centric XML API known as JDOM.

SAX is the Simple API for XML. SAX is not a parser, but rather a Java API that describes how a parser operates. When parsing an XML document using the SAX API, you define a class that implements various "event" handling methods. As the parser encounters the various element types of the XML document, it invokes the corresponding event handler methods you've defined. Your methods take whatever actions are required to accomplish the desired task. In the SAX model, the parser converts an XML document into a sequence of Java method calls. The parser doesn't build a parse tree of any kind (although your methods can do this, if you want). SAX parsing is typically quite efficient and is therefore your best choice for most simple XML processing tasks.

The SAX API was created by David Megginson (http://www.megginson.com/SAX/). The Java implementation of the API is in the package org.xml.sax and its subpackages. SAX is a defacto standard but has not been standardized by any official body. SAX Version 1 has been in use for some time; SAX 2 was finalized in May 2000. There are numerous changes between the SAX 1 and SAX 2 APIs. Many Java-based XML parsers exist that conform to the SAX 1 or SAX 2 APIs.

With the SAX API, you can't completely abstract away the details of the XML parser implementation you are using: at a minimum, your code must supply the classname of the parser to be used. This is where JAXP comes in. JAXP is the Java API for XML Parsing. It is an "optional package" defined by Sun that consists of the javax.xml.parsers package. JAXP provides a thin layer on top of SAX (and on top of DOM, as we'll see) and standardizes an API for obtaining and using SAX (and DOM) parser objects. The JAXP package ships with default parser implementations but allows other parsers to be easily plugged in and configured using system properties. At this writing, the current version of JAXP is 1.0.1; it supports SAX 1, but not SAX 2. By the time you read this, however, JAXP 1.1, which will include support for SAX 2, may have become available.

Example 19.1 is a listing of ListServlets1.java, a program that uses JAXP and SAX to parse a web application deployment descriptor and list the names of the servlets configured by that file. If you haven't yet read Chapter 18, Servlets and JSP, you should know that servlet-based web applications are configured using an XML file named web.xml. This file contains <servlet> tags that define mappings between servlet names and the Java classes that implement them. To help you understand the task to be solved by the ListServlets1.java program, here is an excerpt from the web.xml file developed in Chapter 18:

  <servlet>   </servlet>   <servlet>   </servlet>   <servlet>   </servlet>

ListServlets1.java includes a main() method that uses the JAXP API to obtain a SAX parser instance. It then tells the parser what to parse and starts the parser running. The remaining methods of the class are invoked by the parser. Note that ListServlets1 extends the SAX HandlerBase class. This superclass provides dummy implementations of all the SAX event handler methods. The example simply overrides the handlers of interest. The parser calls the startElement() method when it reads an XML tag; it calls endElement() when it finds a closing tag. characters() is invoked when the parser reads a string of plain text with no markup. Finally, the parser calls warning(), error(), or fatalError() when something goes wrong in the parsing process. The implementations of these methods are written specifically to extract the desired information from a web.xml file and are based on a knowledge of the structure of this type of file.

Note that web.xml files are somewhat unusual in that they don't rely on attributes for any of the XML tags. That is, servlet names are defined by a <servlet-name> tag nested within a <servlet> tag, instead of simply using a name attribute of the <servlet> tag itself. This fact makes the example program slightly more complex than it would otherwise be. The web.xml file does allow id attributes for all its tags. Although servlet engines are not expected to use these attributes, they may be useful to a configuration tool that parses and automatically generates web.xml files. For completeness, the startElement() method in Example 19.1 looks for an id attribute of the <servlet> tag. The value of that attribute, if it exists, is reported in the program's output.

Example 19.1: ListServlets1.java

 package com.davidflanagan.examples.xml; import javax.xml.parsers.*;                   // The JAXP package import org.xml.sax.*;                         // The main SAX package import java.io.*; /**  * Parse a web.xml file using JAXP and SAX1.  Print out the names  * and class names of all servlets listed in the file.  *  * This class implements the HandlerBase helper class, which means  * that it defines all the "callback" methods that the SAX parser will  * invoke to notify the application.  In this example we override the  * methods that we require.  *  * This example uses full package names in places to help keep the JAXP  * and SAX APIs distinct.  **/ public class ListServlets1 extends org.xml.sax.HandlerBase { 

Compiling and Running the Example

To run the previous example, you need the JAXP package from Sun. You can download it by following the download links from http://java.sun.com/xml/. Once you've downloaded the package, uncompress the archive it is packaged in and install it somewhere convenient on your system. In Version 1.0.1 of JAXP, the download bundle contains two JAR files: jaxp.jar, the JAXP API classes, and parser.jar, the SAX and DOM APIs and default parser implementations. To compile and run this example, you need both JAR files in your classpath. If you have any other XML parsers, such as the Xerces parser, in your classpath, remove them or make sure that the JAXP files are listed first; otherwise you may run into version-skew problems between the different parsers. Note that you probably don't want to permanently alter your classpath, since you'll have to change it again for the next example. One simple solution with Java 1.2 and later is to temporarily drop copies of the JAXP JAR files into the jre/lib/ext/ directory of your Java installation.

With the two JAXP JAR files temporarily in your classpath, you can compile and run ListServlets1.java as usual. When you run it, specify the name of a web.xml file on the command line. You can use the sample file included with the downloadable examples for this book or specify one from your own servlet engine.

There is one complication to this example. Most web.xml files contain a <!DOCTYPE> tag that specifies the document type (or DTD). Despite the fact that Example 19.1 specifies that the parser should not validate the document, a conforming XML parser must still read the DTD for any document that has a <!DOCTYPE> declaration. Most web.xml have a declaration like this:

<!DOCTYPE web-app 
Parsing with SAX 2
 
         Example 19.1       showed how you can parse an XML document using the SAX 1 API,       which is what is supported by the current version of JAXP (at        this writing).  The SAX 1 API is out of date, however.  So        Example 19.2      shows how you can accomplish a similar parsing task using the       SAX 2 API and the open-source Xerces parser available from         the Apache Software Foundation. 
        Example 19.2       is a listing of the program       ListServlets2.java.  Like the       ListServlets1.java example, this       program reads a specified web.xml file and       looks for <servlet> tags, so it can       print out the servlet name-to-servlet class mappings.  This example       goes a little further than the last, however, and also looks for       <servlet-mapping> tags, so it can also       output the URL patterns that are mapped to named       servlets.  The example uses two hashtables to store the information        as it accumulates it, then prints out all the information when parsing       is complete. 
      The SAX 2 API is functionally similar to the SAX 1 API, but a       number of classes and interfaces have new names and some methods       have new signatures.  Many of the changes were required for the       addition of XML namespace support in SAX 2.  As you read through       Example 19.2,       pay attention to the API differences from        Example 19.1. 
Example 19.2: ListServlets2.java
 
 package com.davidflanagan.examples.xml; import org.xml.sax.*;             // The main SAX package import org.xml.sax.helpers.*;     // SAX helper classes import java.io.*;                 // For reading the input file import java.util.*;               // Hashtable, lists, and so on /**  * Parse a web.xml file using the SAX2 API and the Xerces parser from the  * Apache project.  *  * This class extends DefaultHandler so that instances can serve as SAX2  * event handlers, and can be notified by the parser of parsing events.  * We simply override the methods that receive events we're interested in  **/ public class ListServlets2 extends org.xml.sax.helpers.DefaultHandler { 
 
Compiling and Running the Example
 
        The ListServlets2 example uses the Xerces-J         parser from the Apache XML Project.  You can download this      open-source parser by following the download links from        http://xml.apache.org/.  Once you have        downloaded Xerces-J, unpack the distribution in a convenient    location on your system.  In that distribution, you should find a       xerces.jar file. This file must be in your    classpath to compile and run the        ListServlets2.java example.  Note that the    xerces.jar file and the       parsers.jar file from the JAXP distribution   both contain versions of the SAX and DOM classes; you should    avoid having both files in your classpath at the same   time....

Table of Contents

	Preface	xiii
Part I	Core Java APIs
Chapter 1	Java Basics	3
	Hello World	3
	FizzBuzz	7
	The Fibonacci Series	10
	Using Command-Line Arguments	10
	Echo in Reverse	11
	FizzBuzz Switched	12
	Computing Factorials	13
	Recursive Factorials	14
	Caching Factorials	15
	Computing Big Factorials	16
	Handling Exceptions	17
	Interactive Input	18
	Using a StringBuffer	19
	Sorting Numbers	21
	Computing Primes	22
	Exercises	23
Chapter 2	Objects, Classes, and Interfaces	24
	A Rectangle Class	25
	Testing the Rect Class	26
	A Rect Subclass	27
	Another Subclass	27
	Complex Numbers	28
	Computing Pseudo-Random Numbers	30
	Computing Statistics	32
	A Linked List Class	33
	Advanced Sorting	36
	Exercises	42
Chapter 3	Input/Output	44
	Files and Streams	44
	Working with Files	48
	Copying File Contents	49
	Reading and Displaying Text Files	52
	Listing Directory and File Information	55
	Compressing Files and Directories	60
	Filtering Character Streams	62
	Filtering Lines of Text	64
	A Custom HTML Output Stream	65
	Exercises	68
Chapter 4	Threads	70
	Thread Basics	71
	Threads and Thread Groups	72
	Deadlock	75
	Timers	77
	Exercises	82
Chapter 5	Networking	84
	Downloading the Contents of a URL	84
	Using a URLConnection	86
	Sending Email Through a URLConnection	87
	Connecting to a Web Server	89
	A Simple Web Server	91
	A Proxy Server	93
	Networking with Applets	96
	A Generic Client	99
	A Generic Multithreaded Server	101
	A Multithreaded Proxy Server	113
	Sending Datagrams	116
	Receiving Datagrams	117
	Exercises	119
Chapter 6	Security and Cryptography	121
	Running Untrusted Code	122
	Loading Untrusted Code	123
	Message Digests and Digital Signatures	128
	Cryptography	136
	Exercises	139
Chapter 7	Internationalization	141
	A Word About Locales	141
	Unicode	142
	Character Encodings	146
	Handling Local Customs	148
	Localizing User-Visible Messages	151
	Formatted Messages	156
	Exercises	159
Chapter 8	Reflection	161
	Obtaining Class and Member Information	161
	Invoking a Named Method	164
	Exercises	168
Chapter 9	Object Serialization	169
	Simple Serialization	169
	Custom Serialization	172
	Externalizable Classes	174
	Serialization and Class Versioning	176
	Serialized Applets	177
	Exercises	178
Part II	Graphics and GUIs
Chapter 10	Graphical User Interfaces	181
	Components	183
	Containers	189
	Layout Management	190
	Event Handling	203
	A Complete GUI	217
	Actions and Reflection	221
	Custom Dialogs	222
	Displaying Tables	227
	Displaying Trees	230
	A Simple Web Browser	234
	Describing GUIs with Properties	242
	Themes and the Metal Look-and-Feel	253
	Custom Components	257
	Exercises	263
Chapter 11	Graphics	266
	Graphics Before Java 1.2	267
	The Java 2D API	276
	Drawing and Filling Shapes	277
	Transforms	279
	Line Styles with BasicStroke	281
	Stroking Lines	283
	Filling Shapes with Paint	284
	Antialiasing	287
	Combining Colors with AlphaComposite	289
	Image Processing	292
	A Custom Shape	295
	Custom Strokes	299
	Custom Paint	303
	Advanced Animation	305
	Displaying Graphics Examples	308
	Exercises	312
Chapter 12	Printing	314
	Printing with the Java 1.1 API	314
	Printing with the Java 1.2 API	316
	Printing Multipage Text Documents	319
	Printing Swing Documents	327
	Exercises	333
Chapter 13	Data Transfer	334
	Data Transfer Architecture	334
	Simple Copy-and-Paste	335
	A Transferable Data Type	338
	Cutting and Pasting Scribbles	344
	Dragging and Dropping Scribbles	347
	Exercises	353
Chapter 14	JavaBeans	354
	Bean Basics	355
	A Simple Bean	356
	A More Complex Bean	360
	Custom Events	364
	Specifying Bean Information	365
	Defining a Simple Property Editor	367
	Defining a Complex Property Editor	369
	Defining a Bean Customizer	371
	Exercises	374
Chapter 15	Applets	375
	Introduction to Applets	375
	A First Applet	377
	A Clock Applet	378
	Applets and the Java 1.0 Event Model	380
	Java 1.0 Event Details	383
	Reading Applet Parameters	385
	Images and Sounds	387
	JAR Files	391
	Exercises	392
Part III	Enterprise Java
Chapter 16	Remote Method Invocation	395
	Remote Banking	396
	A Bank Server	400
	A Multiuser Domain	404
	Remote MUD Interfaces	405
	The MUD Server	408
	The MudPlace Class	411
	The MudPerson Class	418
	A MUD Client	420
	Advanced RMI	428
	Exercises	429
Chapter 17	Database Access with SQL	431
	Accessing a Database	432
	Using Database Metadata	438
	Building a Database	441
	Using the API Database	446
	Atomic Transactions	450
	Exercises	456
Chapter 18	Servlets and JSP	458
	Servlet Setup	458
	A Hello World Servlet	461
	Servlet Initialization and Persistence: A Counter Servlet	463
	Database Access with Servlets	467
	A Login Screen with JSP	471
	Request Forwarding	476
	JSP Pages and JavaBeans	477
	Ending a User Session	482
	Custom Tags	483
	Deploying a Web Application	488
	Exercises	492
Chapter 19	XML	494
	Parsing with JAXP and SAX 1	494
	Parsing with SAX 2	499
	Parsing and Manipulating with JAXP and DOM	502
	Traversing a DOM Tree	506
	Traversing a Document with DOM Level 2	508
	The JDOM API	512
	Exercises	514
Chapter 20	Example Index	516
	Index	535