Applicazione Java RMI

Per scrivere un'applicazione Java RMI, è necessario seguire i passaggi indicati di seguito:

Definisci l'interfaccia remota
Sviluppa la classe di implementazione (oggetto remoto)
Sviluppa il programma server
Sviluppa il programma client
Compilare l'applicazione
Esegui l'applicazione

Definizione dell'interfaccia remota

Un'interfaccia remota fornisce la descrizione di tutti i metodi di un particolare oggetto remoto. Il client comunica con questa interfaccia remota.

Per creare un'interfaccia remota:

Crea un'interfaccia che estenda l'interfaccia predefinita Remote che appartiene al pacchetto.
Dichiarare tutti i metodi di business che possono essere richiamati dal client in questa interfaccia.
Poiché esiste la possibilità di problemi di rete durante le chiamate remote, un'eccezione denominata RemoteExceptionpotrebbe capitare; gettarlo.

Di seguito è riportato un esempio di un'interfaccia remota. Qui abbiamo definito un'interfaccia con il nomeHello e ha un metodo chiamato printMsg().

import java.rmi.Remote; 
import java.rmi.RemoteException;  

// Creating Remote interface for our application 
public interface Hello extends Remote {  
   void printMsg() throws RemoteException;  
}

Sviluppo della classe di implementazione (oggetto remoto)

Dobbiamo implementare l'interfaccia remota creata nel passaggio precedente. (Possiamo scrivere una classe di implementazione separatamente o possiamo fare in modo che direttamente il programma server implementi questa interfaccia.)

Per sviluppare una classe di implementazione -

Implementa l'interfaccia creata nel passaggio precedente.
Fornire implementazione a tutti i metodi astratti dell'interfaccia remota.

Di seguito è una classe di implementazione. Qui abbiamo creato una classe denominataImplExample e implementato l'interfaccia Hello creato nel passaggio precedente e fornito body per questo metodo che stampa un messaggio.

// Implementing the remote interface 
public class ImplExample implements Hello {  
   
   // Implementing the interface method 
   public void printMsg() {  
      System.out.println("This is an example RMI program");  
   }  
}

Sviluppo del programma server

Un programma server RMI dovrebbe implementare l'interfaccia remota o estendere la classe di implementazione. Qui, dovremmo creare un oggetto remoto e associarlo al fileRMIregistry.

Per sviluppare un programma server:

Crea una classe client da cui desideri richiamare l'oggetto remoto.
Create a remote object istanziando la classe di implementazione come mostrato di seguito.
Esporta l'oggetto remoto utilizzando il metodo exportObject() della classe denominata UnicastRemoteObject che appartiene al pacchetto java.rmi.server.
Ottieni il registro RMI utilizzando il getRegistry() metodo del LocateRegistry classe che appartiene al pacchetto java.rmi.registry.
Associare l'oggetto remoto creato al registro utilizzando l'estensione bind() metodo della classe denominata Registry. A questo metodo, passare una stringa che rappresenta il nome del bind e l'oggetto esportato, come parametri.

Di seguito è riportato un esempio di un programma server RMI.

import java.rmi.registry.Registry; 
import java.rmi.registry.LocateRegistry; 
import java.rmi.RemoteException; 
import java.rmi.server.UnicastRemoteObject; 

public class Server extends ImplExample { 
   public Server() {} 
   public static void main(String args[]) { 
      try { 
         // Instantiating the implementation class 
         ImplExample obj = new ImplExample(); 
    
         // Exporting the object of implementation class  
         // (here we are exporting the remote object to the stub) 
         Hello stub = (Hello) UnicastRemoteObject.exportObject(obj, 0);  
         
         // Binding the remote object (stub) in the registry 
         Registry registry = LocateRegistry.getRegistry(); 
         
         registry.bind("Hello", stub);  
         System.err.println("Server ready"); 
      } catch (Exception e) { 
         System.err.println("Server exception: " + e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

Sviluppo del programma client

Scrivici un programma client, prendi l'oggetto remoto e invoca il metodo richiesto usando questo oggetto.

Per sviluppare un programma client -

Crea una classe client da cui intendi richiamare l'oggetto remoto.
Ottieni il registro RMI utilizzando il getRegistry() metodo del LocateRegistry classe che appartiene al pacchetto java.rmi.registry.
Recupera l'oggetto dal registro utilizzando il metodo lookup() della classe Registry che appartiene al pacchetto java.rmi.registry.

A questo metodo, è necessario passare un valore stringa che rappresenti il nome del bind come parametro. Questo ti restituirà l'oggetto remoto.
Lookup () restituisce un oggetto di tipo remote, eseguendo il down cast al tipo Hello.
Infine invoca il metodo richiesto utilizzando l'oggetto remoto ottenuto.

Di seguito è riportato un esempio di un programma client RMI.

import java.rmi.registry.LocateRegistry; 
import java.rmi.registry.Registry;  

public class Client {  
   private Client() {}  
   public static void main(String[] args) {  
      try {  
         // Getting the registry 
         Registry registry = LocateRegistry.getRegistry(null); 
    
         // Looking up the registry for the remote object 
         Hello stub = (Hello) registry.lookup("Hello"); 
    
         // Calling the remote method using the obtained object 
         stub.printMsg(); 
         
         // System.out.println("Remote method invoked"); 
      } catch (Exception e) {
         System.err.println("Client exception: " + e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}