BusinessService: interfaces and implememtations using RMI factory

[Martin de Klaus]

Hi guys,

I already read a lot of posts regarding this topic:

http://www.coderanch.com/t/479761/java-developer-SCJD/certification/design-cloudier#2361306
http://www.coderanch.com/t/547905/java-developer-SCJD/certification/Business-Service#2497723
...

And actually I am in the middle of testing my implementation but still I have some doubts. Maybe some of you could help me with the following questions.

Facts:
I need a RMI factory to identify clients. Meaning each client will get its own RemoteService instance from the RMI factory impl. Each RemoteService instance has its own Data(Implementaion of given interface) instance used as lock-identifier-object in the Data.lock() method implementation.

Code:

public interface Service {   
    public void book() throws ServiceException, RemoteException;  
    public Map<Integer, Room> listAll() throws ServiceException, RemoteException;  
    ....
}  
public interface RemoteService extends Service, Remote{   
    //empty since it gets all method declaration from Service interface
    //RemoteServices interface just required to add the Remote marker interface
}  

public class LocalServiceImpl implements Service {
    // this impl is used in LOCAL mode
   public  LocalServiceImp (String dbPath){
       //create a Data instance
      ... 
   }

   public void book() throws ServiceException {
    //does the following sequence: lock-read-check-update-unlock
     ...
    }
    public Map<Integer, Room> listAll() throws ServiceException {
    ....
    }
}
public class RemoteServiceImpl extends LocalServiceImpl implements RemoteService {
    //this impl is called in NETWORK mode 
   public  RemoteServiceImpl (String dbPath) throws RemoteException{
       //get a unique Data instance for each client
      super(dbPath)
      //make this service instance accessible(export) to the client
      UnicastRemoteObject.exportObject(this);
   }
   //no further method declaration since all are inherited from the LocalServiceImpl super class
}

public interface RemoteServiceFactory extends Remote {
    public abstract RemoteService getRemoteService() throws RemoteException;
}

public class RemoteServiceFactoryImpl implements RemoteServiceFactory {
    
    private Config config;

    public RemoteServiceFactoryImpl (Config config){
        //invoke only once with RMI registering on the server side
        this.config = config;
    }
     public RemoteService getRemoteService() throws RemoteException {
        return new RemoteServiceImpl(config.getDBPath())
    }
}
public class Server {
   ...
    public Server() throws ServerException {
     try {

                        RemoteServiceFactory remoteServiceFactory = (RemoteServiceFactory) UnicastRemoteObject
                                        .exportObject(new RoomOfferServiceFactoryImpl((config),
                                                        0);

                        LocateRegistry.createRegistry(Registry.REGISTRY_PORT).rebind(
                                        "Service",
                                        remoteServiceFactory );

                } catch (Exception e) {
                        throw new ServerException(
                                        "Server not started", e);
                }
   }

   ...
}

public class Client {
  private Service service;

 public Client() {
       //PSEUDO code below
       //if NETWORK mode
       RemoteServiceFactory remoteServiceFactory = (RemoteServiceFactory ) Naming.lookup(".../Service")                     
       service = remoteServiceFactory .getRemoteService();
      //if LOCAL mode
      service = new LocalServiceImpl(config.getDBPath());
   }
   
   public void book() throws ServiceException {
        try {
           service.book()
       catch(RemoteException e) {
           throw new ServiceException("Message",e);
       }
   }

   .....
}

Question 1: Is it ok to call "UnicastRemoteObject.exportObject(this);" in the RemoteServiceImpl constructor to avoid RemoteServiceImpl "extends UnicastRemoteObject"?
Question 2: Is it ok that RemoteServiceImpl does actually not redeclare the service methods incl. throwing RemoteException. Instead just the interface RemoteService declares the RemoteException??? That feels quite strange to me?
Question 3: Overall design approach? Any hints or recommendations?

Thanks and regards

Martin

[Roberto Perillo]

Howdy, Martin. Welcome to the CodeRanch!

Is it ok to call "UnicastRemoteObject.exportObject(this);" in the RemoteServiceImpl constructor to avoid RemoteServiceImpl "extends UnicastRemoteObject"?

You mean, on line 32 of your code? I don't think that is necessary because you are already doing so on line 58. I'm not sure though, because I didn't run this code...

Is it ok that RemoteServiceImpl does actually not redeclare the service methods incl. throwing RemoteException. Instead just the interface RemoteService declares the RemoteException??? That feels quite strange to me?

Declaring a method in an interface with a throws clause means that the implementations can throw the listed exceptions, not that the implementations have to throw them. It's not strange

Question 3: Overall design approach? Any hints or recommendations?

I couldn't take a very deep look at your code, but for what I've seen, I think you're fine!

[Martin de Klaus]

Hi Roberto,

Thanks for the quick reply.

You mean, on line 32 of your code? I don't think that is necessary because you are already doing so on line 58. I'm not sure though, because I didn't run this code...

Hmmm, Actually in line 32 the RemoteServiceImpl itself is exported.
In line 58 the RemoteServiceFACTORY is exported.

If I remove line 32, I recieve a java.io.NotSerializableException: RemoteServiceImpl. So I guess I need to export both, the RemoteServiceFactory and the RemoteServiceImpl. As far as I understand, the RemoteServiceImpl needs to be exported as well to enable the client to access the server via the Proxy(Stubs) pattern. To make the RemoteServiceImpl serializable doesnt make sense to me because then RemoteServiceImpl gets transported to the client and executed on the client side only without communicating to the server.

Declaring a method in an interface with a throws clause means that the implementations can throw the listed exceptions, not that the implementations have to throw them. It's not strange

That's obviously true . I was just wondering, if the actual class method does not declare the RemoteException, even if the interface did so, how will a error during execution of a remote method call indicated? Or is this somehow handled by RMI itself?

[Roel De Nijs]

Martin de Klaus wrote:Question 1: Is it ok to call "UnicastRemoteObject.exportObject(this);" in the RemoteServiceImpl constructor to avoid RemoteServiceImpl "extends UnicastRemoteObject"?

From an OO perspective it's in my opinion much better to call UnicastRemoteObject.exportObject(this); than extending UnicastRemoteObject. Why? If you extend a class, you are actually creating a more specialized version of the base class with more specific behavior. But your RemoteServiceImpl class doesn't do that I guess, it just wants to use the remote capabilities of that class. Another (obvious) reason (but for me less important than the 1st one): Java doesn't support multiple inheritance, so if you extend UnicastRemoteObject, you can't extend from another (business related) class.

Martin de Klaus wrote:Hmmm, Actually in line 32 the RemoteServiceImpl itself is exported.
In line 58 the RemoteServiceFACTORY is exported.

If I remove line 32, I recieve a java.io.NotSerializableException: RemoteServiceImpl. So I guess I need to export both, the RemoteServiceFactory and the RemoteServiceImpl.

I didn't implement a rmi factory myself, so no practical knowledge here. Just some (a little bit) common sense If you get an exception when removing the line, I think it's really needed But I wonder if the constructor is the right place to invoke that method I would move that call to the getRemoteService() method of the RemoteServiceFactoryImpl class. Seems more logical to me.

Martin de Klaus wrote:That's obviously true . I was just wondering, if the actual class method does not declare the RemoteException, even if the interface did so, how will a error during execution of a remote method call indicated? Or is this somehow handled by RMI itself?

Yes, that RemoteException is an RMI thingy In my SCJD days I had some fun playing around with all possible variants with Remote interface and RemoteException in method signature. Here you'll find the results.


Hope it helps!