Java RMI - Application de base de données

Dans le chapitre précédent, nous avons créé un exemple d'application RMI dans laquelle un client appelle une méthode qui affiche une fenêtre GUI (JavaFX).

Dans ce chapitre, nous prendrons un exemple pour voir comment un programme client peut récupérer les enregistrements d'une table dans la base de données MySQL résidant sur le serveur.

Supposons que nous ayons une table nommée student_data dans la base de données details comme indiqué ci-dessous.

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

Supposons que le nom de l'utilisateur est myuser et son mot de passe est password.

Créer une classe d'étudiants

Créer un Student classe avec setter et getter méthodes comme indiqué ci-dessous.

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

Définition de l'interface distante

Définissez l'interface distante. Ici, nous définissons une interface distante nomméeHello avec une méthode nommée getStudents ()dedans. Cette méthode retourne une liste qui contient l'objet de la 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;  
}

Développement de la classe d'implémentation

Créez une classe et implémentez ce qui a été créé ci-dessus interface.

Ici, nous mettons en œuvre le getStudents() méthode de la Remote interface. Lorsque vous appelez cette méthode, elle récupère les enregistrements d'une table nomméestudent_data. Définit ces valeurs sur la classe Student à l'aide de ses méthodes de définition, l'ajoute à un objet de liste et renvoie cette liste.

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

Programme serveur

Un programme serveur RMI doit implémenter l'interface distante ou étendre la classe d'implémentation. Ici, nous devons créer un objet distant et le lier auRMI registry.

Voici le programme serveur de cette application. Ici, nous allons étendre la classe créée ci-dessus, créer un objet distant et l'enregistrer dans le registre RMI avec le nom de liaisonhello.

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

Programme client

Voici le programme client de cette application. Ici, nous récupérons l'objet distant et invoquons la méthode nomméegetStudents(). Il récupère les enregistrements de la table à partir de l'objet de liste et les affiche.

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

Étapes pour exécuter l'exemple

Voici les étapes pour exécuter notre exemple RMI.

Step 1 - Ouvrez le dossier dans lequel vous avez stocké tous les programmes et compilez tous les fichiers Java comme indiqué ci-dessous.

Javac *.java

Step 2 - Démarrez le rmi registre à l'aide de la commande suivante.

start rmiregistry

Cela va démarrer un rmi Registre sur une fenêtre distincte comme indiqué ci-dessous.

Step 3 - Exécutez le fichier de classe du serveur comme indiqué ci-dessous.

Java Server

Step 4 - Exécutez le fichier de classe client comme indiqué ci-dessous.

java Client