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?

Hi guys,

I already read a lot of posts regarding this topic:

https://coderanch.com/t/479761/java-developer-SCJD/certification/design-cloudier#2361306
https://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