Skip to content

Java RMI Designing and Building Distributed Applications

Spend $50 to get a free movie!

ISBN-10: 1565924525

ISBN-13: 9781565924529

Edition: 2001

Authors: William Grosso, Mike Loukides

List price: $54.99
Blue ribbon 30 day, 100% satisfaction guarantee!
Out of stock
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!


"Java RMI contains a wealth of experience in designing and implementing Java's Remote Method Invocation. If you're a novice reader, you will quickly be brought up to speed on why RMI is such a powerful yet easy to use tool for distributed programming, while experts can gain valuable experience for constructing their own enterprise and distributed systems. 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…    
Customers also bought

Book details

List price: $54.99
Copyright year: 2001
Publisher: O'Reilly Media, Incorporated
Publication date: 11/6/2001
Binding: Paperback
Pages: 576
Size: 6.75" wide x 9.00" long x 1.00" tall
Weight: 1.738
Language: English

William Grosso is the former Chief Architect / Director of Quality Assurance and current Vice President of Technical Services for Hipbone Incorporated. He is the author of Java RMI (available from O'Reilly and Associates) and a co-author of Java Enterprise Best Practices (also available from O'Reilly and Associates). He is one of the founders of Seruku, is on the program committee of the International Semantic Web Conference, and frequently volunteers at SDForum (where he serves on the Board of Directors and helps to run the Emerging Technology SIG). A former mathematician, he got into programming because it seemed like easy money. He got into distributed computing because he noticed that…    

Designing and Building: The Basics of RMI Applications
Streams The Core Classes Viewing a File Layering Streams Readers and Writers
Sockets Internet Definitions Sockets Server
Sockets Customizing Socket Behavior Special-Purpose Sockets Using SSL
A Socket-Based Printer Server A Network-Based Printer
The Basic Objects
The Protocol
The Application Itself Evolving the Application
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
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
Deciding on the Remote Server
A Little Bit of Bias
Important Questions
When Thinking About Servers Should We Implement Bank or Account?
Designing the Remote Interface
Important Questions
When Designing Remote Interfaces
Building the Data Objects
Accounting for Partial Failure
Implementing the Bank Server
The Structure of a Server
Implementing the Server
Generating Stubs and Skeletons
The Rest of the Application
The Need for Launch Code Our Actual Launch Code Build Test Applications
Build the Client Application
Deploying the Application
Drilling Down: Scalability
Serialization The Need for Serialization
Using Serialization
How to Make a Class Serializable
The Serialization Algorithm Versioning
Classes Performance Issues
The Externalizable Interface
Threads More Than One Client
Basic Terminology Threading
Concepts Support for Threads in Java
Deadlock Threading and RMI
Implementing Threading
The Basic Task Guidelines for Threading Pools: An Extended Example
Some Final Words on Threading
Testing a Distributed Application
Testing the Bank Application
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
Naming Services Basic Design, Terminology, and Requirements
Requirements for Our Naming Service
Federation and Threading
The Context Interface
The Value Objects Context
Impl Switching Between Naming Services
The Java Naming and Directory Interface (JNDI)
The RMI Runtime
Reviewing the Mechanics of a Remote
Method Call Distributed Garbage
Collection RMI's Logging
Facilities Other JVM Parameters
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
Advanced Topics
Using Custom Sockets Custom Socket
Factories Incorporating a Custom Socket into an Application
Dynamic Classloading Deploying Can Be Difficult Classloaders
How Dynamic Classloading Works
The Class Server Using Dynamic
Classloading in an Application
Security Policies A Different Kind of Security
Problem Permissions Security
Managers Setting Up a Security Policy
Multithreaded Clients Different
Types of Remote Methods
Handling Printer-Type Methods
Handling Report-Type Methods
Generalizing from These Examples
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
The Bank Example in CORBA
A Quick Comparison of CORBA and RMI
RMI on Top of CORBA
Converting the Bank Example to RMI/IIOP