Java RMI

With Java RMI, you'll learn tips and tricks for making your RMI code excel. The book also provides strategies for working with serialization, threading, the RMI registry, sockets and socket factories, activation, dynamic class downloading, HTTP tunneling, distributed garbage collection, JNDI, and CORBA. In short, a treasure trove of valuable RMI knowledge packed into one book.

Table of Contents

Preface

Part I. Designing and Building: The Basics of RMI Applications

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

2. Sockets
Internet Definitions
Sockets
ServerSockets
Customizing Socket Behavior
Special-Purpose Sockets
Using SSL

3. A Socket-Based Printer Server
A Network-Based Printer
The Basic Objects
The Protocol
The Application Itself
Evolving the Application

4. The Same Server, Written Using RMI
The Basic Structure of RMI
The Architecture Diagram Revisited
Implementing the Basic Objects
The Rest of the Server
The Client Application
Summary

5. Introducing the Bank Example
The Bank Example
Sketching a Rough Architecture
The Basic Use Case
Additional Design Decisions
A Distributed Architecture for the Bank Example
Problems That Arise in Distributed Applications

6. Deciding on the Remote Server
A Little Bit of Bias
Important Questions When Thinking About Servers
Should We Implement Bank or Account?

7. Designing the Remote Interface
Important Questions When Designing Remote Interfaces
Building the Data Objects
Accounting for Partial Failure

8. Implementing the Bank Server
The Structure of a Server
Implementing the Server
Generating Stubs and Skeletons

9. The Rest of the Application
The Need for Launch Code
Our Actual Launch Code
Build Test Applications
Build the Client Application
Deploying the Application

Part II. Drilling Down: Scalability

10. Serialization
The Need for Serialization
Using Serialization
How to Make a Class Serializable
The Serialization Algorithm
Versioning Classes
Performance Issues
The Externalizable Interface

11. Threads
More Than One Client
Basic Terminology
Threading Concepts
Support for Threads in Java
Deadlock
Threading and RMI

12. Implementing Threading
The Basic Task
Guidelines for Threading
Pools: An Extended Example
Some Final Words on Threading

13. Testing a Distributed Application
Testing the Bank Application

14. The RMI Registry
Why Use a Naming Service?
The RMI Registry
The RMI Registry Is an RMI Server
Examining the Registry
Limitations of the RMI Registry
Security Issues

15. Naming Services
Basic Design, Terminology, and Requirements
Requirements for Our Naming Service
Federation and Threading
The Context Interface
The Value Objects
ContextImpl
Switching Between Naming Services
The Java Naming and Directory Interface (JNDI)

16. The RMI Runtime
Reviewing the Mechanics of a Remote Method Call
Distributed Garbage Collection
RMI's Logging Facilities
Other JVM Parameters

17. Factories and the Activation Framework
Resource Management
Factories
Implementing a Generic Factory
A Better Factory
Persistence and the Server Lifecycle
Activation
A Final Word About Factories

Part III. Advanced Topics

18. Using Custom Sockets
Custom Socket Factories
Incorporating a Custom Socket into an Application

19. Dynamic Classloading
Deploying Can Be Difficult
Classloaders
How Dynamic Classloading Works
The Class Server
Using Dynamic Classloading in an Application

20. Security Policies
A Different Kind of Security Problem
Permissions
Security Managers
Setting Up a Security Policy

21. Multithreaded Clients
Different Types of Remote Methods
Handling Printer-Type Methods
Handling Report-Type Methods
Generalizing from These Examples

22. HTTP Tunneling
Firewalls
CGI and Dynamic Content
HTTP Tunneling
A Servlet Implementation of HTTP Tunneling
Modifying the Tunneling Mechanism
The Bank via HTTP Tunneling
Drawbacks of HTTP Tunneling
Disabling HTTP Tunneling

23. RMI, CORBA, and RMI/IIOP
How CORBA Works
The Bank Example in CORBA
A Quick Comparison of CORBA and RMI
RMI on Top of CORBA
Converting the Bank Example to RMI/IIOP

Index