Java RMI - Applicazione database

Nel capitolo precedente, abbiamo creato un'applicazione RMI di esempio in cui un client richiama un metodo che visualizza una finestra GUI (JavaFX).

In questo capitolo, faremo un esempio per vedere come un programma client può recuperare i record di una tabella nel database MySQL che risiede sul server.

Supponiamo di avere una tabella denominata student_data nel database details come mostrato di seguito.

+----+--------+--------+------------+---------------------+ 
| ID | NAME   | BRANCH | PERCENTAGE | EMAIL               | 
+----+--------+--------+------------+---------------------+ 
|  1 | Ram    | IT     |         85 | [email protected]    | 
|  2 | Rahim  | EEE    |         95 | [email protected]  | 
|  3 | Robert | ECE    |         90 | [email protected] | 
+----+--------+--------+------------+---------------------+

Supponiamo che il nome dell'utente sia myuser e la sua password è password.

Creazione di una classe per studenti

Creare un Student classe con setter e getter metodi come mostrato di seguito.

public class Student implements java.io.Serializable {   
   private int id, percent;   
   private String name, branch, email;    
  
   public int getId() { 
      return id; 
   } 
   public String getName() { 
      return name; 
   } 
   public String getBranch() { 
      return branch; 
   } 
   public int getPercent() { 
      return percent; 
   } 
   public String getEmail() { 
      return email; 
   } 
   public void setID(int id) { 
      this.id = id; 
   } 
   public void setName(String name) { 
      this.name = name; 
   } 
   public void setBranch(String branch) { 
      this.branch = branch; 
   } 
   public void setPercent(int percent) { 
      this.percent = percent; 
   } 
   public void setEmail(String email) { 
      this.email = email; 
   } 
}

Definizione dell'interfaccia remota

Definisci l'interfaccia remota. Qui stiamo definendo un'interfaccia remota denominataHello con un metodo denominato getStudents ()dentro. Questo metodo restituisce una lista che contiene l'oggetto della classeStudent.

import java.rmi.Remote; 
import java.rmi.RemoteException; 
import java.util.*;

// Creating Remote interface for our application 
public interface Hello extends Remote {  
   public List<Student> getStudents() throws Exception;  
}

Sviluppo della classe di implementazione

Crea una classe e implementa quanto sopra creato interface.

Qui stiamo implementando il getStudents() metodo del Remote interface. Quando si richiama questo metodo, vengono recuperati i record di una tabella denominatastudent_data. Imposta questi valori alla classe Student utilizzando i suoi metodi setter, lo aggiunge a un oggetto elenco e restituisce tale elenco.

import java.sql.*; 
import java.util.*;  

// Implementing the remote interface 
public class ImplExample implements Hello {  
   
   // Implementing the interface method 
   public List<Student> getStudents() throws Exception {  
      List<Student> list = new ArrayList<Student>();   
    
      // JDBC driver name and database URL 
      String JDBC_DRIVER = "com.mysql.jdbc.Driver";   
      String DB_URL = "jdbc:mysql://localhost:3306/details";  
      
      // Database credentials 
      String USER = "myuser"; 
      String PASS = "password";  
      
      Connection conn = null; 
      Statement stmt = null;  
      
      //Register JDBC driver 
      Class.forName("com.mysql.jdbc.Driver");   
      
      //Open a connection
      System.out.println("Connecting to a selected database..."); 
      conn = DriverManager.getConnection(DB_URL, USER, PASS); 
      System.out.println("Connected database successfully...");  
      
      //Execute a query 
      System.out.println("Creating statement..."); 
      
      stmt = conn.createStatement();  
      String sql = "SELECT * FROM student_data"; 
      ResultSet rs = stmt.executeQuery(sql);  
      
      //Extract data from result set 
      while(rs.next()) { 
         // Retrieve by column name 
         int id  = rs.getInt("id"); 
         
         String name = rs.getString("name"); 
         String branch = rs.getString("branch"); 
         
         int percent = rs.getInt("percentage"); 
         String email = rs.getString("email");  
         
         // Setting the values 
         Student student = new Student(); 
         student.setID(id); 
         student.setName(name); 
         student.setBranch(branch); 
         student.setPercent(percent); 
         student.setEmail(email); 
         list.add(student); 
      } 
      rs.close(); 
      return list;     
   }  
}

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 fileRMI registry.

Di seguito è riportato il programma server di questa applicazione. Qui, estenderemo la classe creata sopra, creeremo un oggetto remoto e lo registreremo nel registro RMI con il nome di bindhello.

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(); 
      } 
   } 
}

Programma client

Di seguito è riportato il programma client di questa applicazione. Qui stiamo recuperando l'oggetto remoto e invocando il metodo denominatogetStudents(). Recupera i record della tabella dall'oggetto elenco e li visualizza.

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

public class Client {  
   private Client() {}  
   public static void main(String[] args)throws Exception {  
      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 
         List<Student> list = (List)stub.getStudents(); 
         for (Student s:list)v { 
            
            // System.out.println("bc "+s.getBranch()); 
            System.out.println("ID: " + s.getId()); 
            System.out.println("name: " + s.getName()); 
            System.out.println("branch: " + s.getBranch()); 
            System.out.println("percent: " + s.getPercent()); 
            System.out.println("email: " + s.getEmail()); 
         }  
      // System.out.println(list); 
      } catch (Exception e) { 
         System.err.println("Client exception: " + e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

Passaggi per eseguire l'esempio

Di seguito sono riportati i passaggi per eseguire il nostro esempio RMI.

Step 1 - Apri la cartella in cui hai memorizzato tutti i programmi e compila tutti i file Java come mostrato di seguito.

Javac *.java

Step 2 - Avvia il file rmi registro utilizzando il seguente comando.

start rmiregistry

Questo avvierà un file rmi registro su una finestra separata come mostrato di seguito.

Step 3 - Eseguire il file di classe del server come mostrato di seguito.

Java Server

Step 4 - Esegui il file della classe client come mostrato di seguito.

java Client