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