Home-theater-designers
RMI หมายถึง การเรียกใช้เมธอดระยะไกล และตามชื่อที่ระบุ เป็นโปรโตคอลสำหรับโปรแกรม Java เพื่อเรียกใช้เมธอดของอ็อบเจ็กต์ที่ทำงานบนคอมพิวเตอร์เครื่องอื่น มันมี API (Application Programming Interface) สำหรับการส่งออกวัตถุจากโปรแกรมหนึ่ง (เรียกว่าเซิร์ฟเวอร์) และเรียกใช้วิธีการของวัตถุนั้นจากโปรแกรมอื่น (เรียกว่าไคลเอนต์) อาจทำงานบนคอมพิวเตอร์เครื่องอื่น
ชวา RMI Registry เป็นองค์ประกอบสำคัญของระบบ Java RMI และจัดเตรียมไดเร็กทอรีส่วนกลางสำหรับเซิร์ฟเวอร์เพื่อลงทะเบียนบริการ และสำหรับลูกค้าเพื่อค้นหาบริการเหล่านี้ ในบทความนี้ เราเรียนรู้วิธีใช้งานเซิร์ฟเวอร์เพื่อแสดงออบเจ็กต์และไคลเอนต์เพื่อเรียกใช้เมธอดบนเซิร์ฟเวอร์ ตลอดจนการลงทะเบียนและค้นหาบริการใน RMI Registry
วิธีบล็อกหมายเลขของคุณเมื่อโทรบน Android
ประกาศอินเทอร์เฟซเซิร์ฟเวอร์
หากต้องการเรียนรู้ความสลับซับซ้อนของวิธีการทำงานของระบบ Java RMI ให้เรานำวัตถุเซิร์ฟเวอร์อย่างง่ายมาใช้เพื่อระบุวิธีการยอมรับชื่อและส่งคืนคำทักทาย นี่คือคำจำกัดความของอินเทอร์เฟซของวัตถุ:
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Greeting extends Remote
{
public String greet(String name) throws RemoteException;
}
ชื่อของอินเทอร์เฟซถูกเรียกว่า การทักทาย . มันมีวิธีการเดียวที่เรียกว่า ทักทาย() ซึ่งรับชื่อและส่งกลับคำทักทายที่เหมาะสม
ในการทำเครื่องหมายอินเทอร์เฟซนี้ว่าส่งออกได้ จำเป็นต้องขยาย java.rmi.Remote อินเตอร์เฟซ. วิธีการยังต้องประกาศ a ขว้าง รายการข้อ java.rmi.RemoteException นอกเหนือจากข้อยกเว้นเฉพาะแอปพลิเคชัน นี่คือเพื่อให้รหัสไคลเอ็นต์สามารถจัดการ (หรือเผยแพร่) ข้อผิดพลาดในการเรียกใช้เมธอดระยะไกลเช่น ไม่พบโฮสต์ , การเชื่อมต่อล้มเหลว ฯลฯ
การใช้วัตถุเซิร์ฟเวอร์
หลังจากประกาศอินเทอร์เฟซ (ซึ่งใช้โดยไคลเอ็นต์) เราจะใช้อ็อบเจ็กต์ฝั่งเซิร์ฟเวอร์และจัดเตรียม ทักทาย() วิธีการตามที่แสดง ใช้สตริงรูปแบบอย่างง่ายเพื่อจัดรูปแบบคำทักทาย
public class GreetingObject implements Greeting
{
private String fmtString = 'Hello, %s';
public String greet(String name)
{
return String.format(this.fmtString, name);
}
}
วิธีหลักของเซิร์ฟเวอร์
ให้เราเปรียบเทียบชิ้นส่วนเหล่านี้ทั้งหมดเข้าด้วยกันและนำ หลัก() วิธีการของเซิร์ฟเวอร์ ให้เราผ่านแต่ละขั้นตอนที่เกี่ยวข้องกัน
- ขั้นตอนแรกคือการสร้างการใช้งานวัตถุเซิร์ฟเวอร์ |_+_|
- ต่อไป เราได้รับต้นขั้วสำหรับวัตถุเซิร์ฟเวอร์จากรันไทม์ RMI ต้นขั้วใช้อินเทอร์เฟซเดียวกันกับวัตถุเซิร์ฟเวอร์ อย่างไรก็ตาม วิธีการนี้ใช้การสื่อสารที่จำเป็นกับวัตถุเซิร์ฟเวอร์ระยะไกล ไคลเอนต์ใช้ต้นขั้วนี้เพื่อเรียกใช้เมธอดบนวัตถุเซิร์ฟเวอร์อย่างโปร่งใส |_+_|
- เมื่อได้ต้นขั้วแล้ว เราจะมอบต้นขั้วนี้ให้กับรีจิสทรี RMI เพื่อผูกกับบริการที่ระบุชื่อ เมื่อไคลเอนต์ร้องขอการใช้งานบริการนี้ จะได้รับต้นขั้วที่รู้วิธีการสื่อสารกับวัตถุเซิร์ฟเวอร์ ต่อไปนี้ วิธีคงที่ LocateRegistry.getRegistry () ใช้เพื่อขอรับการอ้างอิงรีจิสตรีท้องถิ่น NS ผูก () แล้วใช้วิธีผูกชื่อกับต้นขั้ว |_+_|
วิธีการหลักที่สมบูรณ์
Greeting greeting = new GreetingObject();
การสร้างเซิร์ฟเวอร์
ให้เรามาดูการสร้างเซิร์ฟเวอร์กัน เพื่อให้ง่ายขึ้น เราสร้างโดยใช้บรรทัดคำสั่งบน Linux แทนที่จะใช้เครื่องมือสร้าง เช่น Maven
ต่อไปนี้จะรวบรวมไฟล์ต้นทางไปยังไฟล์คลาสในไดเร็กทอรีเป้าหมาย
Greeting stub = (Greeting)UnicastRemoteObject.exportObject(greeting, 0);
รวบรวมไฟล์คลาสลงในไฟล์ JAR เพื่อดำเนินการ
String name = 'Greeting';
Registry registry = LocateRegistry.getRegistry(port);
registry.rebind(name, stub);
เรายังรวบรวมไฟล์อินเตอร์เฟสที่จำเป็นสำหรับการคอมไพล์ไคลเอ็นต์ลงในไลบรารี JAR
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class Main
{
static public void main(String[] args) throws Exception
{
if ( args.length == 0 ) {
System.err.println('usage: java Main port#');
System.exit(1);
}
int index = 0;
int port = Integer.parseInt(args[index++]);
String name = 'Greeting';
Greeting greeting = new GreetingObject();
Greeting stub = (Greeting)UnicastRemoteObject.exportObject(greeting, 0);
Registry registry = LocateRegistry.getRegistry(port);
registry.rebind(name, stub);
System.out.println('Greeting bound to '' + name + ''');
}
}
การดำเนินการของลูกค้า
ให้เรามาดูการใช้งานไคลเอนต์ที่ใช้สำหรับการเรียกใช้เมธอดของเซิร์ฟเวอร์
- เช่นเดียวกับเซิร์ฟเวอร์ ให้อ้างอิงถึงรีจิสทรี ระบุชื่อโฮสต์ที่รีจิสทรีทำงาน และหมายเลขพอร์ต |_+_|
- ถัดไป ค้นหาบริการในรีจิสทรี NS ค้นหา () method ส่งคืน stub ที่สามารถใช้สำหรับเรียกใช้บริการได้ |_+_|
- และเรียกใช้วิธีการส่งผ่านอาร์กิวเมนต์ที่ต้องการ ที่นี่เราได้รับคำทักทายโดยส่งชื่อและพิมพ์ออกมา |_+_|
รหัสลูกค้าที่สมบูรณ์:
rm -rf target
mkdir target
javac -d target src/server/*.java
RMI Registry
ให้เราเรียกใช้โปรแกรมเซิร์ฟเวอร์เพื่อให้สามารถเริ่มให้บริการตามคำขอได้
jar cvf target/rmi-server.jar -C target server
คืออะไร ข้อยกเว้นนี้ ? การเชื่อมต่อถูกปฏิเสธ .
เหตุผลที่คุณได้รับข้อยกเว้นนี้เป็นเพราะ: หมายเหตุจากรหัสเซิร์ฟเวอร์ที่พยายามเชื่อมต่อกับรีจิสตรีท้องถิ่นบนพอร์ต 1099 หากไม่สำเร็จ คุณจะได้รับข้อยกเว้นนี้
วิธีแก้ไขคือเรียกใช้ RMI Registry RMI Registry เป็นโปรแกรมที่มาพร้อมกับ Java Virtual Machine และเรียกว่า rmiregistry . ควรอยู่ใน เป็น ไดเร็กทอรีของการติดตั้ง Java Virtual Machine การวิ่งนั้นง่ายเหมือน:
jar cvf target/rmi-lib.jar -C target server/Greeting.class
โดยค่าเริ่มต้น รีจิสทรีจะรับฟังที่พอร์ต 1099 หากต้องการให้รับข้อมูลบนพอร์ตอื่น ให้ระบุหมายเลขพอร์ตดังนี้:
Registry registry = LocateRegistry.getRegistry(host, port);
ตรวจสอบว่ามีผู้ฟังที่พอร์ตที่ระบุด้วย คำสั่ง netstat :
เกมสนุกที่จะเล่นผ่านข้อความ
Greeting greeting = (Greeting) registry.lookup(name);
การรันเซิร์ฟเวอร์
ให้เราลองเรียกใช้เซิร์ฟเวอร์อีกครั้ง
System.out.println(name + ' reported: ' + greeting.greet(myName));
ข้อยกเว้นอีกครั้ง! คราวนี้อะไรอีกล่ะ?
เซิร์ฟเวอร์ไม่สามารถโหลดคลาสอินเตอร์เฟส เซิร์ฟเวอร์ทักทาย . สิ่งนี้เกิดขึ้นเนื่องจาก RMI Registry ไม่สามารถโหลดคลาสที่ต้องการได้ ดังนั้นคุณต้องระบุตำแหน่งของคลาสที่ต้องการ วิธีหนึ่งที่จะทำคือระบุตัวแปรสภาพแวดล้อม CLASSPATH:
package client;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import server.Greeting;
public class Client
{
static public void main(String[] args) throws Exception
{
if ( args.length != 3 ) {
System.err.println('usage: java Client host port myName');
System.exit(1);
}
int index = 0;
String host = args[index++];
int port = Integer.parseInt(args[index++]);
String myName = args[index++];
String name = 'Greeting';
Registry registry = LocateRegistry.getRegistry(host, port);
Greeting greeting = (Greeting) registry.lookup(name);
System.out.println(name + ' reported: ' + greeting.greet(myName));
}
}
การพยายามเรียกใช้เซิร์ฟเวอร์อีกครั้งทำให้:
java -cp target/rmi-server.jar server.Main 1099
# throws
Exception in thread 'main' java.rmi.ConnectException: Connection refused to host: xxx; nested exception is:
java.net.ConnectException: Connection refused
ตอนนี้เซิร์ฟเวอร์กำลังทำงาน
เรียกใช้ไคลเอนต์
หลังจากที่ประกอบและดำเนินการชิ้นส่วนทั้งหมดแล้ว การเรียกใช้ไคลเอ็นต์ก็เป็นเรื่องง่าย ต้องใช้ JAR ที่เหมาะสมสำหรับการดำเนินการ ซึ่งรวมถึงชั้นเรียนที่มี หลัก() เมธอดและคลาสอินเตอร์เฟส ยอมรับอาร์กิวเมนต์ที่ระบุตำแหน่งที่รีจิสตรี RMI กำลังทำงาน และชื่อสำหรับคำทักทาย
/usr/lib/jvm/jdk1.8.0_71/bin/rmiregistry
สรุป
Java RMI จัดเตรียม API และเครื่องมือต่างๆ เพื่อทำให้การเรียกใช้โค้ดจากระยะไกลง่ายขึ้น คุณสามารถใช้เซิร์ฟเวอร์ที่ลงทะเบียนอ็อบเจ็กต์บริการกับ Java RMI Registry ลูกค้าสามารถสอบถามรีจิสทรีและรับต้นขั้ววัตถุบริการเพื่อเรียกใช้วิธีการบริการ ดังที่ตัวอย่างนี้แสดงให้เห็น ทุกอย่างค่อนข้างง่าย
คุณใช้ Java RMI ในโครงการของคุณหรือไม่? ประสบการณ์ของคุณเป็นอย่างไร? มีทางเลือกอื่นที่คุณได้ตรวจสอบหรือไม่? โปรดแจ้งให้เราทราบในความคิดเห็นด้านล่าง
แบ่งปัน แบ่งปัน ทวีต อีเมล คู่มือสำหรับผู้เริ่มต้นในการพูดแบบเคลื่อนไหวการพูดแบบเคลื่อนไหวอาจเป็นเรื่องท้าทาย หากคุณพร้อมที่จะเริ่มเพิ่มบทสนทนาในโครงการของคุณ เราจะแบ่งขั้นตอนให้คุณ
อ่านต่อไป หัวข้อที่เกี่ยวข้อง- การเขียนโปรแกรม
- Java
สมัครรับจดหมายข่าวของเรา
เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!
คลิกที่นี่เพื่อสมัครสมาชิก