RPC
RPC 遠程過程調用可以說是分布式系統的基礎，本文將通過 Java 演示一次普通的 rpc 調用到底發(fā)生了什么。
咸魚君曾經在網上看到有人提問，為什么 RPC 要叫作遠程過程調用，而不叫作 RMC 遠程方法調用。但咸魚君為 RPC 的叫法才是合理的，遠程調用的是某個過程，不一定是一個具體的方法。（你只要看過后面第一個版本的代碼就能懂了）
這整個過程可以用一句話概括：機器 A 通過網絡與機器B建立連接，A 發(fā)送一些參數給 B，B 執(zhí)行某個過程，并把結果返回給 A。
在寫代碼之前，先說一個前置背景，假設我們有一個商品類
public class Product implements Serializable {
private Integer id;
private String name;
?
public Product(Integer id, String name) {
this.id = id;
this.name = name;
}
?
//toString()
//get set 方法
}
有一個商品服務接口
public interface IProductService {
Product getProductById(Integer id);
}
服務端有商品服務接口的實現類
public class ProductServiceImpl implements IProductService {
@Override
public Product getProductById(Integer id) {
//實際上這里應該去查詢數據庫獲得數據，下面簡化了
return new Product(id, "手機");
}
}
下面我們通過客戶端發(fā)送一個商品 id 到服務端，服務端獲得 id 后通過商品服務類獲取商品信息，返回給客戶端
public class Client {
?
public static void main(String[] args) throws Exception {
//建立Socket
Socket socket = new Socket("127.0.0.1", 8888);
//獲取輸出流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
//把商品Id通過網絡傳到服務端
dos.writeInt(123);
?
socket.getOutputStream().write(baos.toByteArray());
socket.getOutputStream().flush();
?
//讀取服務端返回的商品信息
DataInputStream dis = new DataInputStream(socket.getInputStream());
Integer id = dis.readInt(); //商品id
String name = dis.readUTF(); //商品名稱
Product product = new Product(id, name);//通過服務端返回的商品信息生成商品
?
System.out.println(product);
//關閉流資源為了方便閱讀，沒有做try-catch處理
dos.close();
baos.close();
socket.close();
}
}
?
public class Server {
private static boolean running = true;
?
public static void main(String[] args) throws Exception {
//建立服務端Socket
ServerSocket ss = new ServerSocket(8888);
//不斷監(jiān)聽，處理客戶端請求
while (running) {
Socket socket = ss.accept();
process(socket);
socket.close();
}
ss.close();
}
?
private static void process(Socket socket) throws Exception {
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
DataInputStream dis = new DataInputStream(is);
DataOutputStream dos = new DataOutputStream(os);
?
//讀取客戶端發(fā)過來的id
Integer id = dis.readInt();
//調用服務類生成商品
IProductService service = new ProductServiceImpl();
Product product = service.getProductById(id);
//把商品的信息寫回給客戶端
dos.writeInt(id);
dos.writeUTF(product.getName());
dos.flush();
?
dos.close();
dis.close();
os.close();
is.close();
}
}
上面的是 RPC 遠程調用的原始簡易版本，可以看到聯網的代碼寫死在了客戶端中，網絡部分代碼和getProductById()耦合在了一起，如果想把別的方法改為遠程調用還要重新寫一遍聯網的代碼，非常麻煩。
在實際的使用中，我們會編寫各種各樣的遠程調用，打個比方，IProductService接口以后可能會擴展成這樣：
public interface IProductService {
?
Product getProductById(Integer id);
Product getProductByName(String name);
Product getMostExpensiveProduct();
}
我們總不可能為每個方法都編寫一段網絡連接的代碼吧，我們得想到一種辦法為所有的方法都嵌入一段共用的網絡連接代碼。
那具體應該怎樣嵌入呢？這里我們可以用到代理模式。
在 Java 中許多優(yōu)秀的框架都用到了代理模式做代碼嵌入，比如說 Mybatis。它把 JDBC 連接部分的代碼通過代理模式嵌入到 sql 語句的周圍，讓我們專注于寫 sql。
首先，服務端的代碼要進行修改，由于多個方法共用一套聯網的代碼，我們要在服務端識別調用的是哪一個方法：
public class Server {
?
private static boolean running = true;
?
public static void main(String[] args) throws Exception {
//......
}
?
private static void process(Socket socket) throws Exception {
//獲取輸入流，輸出流
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
ObjectInputStream ois = new ObjectInputStream(is);
ObjectOutputStream oos = new ObjectOutputStream(os);
//獲取本次遠程調用的方法名
String methodName = ois.readUTF();
//獲取本次遠程調用方法的參數類型
Class[] parameterTypes = (Class[]) ois.readObject();
//獲取具體的參數對象
Object[] args = (Object[]) ois.readObject();
//創(chuàng)建商品服務類實例，（往后這里可以繼續(xù)優(yōu)化）
IProductService service = new ProductServiceImpl();
//根據遠程獲取的方法名和參數，調用相應的方法
Method method = service.getClass().getMethod(methodName, parameterTypes);
Product product = (Product) method.invoke(service, args);
//把結果寫回給客戶端
oos.writeObject(product);
?
oos.close();
ois.close();
socket.close();
}
}
然后在客戶端，我們創(chuàng)建一個新的代理類，對外提供一個 getStub 獲取代理類的方法。使用 JDK 的動態(tài)代理需要三個參數，一個是類加載器，一個是接口的 class 類，最后一個是InvocationHandler實例。
JDK 動態(tài)代理背后的邏輯是這樣的：JVM 會根據接口的 class 類動態(tài)創(chuàng)建一個代理類對象，這個代理對象實現了傳入的接口，也就是說它擁有了接口中所有方法的實現。方法具體的實現可以由用戶指定，也就是調用InvocationHandler的invoke方法。
在
invoke方法中有三個參數，分別是proxy代理類，method調用的方法，args調用方法的參數。我們可以在invoke方法中對具體的實現方法進行增強，在本案例中就是進行網絡調用。
public class Stub {
?
public static IProductService getStub() {
?
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//和服務端建立Socket連接
Socket socket = new Socket("127.0.0.1", 8888);
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
//拿到遠程調用的方法名
String methodName = method.getName();
//拿到遠程調用方法的參數類型
Class[] parametersTypes = method.getParameterTypes();
//把方法名傳遞給服務端
oos.writeUTF(methodName);
//把方法參數類型傳遞給服務端
oos.writeObject(parametersTypes);
//把方法參數傳遞給服務端
oos.writeObject(args);
oos.flush();
//獲取遠程調用的返回結果
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Product product = (Product) ois.readObject();
?
ois.close();
oos.close();
socket.close();
return product;
}
};
Object o = Proxy.newProxyInstance(IProductService.class.getClassLoader(), new Class[]{IProductService.class}, h);
return (IProductService) o;
}
}
這個新版本比第一個版本又美好了一些，但是其實還可以繼續(xù)優(yōu)化。現在我們的代理只能夠返回IProductService的實現類，得想辦法讓它返回任意類型的服務實現類。
思路和遠程調用方法相似，在遠程調用方法時，我們把方法的名稱，參數類型，參數傳遞給服務端；現在要動態(tài)創(chuàng)建服務類，我們可以把服務接口的名字傳給服務端。服務端拿到遠程接口的名字后，就可以從服務注冊表中找到對應服務實現類。
至于服務實現類如何注冊到服務注冊表，這里提供一個思路：可以考慮使用 Spring 的注解注入。這和我們平時寫 spring 代碼是相似的，在創(chuàng)建完服務實現類后我們會加上注解 @Service，這樣我們就可以在收到遠程調用后，遍歷使用了 @Service的Bean，找到對應的實現類。
總結
如果想要搭建一個簡易的RPC框架，有4個點：
- 代理問題
- 服務實例化問題
- 序列化問題
- 通信問題
本篇文章的側重點是前兩個，代理問題和服務實例化問題，我們回顧一下：
- 首先通過代理模式解決了每個遠程方法聯網的問題
- 通過傳遞方法名，方法參數類型，參數，以及后面提及的直接傳接口名字的形式解決服務實例化問題，這背后的原理是反射，傳這些參數也是給反射用的。
關于另外兩個點的延伸
在網絡上傳輸數據避免不了序列化問題。Java 自帶的序列化方式效率比較低，如果要造一個 RPC 框架的話，我們可以考慮引入其他第三方的序列化框架。
通信問題也很重要，現有的 RPC 框架使用的通信協議也不相同，各有各的優(yōu)缺點。但這部分手動實現可能比較困難，可以根據語言自身封裝好的 API 進行選擇。
