java left logo
java middle logo
java right logo
 

Home arrow Book Reviews arrow Java RMI
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4099
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Java RMI E-mail
User Rating: / 25
PoorBest 
 Book Information

Image

Authors: William Grosso
Paperback: 572 pages
Publisher: O'Reilly Media, Inc.; 1 edition (October 15, 2001)
Language: English
ISBN: 1565924525
Product Dimensions: 9.2 x 7.1 x 1.1 inches
ImageAmazon.com Link


 Book Review

Java RMI by William Grosso is a good effort by the author as it covers all the detailed aspects of Java RMI technology. For a beginner, itís a quick learning experience while experts can gain valuable experience for constructing their own enterprise and distributed systems. The book effectively traverses through streams and sockets working its way through the basics of building scalable client-server architectures using RMI.

Grosso had provided sufficient experience in designing and implementing Java's Remote Method Invocation framework. This book is intended mainly for Java developers who want to build the distributed applications. Author had reflected RMI as a robust and effective way to build distributed applications in which all the participating programs are written in Java. RMI had been presented as a simple and easy to use framework for various applications here.

The book starts with an introduction to some of the essential features of RMI including Java's stream classes, wrapping of one stream into another, compressing of files etc. The discussion then moves on to the socket and socket-based applications. The author had not only explained the socket basics as to what sockets are, their creation, customization but had also taken into account building of socket-based distributed applications. In order to cover the entire topic of building RMI applications socket-based distributed application had been rebuild using RMI.

The book also presents a fairly detailed analysis of how introducing a network, changes the various aspects of application design. It highlights principles for partitioning an application into clients and servers. Next the author discusses how to make the server scale i.e. discussing the implementation decisions that must be made in order to build scalable and secure distributed applications. The concept of Serialization and Threading had been extensively explained. Various guidelines for thread implementation along with its usage for reduction in Response-Time had also been taken care of.

Recognizing the significance of testing the author had also provided guidelines for building an efficient testing framework. Issues related to the RMI Registry including its working, usage, its implementation in RMI server etc had been taken care of in a nice way. Some RMI limitations as well as security issues are also discussed. The focus then turns towards the Naming Services and the RMI Runtime functionalities. The author had not only explained the Naming Services usage, its requirements along with the Federation and Threading concept but had also talked about The Java Naming and Directory Interface (JNDI).

Talking about the RMI Runtime author had effectively covered the concepts of distributed garbage collector, configuration of RMI at runtime along with the Factories and the Activation Framework. From here the discussion moves on to various advanced features of RMI hence providing a smooth transition from providing essential material for building a sophisticated RMI application to some useful and important but not very essential advanced topics .It includes how to use Custom Sockets, how to replace standard sockets that RMI uses with other sockets along with some Dynamic Class loading related issues making the deployment of a distributed application easier.

The book also discusses some Security Policies and Tunneling concepts of Java2 in the later part of the book. Setting up of a security policy, Multithreaded Clients, Firewalls etc had also been explained in the best of the possible ways. The book ends with a useful coverage of The Common Object Request Broker Architecture (or CORBA) and The Enterprise JavaBeans (EJB) specification along with the comparison of CORBA to RMI.

Overall this is a good book for developers giving them all the necessary information about the Java RMI technology. It helps to present RMI as not only a useful tool for building distributed applications, but also as an ideal environment for Java programmers to learn how to build a distributed application.


 Table of Contents

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

  1. Chapter 1: Streams

    • The Core Classes
    • Viewing a File
    • Layering Streams
    • Readers and Writers

  2. Chapter 2: Sockets

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

  3. Chapter 3: A Socket-Based Printer Server

    • A Network-Based Printer
    • The Basic Objects
    • The Protocol
    • The Application Itself
    • Evolving the Application

  4. Chapter 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. Chapter 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. Chapter 6: Deciding on the Remote Server

    • A Little Bit of Bias
    • Important Questions When Thinking About Servers
    • Should We Implement Bank or Account?

  7. Chapter 7: Designing the Remote Interface

    • Important Questions When Designing Remote Interfaces
    • Building the Data Objects
    • Accounting for Partial Failure

  8. Chapter 8: Implementing the Bank Server

    • The Structure of a Server
    • Implementing the Server
    • Generating Stubs and Skeletons

  9. Chapter 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. Chapter 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. Chapter 11: Threads

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

  12. Chapter 12: Implementing Threading

    • The Basic Task
    • Guidelines for Threading
    • Pools: An Extended Example
    • Some Final Words on Threading

  13. Chapter 13: Testing a Distributed Application

    • Testing the Bank Application

  14. Chapter 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. Chapter 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. Chapter 16: The RMI Runtime

    • Reviewing the Mechanics of a Remote Method Call
    • Distributed Garbage Collection
    • RMI's Logging Facilities
    • Other JVM Parameters

  17. Chapter 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. Chapter 18: Using Custom Sockets

    • Custom Socket Factories
    • Incorporating a Custom Socket into an Application

  19. Chapter 19: Dynamic Class loading

    • Deploying Can Be Difficult
    • Class loaders
    • How Dynamic Class loading Works
    • The Class Server
    • Using Dynamic Class loading in an Application

  20. Chapter 20: Security Policies

    • A Different Kind of Security Problem
    • Permissions
    • Security Managers
    • Setting Up a Security Policy

  21. Chapter 21: Multithreaded Clients

    • Different Types of Remote Methods
    • Handling Printer-Type Methods
    • Handling Report-Type Methods
    • Generalizing from These Examples

  22. Chapter 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. Chapter 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
 Overview of Chapters

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

  1. Chapter 1: Streams

    • The Java's stream classes (Input stream, Output Stream etc.)
    • How to view as well as display the contents of a file.
    • How streams can be wrapped in other streams to provide incremental functionality.
    • How you can compress a file.
    • The Reader and Writer abstract classes.

  2. Chapter 2: Sockets

    • The Java's socket classes.
    • What are Sockets?
    • How to create a Socket.
    • How to write an application that will accept connections.
    • How you can customize the socket behavior.
    • What is Secure Sockets Layer (SSL) and how to implement them?

  3. Chapter 3: A Socket-Based Printer Server

    • How to to build a simple client-server application using sockets.
    • What are the various problems faced by the distributed applications.
    • How to solve the protocol related issues while developing the application.
    • The concept of Spooling.
    • How to write the data objects and the objects that encapsulate the network protocol.

  4. Chapter 4: The Same Server, Written Using RMI

    • The Basic Structure of RMI
    • The RMI Compiler.
    • How to build a simple client-server application using RMI.
    • What is Serialization and how is it implemented.
    • How to implement the Basic Objects using RMI.
    • How to implement a Printer in RMI.
    • What are the Format of Names in the RMI Registry

  5. Chapter 5: Introducing the Bank Example

    • How to design a distributed application.
    • What are the different types of Distributed Applications?
    • How to sketch a rough architecture while building a distributed application.
    • How to build a Distributed Architecture for a simple Banking environment.
    • What are the problems associated in building a distributed application.

  6. Chapter 6: Deciding on the Remote Server

    • How to choose between various design options while deciding on the Remote Server.
    • The interaction of stubs and skeletons with the RMI runtime
    • How to decide if a Single Server Handle a Typical Client Interaction.
    • How to Make a Server Handle Multiple Simultaneous Clients
    • How Easy Is It to Gracefully Extend the Software and Add New Functionality?

  7. Chapter 7: Designing the Remote Interface

    • How to design a remote interface.
    • What are the issues involved in building data objects as well as objects designed to be passed by value over the wire.
    • To what extent should arguments to remote methods be bundled together in objects?
    • How to account for a partial failure.
    • How to identify a Reasonable Set of Distributed Exceptions.

  8. Chapter 8: Implementing the Bank Server

    • The Structure of a Server.
    • What are the various design options available for server design?
    • How to generate stubs and skeletons.
    • How and why to get rid of skeletons.
    • How to implement your server with and without extending the UnicastRemoteObject

  9. Chapter 9: The Rest of the Application

    • How to build the launch code and assembling a simple client.
    • What is The Need for Launch Code and how does an actual Launch code looks like.
    • How to Build Test Applications.
    • How to Build a Client Application.
    • How to Deploy the Application

    Part II: Drilling Down: Scalability

  10. Chapter 10: Serialization

    • What is Serialization?
    • How serialization works.
    • How to use serialization efficiently within your applications
    • How to Make a Class Serializable.
    • The Serialization Algorithm.
    • How to take care of the changes in classes and how Serialization detects such changes.
    • How Externalizable Interface allows you to solve the performance problems associated with making a class Serializable.

  11. Chapter 11: Threads

    • Why threading is important in distributed programming.
    • Threading Concepts.
    • How to Control Individual Threads.
    • The concept of Deadlock.
    • What does the RMI specification says about threading

  12. Chapter 12: Implementing Threading

    • How to use threads in a distributed application.
    • What are the various guidelines to be followed for Threading?
    • How to minimize the time spent in Synchronized Blocks.
    • How to deal with Container Classes.
    • How to Use Threading to Reduce Response-Time Variance
    • How to Acquire Locks in a Fixed Order.

  13. Chapter 13: Testing a Distributed Application

    • Basics of building a testing framework.
    • How to Test a Server.
    • To know some minimal tests for a test application.
    • How to build simple test objects.
    • How to build aggregate tests that test entire use cases

  14. Chapter 14: The RMI Registry

    • How does RMI works.
    • How to use RMI in applications.
    • What is the need of Naming Service?
    • How the RMI registry is implemented as an RMI server.
    • What are the Limitations of the RMI Registry
    • Security issues regarding the RMI Registry.

  15. Chapter 15: Naming Services

    • How Naming Service are used in distributed computing.
    • How to build multithreaded servers.
    • Requirements for the Naming Service
    • The concept of Federation and Threading.
    • The Context Interface
    • How to implement your own container objects
    • How to Switch Between Naming Services.
    • The Java Naming and Directory Interface (JNDI).

  16. Chapter 16: The RMI Runtime

    • How the distributed garbage collector works.
    • How RMI maintains connections between clients and servers.
    • How to use the various RMI logging facilities.
    • How to customize RMI's behavior at runtime.
    • What are some additional parameters that can be used to configure the RMI runtime?

  17. Chapter 17: Factories and the Activation Framework

    • How the requirement of applications to have more infrastructure dealt with.
    • The Factory pattern.
    • How Factory pattern is supported in RMI.
    • How to Implement a Generic Factory.
    • How factory can be improved.
    • The Activation Framework.

    Part III: Advanced Topics

  18. Chapter 18: Using Custom Sockets

    • How to replace the standard (cleartext) sockets that RMI uses with other sockets.
    • How to Create Custom Socket Factories
    • Why to use a Custom Socket Class?
    • How to Incorporate a Custom Socket into an Application
    • How to Modify Ordinary, Activatable and Default Servers

  19. Chapter 19: Dynamic Class loading

    • Why deploying a distributed application is difficult.
    • How Dynamic class loading make this deployment a little easier.
    • How Classes are loaded.
    • How Dynamic Class loading Works.
    • The Class Server.
    • How to Use Dynamic Class loading in an Application.

  20. Chapter 20: Security Policies

    • The security policy mechanism in Java 2.
    • How to use it to safeguard the aspects of your RMI application.
    • How Java 2 introduces a list of permissions that must be granted to pieces of code.
    • How permissions are enforced by an instance of the SecurityManager class within a running JVM.
    • How to Set Up a Security Policy.

  21. Chapter 21: Multithreaded Clients

    • What are the different types of Remote Methods?
    • How to Handle Printer-Type Methods.
    • How to Handle Report-Type Methods.
    • How to have a RMI server inside the client application.
    • How to define a client-side callback interface.

  22. Chapter 22: HTTP Tunneling

    • How RMI application can use HTTP Tunneling to circumvent firewalls and enable your application to function.
    • The concept of Firewall.
    • The Servlet Implementation of HTTP Tunneling
    • What are the drawbacks of HTTP Tunneling
    • How to Disable HTTP Tunneling.

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

    • The Common Object Request Broker Architecture (or CORBA).
    • How CORBA works.
    • Comparison of CORBA to RMI.
    • How to decide when to use CORBA and when to use RMI.
    • How to Communicating via CORBA
    • The Enterprise JavaBeans (EJB) specification and RMI/IIOP

Reviewer: Sumit Kulshreshtha


 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.