Java RMI: aplicación de base de datos
En el capítulo anterior, creamos una aplicación RMI de muestra donde un cliente invoca un método que muestra una ventana GUI (JavaFX).
En este capítulo, tomaremos un ejemplo para ver cómo un programa cliente puede recuperar los registros de una tabla en la base de datos MySQL que reside en el servidor.
Supongamos que tenemos una tabla llamada student_data en la base de datos details Como se muestra abajo.
+----+--------+--------+------------+---------------------+
| ID | NAME | BRANCH | PERCENTAGE | EMAIL |
+----+--------+--------+------------+---------------------+
| 1 | Ram | IT | 85 | [email protected] |
| 2 | Rahim | EEE | 95 | [email protected] |
| 3 | Robert | ECE | 90 | [email protected] |
+----+--------+--------+------------+---------------------+Suponga que el nombre del usuario es myuser y su contraseña es password.
Crear una clase para estudiantes
Crear un Student clase con setter y getter métodos como se muestra a continuación.
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;
}
}Definición de la interfaz remota
Defina la interfaz remota. Aquí, estamos definiendo una interfaz remota llamadaHello con un método llamado getStudents ()en eso. Este método devuelve una lista que contiene el objeto de la clase.Student.
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;
}Desarrollar la clase de implementación
Cree una clase e implemente lo creado anteriormente interface.
Aquí estamos implementando el getStudents() método del Remote interface. Cuando invoca este método, recupera los registros de una tabla llamadastudent_data. Establece estos valores en la clase Student usando sus métodos de establecimiento, los agrega a un objeto de lista y devuelve esa lista.
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;
}
}Programa de servidor
Un programa de servidor RMI debe implementar la interfaz remota o extender la clase de implementación. Aquí, deberíamos crear un objeto remoto y vincularlo alRMI registry.
A continuación se muestra el programa de servidor de esta aplicación. Aquí, ampliaremos la clase creada anteriormente, crearemos un objeto remoto y lo registraremos en el registro RMI con el nombre de enlace.hello.
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();
}
}
}Programa de cliente
A continuación se muestra el programa cliente de esta aplicación. Aquí, buscamos el objeto remoto e invocamos el método llamadogetStudents(). Recupera los registros de la tabla del objeto de lista y los muestra.
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();
}
}
}Pasos para ejecutar el ejemplo
Los siguientes son los pasos para ejecutar nuestro ejemplo RMI.
Step 1 - Abra la carpeta donde ha almacenado todos los programas y compile todos los archivos Java como se muestra a continuación.
Javac *.java
Step 2 - Inicie el rmi registro usando el siguiente comando.
start rmiregistry
Esto iniciará un rmi registro en una ventana separada como se muestra a continuación.
Step 3 - Ejecute el archivo de clase del servidor como se muestra a continuación.
Java Server
Step 4 - Ejecute el archivo de clase del cliente como se muestra a continuación.
java Client