Question

i’m preparing for an exam and I’m having a question that I hope someone here could answer me.

It’s about RMI and remote objects. I wonder why there is so much difference between these two implementations. one is extending the UnicastRemoteObject whereas the other is exporting the object as an UnicastRemoteObject.

I don’t really get the difference

Interface:

public interface EchoI extends Remote {
   public String echo() throws RemoteException
}

This is the server code (version 1):

public class EchoImpl extends UnicastRemoteObject implements EchoI {
    public EchoImpl {
        super();
    }

    public static void main (String[] args) {
        try {
            LocateRegistry.createRegistry(Registry.REGISTRY_PORT);
            StoreHouse storehouseImpl = new StorehouseImpl();
            Naming.rebind("//localhost/StoreHouse.SERVICE_NAME", storehouseImpl);
            System.out.println("Server ready");
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

    public String echo() {
        return "echo";
    }
}

and this would be version 2:

public class EchoImpl implements EchoI {
    public static void main (String[] args) {
        EchoI echoService = new EchoImpl();
        EchoI stub = (EchoI) UnicastRemoteObject.exportObject(echoService, 0);
        Registry registry = LocateRegistry.getRegistry();
        registry.bind("echoService", stub);
        ...
    }
}

My question is: what is the difference between these two?

In thefirst version the registry is explicitly created, furthermore the remote object is created within a rebind?

I’m really curious, why in the first I need to create the registry myself but do not need to export the object explicitly and just rebind it using Naming. Is that object already bound to the registry before, or could I use bind instead? And what happens, if the object was not previously bound and a rebind is excecuted?

In the second version, the registry seems to be already created.
Why is binding to naming the same as binding to an registry directly?

This is, what I think:

• the first class direclty implements the interface UnicastRemoteObject which means, that at runtime the registry is created and the object is automatically exported to the RMI registry.
• as the object is already bound to the registry, a rebind instead of a normal bind must take place.
• the latter does all this explicitly.

Answer 1

java.rmi.server.UnicastRemoteObject is used for exporting a remote object with Java Remote Method Protocol (JRMP) and obtaining a stub that communicates to the remote object.

For the constructors and static exportObject methods below, the stub for a remote object being exported is obtained …

There you should follow the Javadoc