Java RMI - Datenbankanwendung
Im vorherigen Kapitel haben wir eine RMI-Beispielanwendung erstellt, in der ein Client eine Methode aufruft, die ein GUI-Fenster (JavaFX) anzeigt.
In diesem Kapitel sehen wir uns anhand eines Beispiels an, wie ein Clientprogramm die Datensätze einer Tabelle in der MySQL-Datenbank auf dem Server abrufen kann.
Angenommen, wir haben eine Tabelle mit dem Namen student_data in der Datenbank details Wie nachfolgend dargestellt.
+----+--------+--------+------------+---------------------+
| ID | NAME | BRANCH | PERCENTAGE | EMAIL |
+----+--------+--------+------------+---------------------+
| 1 | Ram | IT | 85 | [email protected] |
| 2 | Rahim | EEE | 95 | [email protected] |
| 3 | Robert | ECE | 90 | [email protected] |
+----+--------+--------+------------+---------------------+
Angenommen, der Name des Benutzers lautet myuser und sein Passwort ist password.
Erstellen einer Schülerklasse
Ein ... kreieren Student Klasse mit setter und getter Methoden wie unten gezeigt.
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;
}
}
Remote-Schnittstelle definieren
Definieren Sie die Remote-Schnittstelle. Hier definieren wir eine Remote-Schnittstelle mit dem NamenHello mit einer Methode namens getStudents ()drin. Diese Methode gibt eine Liste zurück, die das Objekt der Klasse enthältStudent.
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;
}
Entwicklung der Implementierungsklasse
Erstellen Sie eine Klasse und implementieren Sie die oben erstellte interface.
Hier implementieren wir die getStudents() Methode der Remote interface. Wenn Sie diese Methode aufrufen, werden die Datensätze einer Tabelle mit dem Namen abgerufenstudent_data. Setzt diese Werte mithilfe ihrer Setter-Methoden auf die Student-Klasse, fügt sie einem Listenobjekt hinzu und gibt diese Liste zurück.
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;
}
}
Serverprogramm
Ein RMI-Serverprogramm sollte die Remote-Schnittstelle implementieren oder die Implementierungsklasse erweitern. Hier sollten wir ein entferntes Objekt erstellen und es an das bindenRMI registry.
Es folgt das Serverprogramm dieser Anwendung. Hier erweitern wir die oben erstellte Klasse, erstellen ein Remote-Objekt und registrieren es in der RMI-Registrierung mit dem Bindungsnamenhello.
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();
}
}
}
Client-Programm
Es folgt das Client-Programm dieser Anwendung. Hier rufen wir das entfernte Objekt ab und rufen die benannte Methode aufgetStudents(). Es ruft die Datensätze der Tabelle aus dem Listenobjekt ab und zeigt sie an.
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();
}
}
}
Schritte zum Ausführen des Beispiels
Im Folgenden finden Sie die Schritte zum Ausführen unseres RMI-Beispiels.
Step 1 - Öffnen Sie den Ordner, in dem Sie alle Programme gespeichert haben, und kompilieren Sie alle Java-Dateien wie unten gezeigt.
Javac *.java
Step 2 - Starten Sie die rmi Registrierung mit dem folgenden Befehl.
start rmiregistry
Dies startet eine rmi Registrierung in einem separaten Fenster wie unten gezeigt.
Step 3 - Führen Sie die Serverklassendatei wie unten gezeigt aus.
Java Server
Step 4 - Führen Sie die Clientklassendatei wie unten gezeigt aus.
java Client