Java RMI 快速指南

上一页
下一页

Java RMI - 简介

RMI 代表 **远程方法调用**。它是一种机制，允许驻留在一个系统（JVM）中的对象访问/调用在另一个 JVM 上运行的对象。

RMI 用于构建分布式应用程序；它提供 Java 程序之间的远程通信。它在 **java.rmi** 包中提供。

RMI 应用程序的架构

在 RMI 应用程序中，我们编写两个程序，一个 **服务器程序**（驻留在服务器上）和一个 **客户端程序**（驻留在客户端上）。

  • 在服务器程序内部，创建了一个远程对象，并使该对象的引用可供客户端使用（使用注册表）。

  • 客户端程序请求服务器上的远程对象并尝试调用其方法。

下图显示了 RMI 应用程序的架构。

RMI Architecture

现在让我们讨论一下此架构的组件。

  • **传输层** - 此层连接客户端和服务器。它管理现有连接，并建立新连接。

  • **存根** - 存根是客户端上远程对象的表示（代理）。它驻留在客户端系统中；它充当客户端程序的网关。

  • **骨架** - 这是驻留在服务器端的对象。**存根**与该骨架通信以将请求传递给远程对象。

  • **RRL（远程引用层）** - 它是在客户端对远程对象进行引用时进行管理的层。

RMI 应用程序的工作原理

以下几点总结了 RMI 应用程序的工作原理 -

  • 当客户端对远程对象进行调用时，存根会接收该调用，并最终将此请求传递给 RRL。

  • 当客户端 RRL 接收请求时，它会调用对象 **remoteRef** 的名为 **invoke()** 的方法。它将请求传递给服务器端的 RRL。

  • 服务器端的 RRL 将请求传递给骨架（服务器上的代理），骨架最终在服务器上调用所需的对象。

  • 结果将一直传递回客户端。

编组和反编组

每当客户端调用远程对象上接受参数的方法时，这些参数都会被打包到消息中，然后通过网络发送。这些参数可以是基本类型或对象。对于基本类型，参数会组合在一起，并附加一个标头。如果参数是对象，则会对其进行序列化。此过程称为 **编组**。

在服务器端，打包的参数会被解包，然后调用所需的方法。此过程称为 **反编组**。

RMI 注册表

RMI 注册表是一个命名空间，所有服务器对象都放置在其中。服务器每次创建对象时，都会使用 **bind()** 或 **reBind()** 方法将此对象注册到 RMI 注册表中。这些是使用称为 **绑定名称** 的唯一名称注册的。

要调用远程对象，客户端需要该对象的引用。此时，客户端使用其绑定名称（使用 **lookup()** 方法）从注册表中获取对象。

下图说明了整个过程 -

Registry

RMI 的目标

以下是 RMI 的目标 -

  • 最大程度地降低应用程序的复杂性。
  • 保留类型安全性。
  • 分布式垃圾回收。
  • 最大程度地减少使用本地对象和远程对象之间的差异。

Java RMI 应用程序

要编写 RMI Java 应用程序，您需要按照以下步骤操作 -

  • 定义远程接口
  • 开发实现类（远程对象）
  • 开发服务器程序
  • 开发客户端程序
  • 编译应用程序
  • 执行应用程序

定义远程接口

远程接口提供了特定远程对象的所有方法的描述。客户端与此远程接口通信。

要创建远程接口 -

  • 创建一个扩展预定义接口 **Remote** 的接口，该接口属于该包。

  • 在此接口中声明客户端可以调用的所有业务方法。

  • 由于远程调用期间存在网络问题的可能性，因此可能会发生名为 **RemoteException** 的异常；抛出它。

以下是一个远程接口的示例。在这里，我们定义了一个名为 **Hello** 的接口，它有一个名为 **printMsg()** 的方法。

import java.rmi.Remote; 
import java.rmi.RemoteException;  

// Creating Remote interface for our application 
public interface Hello extends Remote {  
   void printMsg() throws RemoteException;  
}

开发实现类（远程对象）

我们需要实现前面步骤中创建的远程接口。（我们可以单独编写一个实现类，或者可以直接让服务器程序实现此接口。）

要开发实现类 -

  • 实现上一步中创建的接口。
  • 为远程接口的所有抽象方法提供实现。

以下是一个实现类。在这里，我们创建了一个名为 **ImplExample** 的类并实现了上一步中创建的 **Hello** 接口，并为该方法提供了 **主体**，该主体打印一条消息。

// Implementing the remote interface 
public class ImplExample implements Hello {  
   
   // Implementing the interface method 
   public void printMsg() {  
      System.out.println("This is an example RMI program");  
   }  
}

开发服务器程序

RMI 服务器程序应实现远程接口或扩展实现类。在这里，我们应该创建一个远程对象并将其绑定到 **RMI 注册表**。

要开发服务器程序 -

  • 从您想要调用远程对象的位置创建一个客户端类。

  • **创建远程对象**，方法是实例化实现类，如下所示。

  • 使用名为 **UnicastRemoteObject** 的类的 **exportObject()** 方法导出远程对象，该类属于 **java.rmi.server** 包。

  • 使用 **java.rmi.registry** 包中名为 **LocateRegistry** 类的 **getRegistry()** 方法获取 RMI 注册表。

  • 使用名为 **Registry** 类的 **bind()** 方法将创建的远程对象绑定到注册表。为此方法传递表示绑定名称和导出的对象的字符串作为参数。

以下是一个 RMI 服务器程序的示例。

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

开发客户端程序

在其中编写一个客户端程序，获取远程对象并使用此对象调用所需的方法。

要开发客户端程序 -

  • 从您打算调用远程对象的位置创建一个客户端类。

  • 使用 **java.rmi.registry** 包中名为 **LocateRegistry** 类的 **getRegistry()** 方法获取 RMI 注册表。

  • 使用 **java.rmi.registry** 包中名为 **Registry** 类的 **lookup()** 方法从注册表中获取对象。

    为此方法，您需要传递一个表示绑定名称的字符串值作为参数。这将返回远程对象。

  • lookup() 返回类型为远程的对象，将其向下转换为 Hello 类型。

  • 最后使用获得的远程对象调用所需的方法。

以下是一个 RMI 客户端程序的示例。

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

public class Client {  
   private Client() {}  
   public static void main(String[] args) {  
      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 
         stub.printMsg(); 
         
         // System.out.println("Remote method invoked"); 
      } catch (Exception e) {
         System.err.println("Client exception: " + e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

编译应用程序

要编译应用程序 -

  • 编译远程接口。
  • 编译实现类。
  • 编译服务器程序。
  • 编译客户端程序。

或者，

打开存储所有程序的文件夹，并编译所有 Java 文件，如下所示。

Javac *.java

Stored Programs

执行应用程序

**步骤 1** - 使用以下命令启动 **rmi** 注册表。

start rmiregistry

Start Execution

这将在一个单独的窗口中启动一个 **rmi** 注册表，如下所示。

Separate Window

**步骤 2** - 运行服务器类文件，如下所示。

Java Server

Run Server

**步骤 3** - 运行客户端类文件，如下所示。

java Client

Run Client

**验证** - 只要您启动客户端，您就会在服务器中看到以下输出。

Output

Java RMI - GUI 应用程序

在上一章中，我们创建了一个示例 RMI 应用程序。在本章中，我们将解释如何创建一个 RMI 应用程序，其中客户端调用一个显示 GUI 窗口（JavaFX）的方法。

定义远程接口

在这里，我们定义了一个名为 **Hello** 的远程接口，其中包含一个名为 **animation()** 的方法。

import java.rmi.Remote; 
import java.rmi.RemoteException;  

// Creating Remote interface for our application 
public interface Hello extends Remote { 
   void animation() throws RemoteException; 
}

开发实现类

在此应用程序的实现类（远程对象）中，我们尝试使用 JavaFX 创建一个显示 GUI 内容的窗口。

import javafx.animation.RotateTransition;  
import javafx.application.Application;  
import javafx.event.EventHandler;   

import javafx.scene.Group;  
import javafx.scene.PerspectiveCamera;  
import javafx.scene.Scene;  
import javafx.scene.control.TextField;  
import javafx.scene.input.KeyEvent;  
import javafx.scene.paint.Color;  
import javafx.scene.paint.PhongMaterial; 
  
import javafx.scene.shape.Box;  
import javafx.scene.text.Font;  
import javafx.scene.text.FontWeight;
import javafx.scene.text.Text;   
import javafx.scene.transform.Rotate;  

import javafx.stage.Stage;  
import javafx.util.Duration;  

// Implementing the remote interface 
public class FxSample extends Application implements Hello {  
   @Override  
   public void start(Stage stage) { 
      // Drawing a Box  
      Box box = new Box();  

      // Setting the properties of the Box  
      box.setWidth(150.0);  
      box.setHeight(150.0);    
      box.setDepth(100.0);  

      // Setting the position of the box  
      box.setTranslateX(350);   
      box.setTranslateY(150);  
      box.setTranslateZ(50);  

      // Setting the text  
      Text text = new Text(
         "Type any letter to rotate the box, and click on the box to stop the rotation");

      // Setting the font of the text  
      text.setFont(Font.font(null, FontWeight.BOLD, 15));      

      // Setting the color of the text  
      text.setFill(Color.CRIMSON);  

      // Setting the position of the text  
      text.setX(20);  
      text.setY(50); 

      // Setting the material of the box  
      PhongMaterial material = new PhongMaterial();   
      material.setDiffuseColor(Color.DARKSLATEBLUE);   

      // Setting the diffuse color material to box  
      box.setMaterial(material);        

      // Setting the rotation animation to the box     
      RotateTransition rotateTransition = new RotateTransition();  

      // Setting the duration for the transition  
      rotateTransition.setDuration(Duration.millis(1000));  

      // Setting the node for the transition  
      rotateTransition.setNode(box);        

      // Setting the axis of the rotation  
      rotateTransition.setAxis(Rotate.Y_AXIS);  

      // Setting the angle of the rotation 
      rotateTransition.setByAngle(360);  

      // Setting the cycle count for the transition  
      rotateTransition.setCycleCount(50);  

      // Setting auto reverse value to false  
      rotateTransition.setAutoReverse(false);   

      // Creating a text filed  
      TextField textField = new TextField();    

      // Setting the position of the text field  
      textField.setLayoutX(50);  
      textField.setLayoutY(100);  

      // Handling the key typed event  
      EventHandler<KeyEvent> eventHandlerTextField = new EventHandler<KeyEvent>() {  
         @Override  
         public void handle(KeyEvent event) {  
            // Playing the animation  
            rotateTransition.play();  
         }            
      };               
      
      // Adding an event handler to the text feld  
      textField.addEventHandler(KeyEvent.KEY_TYPED, eventHandlerTextField);  

      // Handling the mouse clicked event(on box)  
      EventHandler<javafx.scene.input.MouseEvent> eventHandlerBox =  
         new EventHandler<javafx.scene.input.MouseEvent>() {  
         @Override  
         public void handle(javafx.scene.input.MouseEvent e) {  
            rotateTransition.stop();   
         }  
      };  
      
      // Adding the event handler to the box   
      box.addEventHandler(javafx.scene.input.MouseEvent.MOUSE_CLICKED, eventHandlerBox); 

      // Creating a Group object 
      Group root = new Group(box, textField, text);  

      // Creating a scene object  
      Scene scene = new Scene(root, 600, 300);       

      // Setting camera  
      PerspectiveCamera camera = new PerspectiveCamera(false);  
      camera.setTranslateX(0);  
      camera.setTranslateY(0);  
      camera.setTranslateZ(0);  
      scene.setCamera(camera);   

      // Setting title to the Stage
      stage.setTitle("Event Handlers Example");  

      // Adding scene to the stage  
      stage.setScene(scene);  

      // Displaying the contents of the stage  
      stage.show();  
   }  

   // Implementing the interface method 
   public void animation() {  
      launch();  
   }  
}

服务器程序

RMI 服务器程序应实现远程接口或扩展实现类。在这里，我们应该创建一个远程对象并将其绑定到 **RMI 注册表**。

以下是此应用程序的服务器程序。在这里，我们将扩展上面创建的类，创建一个远程对象，并使用绑定名称 **hello** 将其注册到 RMI 注册表中。

import java.rmi.registry.Registry; 
import java.rmi.registry.LocateRegistry; 
import java.rmi.RemoteException; 
import java.rmi.server.UnicastRemoteObject; 

public class Server extends FxSample { 
   public Server() {} 
   public static void main(String args[]) { 
      try { 
         // Instantiating the implementation class 
         FxSample obj = new FxSample();
      
         // 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(); 
      } 
   } 
}

客户端程序

以下是此应用程序的客户端程序。在这里，我们正在获取远程对象并调用其名为 **animation()** 的方法。

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

public class Client { 
   private Client() {} 
   public static void main(String[] args) {  
      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 
         stub.animation(); 
         
         System.out.println("Remote method invoked"); 
      } catch (Exception e) {
         System.err.println("Client exception: " + e.toString()); 
         e.printStackTrace(); 
      } 
   } 
}

运行示例的步骤

以下是运行我们的 RMI 示例的步骤。

**步骤 1** - 打开存储所有程序的文件夹，并编译所有 Java 文件，如下所示。

Javac *.java

Stored Programs

**步骤 2** - 使用以下命令启动 **rmi** 注册表。

start rmiregistry

Start Execution

这将在一个单独的窗口中启动一个 **rmi** 注册表，如下所示。

Separate Window

**步骤 3** - 运行服务器类文件，如下所示。

Java Server

Run Server

**步骤 4** - 运行客户端类文件，如下所示。

java Client

Client Class

**验证** - 只要您启动客户端，您就会在服务器中看到以下输出。

Event Handler

Java RMI - 数据库应用程序

在上一章中，我们创建了一个示例 RMI 应用程序，其中客户端调用一个显示 GUI 窗口（JavaFX）的方法。

在本章中，我们将举一个例子来了解客户端程序如何检索驻留在服务器上的 MySQL 数据库中表的记录。

假设我们在数据库 **details** 中有一个名为 **student_data** 的表，如下所示。

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

假设用户的名称为 **myuser**，其密码为 **password**。

创建学生类

创建一个名为Student的类，并包含如下所示的setter和getter方法。

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

定义远程接口

定义远程接口。在这里，我们定义了一个名为Hello的远程接口，其中包含一个名为getStudents()的方法。此方法返回一个列表，该列表包含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;  
}

开发实现类

创建一个类并实现上面创建的接口。

在这里，我们实现了远程接口的getStudents()方法。当您调用此方法时，它会检索名为student_data的表的记录。使用其setter方法将这些值设置为Student类，将其添加到列表对象中并返回该列表。

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://127.0.0.1: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;     
   }  
}

服务器程序

RMI服务器程序应实现远程接口或扩展实现类。在这里，我们应该创建一个远程对象并将其绑定到RMI注册表。

以下是此应用程序的服务器程序。在这里，我们将扩展上面创建的类，创建一个远程对象并将其注册到RMI注册表，绑定名称为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(); 
      } 
   } 
}

客户端程序

以下是此应用程序的客户端程序。在这里，我们正在获取远程对象并调用名为getStudents()的方法。它从列表对象中检索表的记录并显示它们。

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

运行示例的步骤

以下是运行我们的 RMI 示例的步骤。

**步骤 1** - 打开存储所有程序的文件夹，并编译所有 Java 文件，如下所示。

Javac *.java

Stored Programs

**步骤 2** - 使用以下命令启动 **rmi** 注册表。

start rmiregistry

Start Execution

这将在一个单独的窗口中启动一个 **rmi** 注册表，如下所示。

Separate Window

**步骤 3** - 运行服务器类文件，如下所示。

Java Server

Run Server

**步骤 4** - 运行客户端类文件，如下所示。

java Client

Client File
打印页面
上一页
下一页
广告