1. Designing and Building: The Basics of RMI Applications

   1. Chapter 1 Streams

      1. The Core Classes
      2. Viewing a File
      3. Layering Streams
      4. Readers and Writers

   2. Chapter 2 Sockets

      1. Internet Definitions
      2. Sockets
      3. ServerSockets
      4. Customizing Socket Behavior
      5. Special-Purpose Sockets
      6. Using SSL

   3. Chapter 3 A Socket-Based Printer Server

      1. A Network-Based Printer
      2. The Basic Objects
      3. The Protocol
      4. The Application Itself
      5. Evolving the Application

   4. Chapter 4 The Same Server, Written Using RMI

      1. The Basic Structure of RMI
      2. The Architecture Diagram Revisited
      3. Implementing the Basic Objects
      4. The Rest of the Server
      5. The Client Application
      6. Summary

   5. Chapter 5 Introducing the Bank Example

      1. The Bank Example
      2. Sketching a Rough Architecture
      3. The Basic Use Case
      4. Additional Design Decisions
      5. A Distributed Architecturefor the Bank Example
      6. Problems That Arise in Distributed Applications

   6. Chapter 6 Deciding on the Remote Server

      1. A Little Bit of Bias
      2. Important Questions WhenThinking About Servers
      3. Should We Implement Bank or Account?

   7. Chapter 7 Designing the Remote Interface

      1. Important Questions When Designing Remote Interfaces
      2. Building the Data Objects
      3. Accounting for Partial Failure

   8. Chapter 8 Implementing the Bank Server

      1. The Structure of a Server
      2. Implementing the Server
      3. Generating Stubs and Skeletons

   9. Chapter 9 The Rest of the Application

      1. The Need for Launch Code
      2. Our Actual Launch Code
      3. Build Test Applications
      4. Build the Client Application
      5. Deploying the Application

2. Drilling Down: Scalability

   1. Chapter 10 Serialization

      1. The Need for Serialization
      2. Using Serialization
      3. How to Make a Class Serializable
      4. The Serialization Algorithm
      5. Versioning Classes
      6. Performance Issues
      7. The Externalizable Interface

   2. Chapter 11 Threads

      1. More Than One Client
      2. Basic Terminology
      3. Threading Concepts
      4. Support for Threads in Java
      5. Deadlock
      6. Threading and RMI

   3. Chapter 12 Implementing Threading

      1. The Basic Task
      2. Guidelines for Threading
      3. Pools: An Extended Example
      4. Some Final Words on Threading

   4. Chapter 13 Testing a Distributed Application

      1. Testing the Bank Application

   5. Chapter 14 The RMI Registry

      1. Why Use a Naming Service?
      2. The RMI Registry
      3. The RMI Registry Is an RMI Server
      4. Examining the Registry
      5. Limitations of the RMI Registry
      6. Security Issues

   6. Chapter 15 Naming Services

      1. Basic Design, Terminology,and Requirements
      2. Requirements for Our Naming Service
      3. Federation and Threading
      4. The Context Interface
      5. The Value Objects
      6. ContextImpl
      7. Switching Between Naming Services
      8. The Java Naming and Directory Interface (JNDI)

   7. Chapter 16 The RMI Runtime

      1. Reviewing the Mechanics of a Remote Method Call
      2. Distributed Garbage Collection
      3. RMI's Logging Facilities
      4. Other JVM Parameters

   8. Chapter 17 Factories and the Activation Framework

      1. Resource Management
      2. Factories
      3. Implementing a Generic Factory
      4. A Better Factory
      5. Persistence and the Server Lifecycle
      6. Activation
      7. A Final Word About Factories

3. Advanced Topics

   1. Chapter 18 Using Custom Sockets

      1. Custom Socket Factories
      2. Incorporating a Custom Socket into an Application

   2. Chapter 19 Dynamic Classloading

      1. Deploying Can Be Difficult
      2. Classloaders
      3. How Dynamic Classloading Works
      4. The Class Server
      5. Using Dynamic Classloadingin an Application

   3. Chapter 20 Security Policies

      1. A Different Kind of Security Problem
      2. Permissions
      3. Security Managers
      4. Setting Up a Security Policy

   4. Chapter 21 Multithreaded Clients

      1. Different Types of Remote Methods
      2. Handling Printer-Type Methods
      3. Handling Report-Type Methods
      4. Generalizing from These Examples

   5. Chapter 22 HTTP Tunneling

      1. Firewalls
      2. CGI and Dynamic Content
      3. HTTP Tunneling
      4. A Servlet Implementationof HTTP Tunneling
      5. Modifying the Tunneling Mechanism
      6. The Bank via HTTP Tunneling
      7. Drawbacks of HTTP Tunneling
      8. Disabling HTTP Tunneling

   6. Chapter 23 RMI, CORBA, and RMI/IIOP

      1. How CORBA Works
      2. The Bank Example in CORBA
      3. A Quick Comparison of CORBA and RMI
      4. RMI on Top of CORBA
      5. Converting the Bank Example to RMI/IIOP

1. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Java RMI is a European red squirrel (Sciurus vulgaris). The word squirrel comes from the Greek skia, meaning shadow, and oura, tail.

Squirrel species exist on every continent except Australia and Antarctica. The red squirrel is common throughout central Europe, but in Great Britain, where it was once also abundant, its numbers have been greatly reduced. The grey squirrel, a heartier species, has largely replaced it; there are now about 60 times as many grey squirrels as red in Great Britain.

The red squirrel is light-red to black in color on its head and back. All except those with black fur have white stomachs; the black ones are black all over. They have tufts of fur sticking up from their ears. They spend much of their time up in trees; their sharp claws make them good climbers, and they can survive falls of up to 100 feet. They eat mostly seeds, acorns, and nuts, but they'll also eat mushrooms, flowers, vegetables, and even eggs when their main food source is scarce.

Female red squirrels usually produce two litters of young each year, with five to seven babies in each. They're blind and hairless at birth and weigh only eight to twelve grams, but by eight weeks of age, they are weaned and fully independent--though they have a tendency to darken their mother's doorstep for a while longer, until they're ready to face the world on their own. Matt Hutchinson was the production editor and copyeditor for Java RMI. Maureen Dempsey proofread the book. Claire Cloutier, Tatiana Apandi Diaz, Jane Ellin, and Sue Willing provided quality control. Sarah Sherman, Edie Shapiro, and Derek DiMatteo provided production assistance. Johnna VanHoose Dinse wrote the index.

Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

Melanie Wang designed the interior layout. Anne-Marie Vaduva reformatted the files in FrameMaker 5.5.6 using tools created by Mike Sierra. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is Lucas-Font's Sans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Leanne Soylemez.

Whenever possible, our books use a durable and flexible lay-flat binding. If the page count exceeds this binding's limit, perfect binding is used.