Java RMI - คู่มือฉบับย่อ

RMI ย่อมาจาก Remote Method Invocation. เป็นกลไกที่อนุญาตให้อ็อบเจ็กต์ที่อยู่ในระบบหนึ่ง (JVM) เข้าถึง / เรียกใช้อ็อบเจ็กต์ที่รันบน JVM อื่น

RMI ใช้เพื่อสร้างแอปพลิเคชันแบบกระจาย ให้การสื่อสารระยะไกลระหว่างโปรแกรม Java มีให้ในแพ็คเกจjava.rmi.

สถาปัตยกรรมของแอปพลิเคชัน RMI

ในแอปพลิเคชัน RMI เราเขียนโปรแกรมสองโปรแกรม a server program (อยู่บนเซิร์ฟเวอร์) และ a client program (อยู่บนไคลเอนต์)

ภายในโปรแกรมเซิร์ฟเวอร์จะมีการสร้างวัตถุระยะไกลและการอ้างอิงของวัตถุนั้นพร้อมใช้งานสำหรับไคลเอนต์ (โดยใช้รีจิสทรี)
โปรแกรมไคลเอ็นต์ร้องขอวัตถุระยะไกลบนเซิร์ฟเวอร์และพยายามเรียกใช้เมธอด

แผนภาพต่อไปนี้แสดงสถาปัตยกรรมของแอปพลิเคชัน RMI

ตอนนี้ให้เราพูดถึงส่วนประกอบของสถาปัตยกรรมนี้

Transport Layer- เลเยอร์นี้เชื่อมต่อไคลเอนต์และเซิร์ฟเวอร์ จะจัดการการเชื่อมต่อที่มีอยู่และตั้งค่าการเชื่อมต่อใหม่
Stub- ต้นขั้วเป็นตัวแทน (พร็อกซี) ของวัตถุระยะไกลที่ไคลเอนต์ มันอยู่ในระบบไคลเอนต์ ทำหน้าที่เป็นเกตเวย์สำหรับโปรแกรมไคลเอนต์
Skeleton - นี่คือวัตถุที่อยู่ทางฝั่งเซิร์ฟเวอร์ stub สื่อสารกับโครงกระดูกนี้เพื่อส่งคำขอไปยังวัตถุระยะไกล
RRL(Remote Reference Layer) - เป็นชั้นที่จัดการการอ้างอิงที่ลูกค้าทำไปยังวัตถุระยะไกล

การทำงานของแอปพลิเคชัน RMI

ประเด็นต่อไปนี้สรุปวิธีการทำงานของแอปพลิเคชัน RMI -

เมื่อไคลเอ็นต์ทำการโทรไปยังอ็อบเจ็กต์ระยะไกลไคลเอ็นต์จะได้รับโดยต้นขั้วซึ่งส่งคำขอนี้ไปยัง RRL ในที่สุด
เมื่อ RRL ฝั่งไคลเอ็นต์ได้รับคำขอจะเรียกใช้เมธอดที่เรียกว่า invoke() ของวัตถุ remoteRef. ส่งคำขอไปยัง RRL ทางฝั่งเซิร์ฟเวอร์
RRL บนฝั่งเซิร์ฟเวอร์ส่งคำขอไปยัง Skeleton (พร็อกซีบนเซิร์ฟเวอร์) ซึ่งสุดท้ายจะเรียกใช้วัตถุที่ต้องการบนเซิร์ฟเวอร์
ผลลัพธ์จะถูกส่งกลับไปยังไคลเอนต์

Marshalling และ Unmarshalling

เมื่อใดก็ตามที่ไคลเอ็นต์เรียกใช้เมธอดที่ยอมรับพารามิเตอร์บนวัตถุระยะไกลพารามิเตอร์จะรวมอยู่ในข้อความก่อนที่จะส่งผ่านเครือข่าย พารามิเตอร์เหล่านี้อาจเป็นประเภทดั้งเดิมหรือวัตถุ ในกรณีของชนิดดั้งเดิมพารามิเตอร์จะถูกรวมเข้าด้วยกันและแนบส่วนหัวเข้าด้วยกัน ในกรณีที่พารามิเตอร์เป็นอ็อบเจ็กต์พารามิเตอร์เหล่านั้นจะถูกทำให้เป็นอนุกรม กระบวนการนี้เรียกว่าmarshalling.

ที่ฝั่งเซิร์ฟเวอร์พารามิเตอร์ที่บรรจุจะถูกยกเลิกการรวมกลุ่มจากนั้นจึงเรียกวิธีการที่ต้องการ กระบวนการนี้เรียกว่าunmarshalling.

RMI Registry

RMI Registry เป็นเนมสเปซที่วางอ็อบเจ็กต์เซิร์ฟเวอร์ทั้งหมด ทุกครั้งที่เซิร์ฟเวอร์สร้างอ็อบเจ็กต์เซิร์ฟเวอร์จะลงทะเบียนอ็อบเจ็กต์นี้ด้วย RMIregistry (โดยใช้bind() หรือ reBind()วิธีการ) สิ่งเหล่านี้ได้รับการจดทะเบียนโดยใช้ชื่อเฉพาะที่เรียกว่าbind name.

ในการเรียกใช้วัตถุระยะไกลไคลเอนต์ต้องการการอ้างอิงของวัตถุนั้น ในเวลานั้นไคลเอนต์ดึงวัตถุจากรีจิสทรีโดยใช้ชื่อผูก (โดยใช้lookup() วิธี).

ภาพประกอบต่อไปนี้อธิบายกระบวนการทั้งหมด -

เป้าหมายของ RMI

ต่อไปนี้เป็นเป้าหมายของ 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 สร้างขึ้นในขั้นตอนก่อนหน้าและมีให้ body สำหรับวิธีนี้ซึ่งพิมพ์ข้อความ

// 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 ควรใช้อินเทอร์เฟซระยะไกลหรือขยายคลาสการนำไปใช้งาน ที่นี่เราควรสร้างวัตถุระยะไกลและเชื่อมโยงกับไฟล์RMIregistry.

เพื่อพัฒนาโปรแกรมเซิร์ฟเวอร์ -

สร้างคลาสไคลเอนต์จากตำแหน่งที่คุณต้องการเรียกใช้วัตถุระยะไกล
Create a remote object โดยการสร้างอินสแตนซ์คลาสการใช้งานตามที่แสดงด้านล่าง
ส่งออกวัตถุระยะไกลโดยใช้วิธีการ exportObject() ของคลาสชื่อ UnicastRemoteObject ซึ่งเป็นของแพ็คเกจ java.rmi.server.
รับรีจิสทรี RMI โดยใช้ไฟล์ getRegistry() วิธีการของ LocateRegistry คลาสซึ่งเป็นของแพ็คเกจ java.rmi.registry.
ผูกวัตถุระยะไกลที่สร้างขึ้นกับรีจิสทรีโดยใช้ไฟล์ bind() เมธอดของคลาสชื่อ Registry. สำหรับวิธีนี้ให้ส่งสตริงที่แสดงชื่อการผูกและอ็อบเจ็กต์ที่เอ็กซ์พอร์ตเป็นพารามิเตอร์

ต่อไปนี้เป็นตัวอย่างของโปรแกรมเซิร์ฟเวอร์ 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(); 
      } 
   } 
}

การพัฒนาโปรแกรมไคลเอ็นต์

เขียนโปรแกรมไคลเอนต์ดึงวัตถุระยะไกลและเรียกใช้วิธีการที่ต้องการโดยใช้วัตถุนี้

เพื่อพัฒนาโปรแกรมไคลเอนต์ -

สร้างคลาสไคลเอนต์จากจุดที่คุณตั้งใจจะเรียกใช้วัตถุระยะไกล
รับรีจิสทรี RMI โดยใช้ไฟล์ getRegistry() วิธีการของ LocateRegistry คลาสซึ่งเป็นของแพ็คเกจ java.rmi.registry.
ดึงวัตถุจากรีจิสทรีโดยใช้วิธีการ lookup() ของชั้นเรียน Registry ซึ่งเป็นของแพ็คเกจ java.rmi.registry.

ในวิธีนี้คุณต้องส่งค่าสตริงที่แสดงชื่อการผูกเป็นพารามิเตอร์ สิ่งนี้จะส่งคืนวัตถุระยะไกลให้คุณ
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

การใช้งานแอปพลิเคชัน

Step 1 - เริ่มไฟล์ rmi รีจิสทรีโดยใช้คำสั่งต่อไปนี้

start rmiregistry

สิ่งนี้จะเริ่มต้น rmi รีจิสทรีในหน้าต่างแยกต่างหากดังที่แสดงด้านล่าง

Step 2 - เรียกใช้ไฟล์คลาสเซิร์ฟเวอร์ดังที่แสดงด้านล่าง

Java Server

Step 3 - เรียกใช้ไฟล์คลาสไคลเอนต์ตามที่แสดงด้านล่าง

java Client

Verification - ทันทีที่คุณเริ่มไคลเอนต์คุณจะเห็นผลลัพธ์ต่อไปนี้ในเซิร์ฟเวอร์

ในบทที่แล้วเราได้สร้างแอปพลิเคชัน 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; 
}

การพัฒนาระดับการใช้งาน

ในคลาส Implementation (Remote Object) ของแอปพลิเคชันนี้เรากำลังพยายามสร้างหน้าต่างที่แสดงเนื้อหา GUI โดยใช้ JavaFX

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 ด้วยชื่อการผูกhello.

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 ของเรา

Step 1 - เปิดโฟลเดอร์ที่คุณเก็บโปรแกรมทั้งหมดและรวบรวมไฟล์ Java ทั้งหมดดังที่แสดงด้านล่าง

Javac *.java

Step 2 - เริ่มไฟล์ rmi รีจิสทรีโดยใช้คำสั่งต่อไปนี้

start rmiregistry

สิ่งนี้จะเริ่มต้น rmi รีจิสทรีในหน้าต่างแยกต่างหากดังที่แสดงด้านล่าง

Step 3 - เรียกใช้ไฟล์คลาสเซิร์ฟเวอร์ดังที่แสดงด้านล่าง

Java Server

Step 4 - เรียกใช้ไฟล์คลาสไคลเอนต์ตามที่แสดงด้านล่าง

java Client

ในบทก่อนหน้านี้เราได้สร้างแอปพลิเคชัน RMI ตัวอย่างที่ไคลเอนต์เรียกใช้เมธอดที่แสดงหน้าต่าง GUI (JavaFX)

ในบทนี้เราจะนำตัวอย่างเพื่อดูว่าโปรแกรมไคลเอนต์สามารถดึงข้อมูลของตารางในฐานข้อมูล MySQL ที่อยู่บนเซิร์ฟเวอร์ได้อย่างไร

สมมติว่าเรามีตารางชื่อ student_data ในฐานข้อมูล details ดังแสดงด้านล่าง

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

การพัฒนาระดับการใช้งาน

สร้างคลาสและใช้สิ่งที่สร้างไว้ข้างต้น interface.

ที่นี่เรากำลังใช้งานไฟล์ getStudents() วิธีการของ Remote interface. เมื่อคุณเรียกใช้เมธอดนี้ระบบจะดึงข้อมูลของตารางที่มีชื่อว่าstudent_data. ตั้งค่าเหล่านี้เป็นคลาส Student โดยใช้เมธอด setter เพิ่มลงใน list object และส่งกลับรายการนั้น

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

โปรแกรมเซิร์ฟเวอร์

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