分佈式通訊框架 - rmi

時間 2019-12-05

原文原文鏈接

知識點：

1）什麼是rmi
2）簡單的實現rmi
3）rmi原理
4）手寫rmi框架java

首先談下什麼RPC？

Remote procedure call protocal 遠程過程調用協議
不用知道具體細節，調用遠程系統中類的方法，就跟調用本地方法同樣。
RPC協議實際上是一種規範。
包括Dubbo，Thrift，rmi，webservice，hessainweb

網絡協議和網絡IO對於調用端和服務端來講是透明的。安全

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

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：註冊所，提供了服務名到服務的映射。socket

結合這上面的圖，再以上面的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的對象ide

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);
	}
}
複製代碼