分散式通訊框架 - rmi

摘要： 1）什麼是rmi 2）簡單的實現rmi 3）rmi原理 4）手寫rmi框架 首先談下什麼RPC？ Remote procedure call protocal 遠端過程呼叫協議 不用知道具體細節，呼叫遠端系統中類的方法，就跟呼叫本地方法一樣。 RPC協議其實是一種規...

1）什麼是rmi

2）簡單的實現rmi

3）rmi原理

4）手寫rmi框架

首先談下什麼RPC？

Remote procedure call protocal 遠端過程呼叫協議

不用知道具體細節，呼叫遠端系統中類的方法，就跟呼叫本地方法一樣。

RPC協議其實是一種規範。

包括Dubbo，Thrift，rmi，webservice，hessain

網路協議和網路IO對於呼叫端和服務端來說是透明的。

一個RPC框架應該包含的要素：

RMI概述

rmi（remote method invocation） 遠端方法呼叫

可以認為是RPC的java版本

RMI使用的是JRMP（JAVA Remote Messageing Protocol），可以說JRMP是專門為java定製的通訊協議，所以它是純java的分散式解決方案。

怎麼實現一個RMI程式

1）建立遠端介面並且繼承java.rmi.Remote 介面

package com.llf.rmidemo;

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

public interface SayHello extends Remote{
public String sayHello(String name)throws RemoteException;
}
複製程式碼

2）實現我們這個遠端介面並且繼承 UnicastRemoteObject

package com.llf.rmidemo;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class SayHelloImpl extends UnicastRemoteObject implements SayHello{

protected SayHelloImpl() throws RemoteException {
}

@Override
public String sayHello(String name) throws RemoteException {
return "Hello LLF -->"+name;
}

}
複製程式碼

3）建立伺服器程式 呼叫createRegistry方法註冊遠端物件

package com.llf.rmidemo;

import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class HelloServer {
public static void main(String[] args) {
try {
SayHello hello=new SayHelloImpl();
LocateRegistry.createRegistry(8888);
try {
Naming.bind("rmi://localhost:8888/sayhello", hello);
System.out.println("Server start success!");
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
} catch (RemoteException e) {
e.printStackTrace();
}
}

}
複製程式碼

4）建立客戶端程式

package com.llf.rmidemo;

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class HelloClient {
public static void main(String[] args) {
try {
SayHello hello=(SayHello) Naming.lookup("rmi://localhost:8888/sayhello");
System.out.println(hello.sayHello("FXP"));
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (NotBoundException e) {
e.printStackTrace();
}
}

}
複製程式碼

結果：

自己去實現一個RMI

1）編寫伺服器程式，暴露監聽，可以使用socket 2）編寫客戶端程式，通過IP和埠連線到指定的服務，並且把我們的資料做封裝（序列化） 3）伺服器端收到請求先反序列化在進行業務邏輯處理，把返回結果序列化返回

rmi框架呼叫時序圖

rmi原始碼分析

我們近乎的可以以如下的圖來理解： a） stub和skeleton這倆個身份都是作為代理存在，客戶端的稱為stub，服務端的稱為skeleton，通過這倆個物件遮蔽了遠端方法呼叫的具體細節，這倆個是必不可少的。 b）Registry：註冊所，提供了服務名到服務的對映。

結合這上面的圖，再以上面的demo程式碼，我們來扒一扒rmi的底層原始碼 首先我們看提供服務的server方 createRegistry方法

服務端先建立了一個RegistryImpl的物件，然後做了一個安全校驗，這邊我們不用關注，重點是看setup方法。

進入到RegistryImpl類

然後進入到UnicastServerRef的exportObject方法 1）首先為傳入的RegistryImpl建立一個代理物件stub 2）把UnicastServerRef的skeleton物件設定為當前RegistryImpl物件 3）skeleton，stub，unicastserverRef物件，id和一個boolean構造了一個target物件

再往下追就是export的exportObject方法

主要是呼叫listen方法建立一個serversocket，啟動一條執行緒等待客戶端請求。 至此為止我們的服務端已經起了服務等待客戶端連線了。

客戶端

這邊其實就是建立一個stub的代理物件

用程式碼來模擬RMI底層過程如下： 新建一個User的物件

package com.llf.rmi;

public class User {

private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}
複製程式碼

編寫一個Skeleton類供客戶端呼叫【這塊是rmi定義出來遮蔽底層序列化及流連線的，這邊模擬寫了下底層的序列化及流】

package com.llf.rmi;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

//server程式
public class User_Skeleton extends Thread {

private UserServer userServer;

public User_Skeleton(UserServer userServer) {
this.userServer = userServer;

}

public void run() {
ServerSocket serverSocket = null;
ObjectInputStream read = null;
ObjectOutputStream oos = null;
Socket socket=null;
try {
serverSocket = new ServerSocket(8888);
socket = serverSocket.accept();
while (socket != null) {
read = new ObjectInputStream(socket.getInputStream());
String method = (String) read.readObject();
if (method.equals("age")) {
int age = userServer.getAge();
oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeInt(age);
oos.flush();
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (serverSocket != null) {
try {
oos.close();
read.close();
socket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
複製程式碼

寫一個stub

package com.llf.rmi;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class User_Stub extends User {
private Socket socket;

public User_Stub() {
try {
socket=new Socket("localhost", 8888);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public int getAge(){
ObjectOutputStream oos=null;
ObjectInputStream ois=null;
try {
oos=new ObjectOutputStream(socket.getOutputStream());
oos.writeObject("age");
oos.flush();

ois=new ObjectInputStream(socket.getInputStream());
return ois.readInt();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
ois.close();
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
return 0;
}

}
複製程式碼

編寫伺服器程式碼

package com.llf.rmi;

public class UserServer extends User{
public static void main(String[] args) {
UserServer server=new UserServer();
server.setAge(18);
//模擬rmi生成的skeleton代理物件
User_Skeleton user_Skeleton=new User_Skeleton(server);
user_Skeleton.start();

}
}
複製程式碼

編寫客戶端程式碼

package com.llf.rmi;

public class UserClient {
public static void main(String[] args) {
User user=new User_Stub();
int age=user.getAge();
System.out.println(age);
}
}
複製程式碼