• What's Needed:
  • Stubs/Skeletons for marshalling and unmarshalling
  • A way to locate remote objects
• What Java Provides:
  • Dynamic generation of stubs
  • Skeleton functionality within the class
  • Tools (i.e., rmiregistry and rmid) that provide registry services

• "Newer" Versions of Java:
  • A remote interface normally does not include a suffix (e.g., Server)
  • A class that implements a remote interface normally includes the Impl suffix (e.g., ServerImpl)
• "Older" Versions of Java:
  • A stub class that was generated by the rmic tool normally included the _Stub suffix (e.g., Server_Stub)
  • A skeleton class that was generated by the rmic tool normally included the _Skel suffix (e.g., Server_Skel).

• The Remote Interface:
  • Any object that wants to be available remotely must directly or indirectly implement the Remote interface
  • The Remote interface has no methods or fields and serves only to identify the semantics of being remotely available
• The RemoteException Class:
  • It is the common superclass for a number of communication-related exceptions that may occur during the execution of a remote method call
  • All methods in an interface/class that extends/implements the Remote interface must list RemoteException in its throws clause

• An Observation:
  • Most methods are either passed parameters or return something
  • The parameters/returns are often objects
• Classes to be Passed/Returned:
  • Must be serializable
  • Hence, normally implement the Serializable interface

• Comparing "Normal" Objects:
  • Use the equals() method
• Comparing "Remote" Objects:
  • The equals method in the Object class does not work correctly
  • One remedy is to extend the UnicastRemoteObject class (which also implements the hashCode() and toString() methods)

The Course Class is Unchanged

javaexamples/remoteobjects/Course.java

import java.io.Serializable;


/**
 * A Course 
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Course implements Serializable
{
    private int    number;
    private String department, title;

    /**
     * Explicit Value Constructor
     *
     * @param department  The department code
     * @param number      The course number
     * @param title       The course title
     */
    public Course(String department, int number, String title)
    {
        this.department = department;
        this.number     = number;
        this.title      = title;
    }

    /**
     * Get the course designation
     *
     * @return  The course designation
     */
    public String getDesignation()
    {
        return department+number;
    }

    /**
     * Get the course title
     *
     * @return  The course title
     */
    public String getTitle()
    {
        return title;
    }
}
        

The CourseDatabase Interface

javaexamples/remoteobjects/rmi/CourseDatabase.java

import java.rmi.*;


/**
 * Methods that must be implemented by a database of Course objects
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0rmi
 */
public interface CourseDatabase extends Remote
{
    /**
     * Add a Course
     *
     * @param course   The Course to add
     */
    public void add(Course course)  throws RemoteException;


    /**
     * Get a Course
     *
     * @param course   The Course to add
     */
    public Course get(String department, int number)  throws RemoteException;


    /**
     * Remove a Course
     *
     *
     * @param department   The department code
     * @param number       The course number
     */
    public void remove(String department, int number)  throws RemoteException;

}
        

The CourseDatabase Implementation

javaexamples/remoteobjects/rmi/CourseDatabaseImpl.java

import java.rmi.*;
import java.rmi.server.*;
import java.util.*;

/**
 * The implementation of a database of Course objects
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0rmi
 */
public class CourseDatabaseImpl extends    UnicastRemoteObject
                                implements CourseDatabase
{
    private Hashtable      db;

    /**
     * Constructor
     */
    public CourseDatabaseImpl() throws RemoteException
    {
        db = new Hashtable();
    }

    /**
     * Add a Course
     *
     * @param course   The Course to add
     */
    public void add(Course course)  throws RemoteException
    {
        db.put(course.getDesignation(), course);
    }

    /**
     * Get a Course
     *
     * @param course   The Course to get
     */
    public Course get(String department, int number)  throws RemoteException
    {
        return (Course)db.get(department+number);
    }

    /**
     * Remove a Course
     *
     * @param department   The department code
     * @param number       The course number
     */
    public void remove(String department, int number)  throws RemoteException
    {
        db.remove(department+number);
    }
}
        

You Need a Policy File

grant
{
	permission java.security.AllPermission;
};
  

• The Naming Class:
  • Look up a remote object
  • Bind/rebind a name to a remote object
  • Unbind a name from a remote object
  • List the names that are bound bound in the registry
• The Names:
  • The names in the registry are URL formatted

The Client Driver

javaexamples/remoteobjects/rmi/ClientDriver.java

import java.rmi.*;

/**
 * The client in an example of Java's remote method invocation
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0rmi
 */
public class ClientDriver
{

    /**
     * The entry point
     *
     * @param args  The command line arguments
     */
    public static void main(String[] args)
    {
       Course           course;       
       CourseDatabase   db;
       String           host, username;
        
       System.setProperty("java.security.policy", "database.policy");        

       try 
       {
          db = (CourseDatabase)Naming.lookup("rmi://localhost:22801/CourseDatabase");
          db.add(new Course("CS",139,"Algorithm Development"));
          db.add(new Course("CS",240,"Data Structures and Algorithms"));
          db.add(new Course("CS",349,"Developing Multimedia Content"));
          db.add(new Course("CS",462,"Network Applications Development"));
          
          course = db.get("CS",462);
          System.out.println(course.getDesignation()+"\t"+
                             course.getTitle());          

       }
       catch (Exception e) 
       {
          e.printStackTrace();
       }
    }

}
        

The Server Driver

javaexamples/remoteobjects/rmi/ServerDriver.java

import java.rmi.*;

/**
 * A server Java's remote method invocation
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0rmi
 */
public class ServerDriver
{
    private static final String SERVERNAME = "//localhost:22801/CourseDatabase";


    /**
     * The entry point
     *
     * @param args  The command line arguments
     */
    public static void main(String[] args)
    {
       CourseDatabaseImpl    db;


       System.setProperty("java.security.policy", "database.policy");        
       System.setSecurityManager(new RMISecurityManager());


       try 
       {
          db = new CourseDatabaseImpl();
          Naming.rebind(SERVERNAME, db);
       }
       catch (Exception e) 
       {
          e.printStackTrace();
       }
    }
}
        

1. Compile the source files using the javac command.
2. Start the registry using the rmiregistry command (which uses port 1099 by default).
3. Run the application that adds the necessary remote objects to the registry (using the java command).
4. Run the applications/applets that use the remote objects.

History:

• Prior to version 1.2, the rmic tool was used to create stubs and skeletons.
• In versions 1.2-1.4, the rmic tool was used to create stubs but explicit skeletons were not needed.
• Starting in version 1.5, stub classes are generated at runtime. Hence, the rmic tool is no longer needed. (The rmic tool can be used for IIOP and IDL.)

• The Activatable Class:
  • Provides support for persistent remote objects that can be activated into "live" objects by the system when needed
• Notes:
  • The "invoker" does not need to know whether the activation system is being used or not, and, hence does, not need to change
  • What does need to change is the way that the "invoked" object is registered
• The rmid Tool:
  • Starts the activation system daemon (which must be started before activatable objects can be either registered or activated)