十分鐘寫個RPC框架

東隼發表於2016-12-12

網際網路時代，各種RPC框架盛行，細看各種框架，應用層面有各種變化，但是萬變不離其宗，RPC最核心的部分基本都是一致的。
那就是跟遠端的伺服器進行通訊，像呼叫本地服務一樣呼叫遠端服務。
然後在這些基礎上可能會附加一些諸如，服務自動註冊和發現，負載均衡，就近路由，呼叫鏈路記錄，遠端mock等等功能。
今天想給大家分享的是，如果不考慮效能，API易用性，服務發現，負載均衡，環境隔離等其他因素，其實做一個基本功能的RPC框架，幾分鐘就能搞定。
個人認為RPC功能的基石有下面幾個一、序列化協議二、遠端通訊報文協議三、協議報文處理實現。
序列化協議JDK為我們提供了一套自帶的序列化協議，雖然不能跨語言，壓縮率不高，不過我們只為展示RPC技術，沒有考慮其他，如果覺得不好可以使用Hessian ,protobuf,甚至是諸如fastjson這些json序列化的開源框架。
遠端通訊JDK有一套socket和輸入輸出流，雖然是同步的，效能不怎麼樣，但是隻為展示RPC技術原理，不考慮其他，為了效能和吞吐量我們可以選擇netty進行改造。
通訊協議，我只做了一個簡單的 MAGIC_NUM+兩個位元組報文長+序列化物件位元組流的協議，協議上可以增加很多東西，比如版本號，心跳包，狀態碼，可擴充套件的報文頭等等，不過同樣的，這裡只為展示RPC原理，不考慮其他的。
協議報文處理部分只是通過報文體裡面攜帶的類名方法名，方法引數，做了個簡單的反射處理，這部分其實可以擴充套件的部分很多，比如預先做方法快取，方法簽名使用短命名註冊等等，或者想更快還能通過位元組碼注入的方式自動生成一些模板程式碼的方式，將反射變成直接的方法呼叫。

下面直接展示程式碼吧
首先是傳輸的物件都是java可序列化物件：

public class RpcCommand implements Serializable{
    String className ;
    String methodName ;
    String[] argumetsType ;

    Object[] params ;
    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public String[] getArgumetsType() {
        return argumetsType;
    }

    public void setArgumetsType(String[] argumetsType) {
        this.argumetsType = argumetsType;
    }

    public Object[] getParams() {
        return params;
    }

    public void setParams(Object[] params) {
        this.params = params;
    }


}
public class RpcResponse implements Serializable{
    boolean isException;
    Object result ;
    Exception exception;
    public boolean isException() {
        return isException;
    }

    public void setException(boolean exception) {
        isException = exception;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

    public Exception getException() {
        return exception;
    }

    public void setException(Exception exception) {
        this.exception = exception;
    }

}

其次是請求物件的處理部分

package com.shock.rpc;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ${DESCRIPTION}
 * com.shock.rpc.${CLASS_NAME}
 * Created by zhengdong.lzd on 2016/11/29 0029.
 */
public class RpcHandler {

    ConcurrentHashMap<String, Object> registered = new ConcurrentHashMap<String, Object>(128);

    public RpcResponse handler(RpcCommand commond) {
        String className = commond.getClassName();
        RpcResponse response = new RpcResponse();
        try {
            Object obj = registered.get(className);
            String[] argTypes = commond.getArgumetsType();
            Class aClass = Class.forName(className);
            List<Class> argsTypeList = new ArrayList<Class>(argTypes.length);
            for (String s : argTypes) {
                argsTypeList.add(Class.forName(s));
            }
            Method method = aClass.getMethod(commond.getMethodName(),
                argsTypeList.toArray(new Class[argsTypeList.size()]));
            Object object = method.invoke(obj, commond.getParams());
            response.setResult(object);
        } catch (Exception e) {
            e.printStackTrace();
            response.setException(true);
            response.setException(e);
        }
        return response;
    }

    public void regist(Class interfa, Object object) {
        registered.put(interfa.getName(), object);
    }
}

程式碼裡面只有很粗暴的反射實現

第三個是服務端啟動和服務端協議處理程式碼

package com.shock.rpc;

import com.shock.rpc.demo.IDemoImpl;
import com.shock.rpc.demo.IDemoInterface;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * ${DESCRIPTION}
 * com.shock.rpc.${CLASS_NAME}
 * Created by zhengdong.lzd on 2016/11/29 0029.
 */
public class RpcServer {
    int port;

    public RpcServer(int port, RpcHandler handler) {
        this.port = port;
        this.handler = handler;
    }

    RpcHandler      handler;

    ExecutorService executorService = Executors.newFixedThreadPool(20);

    public void start() {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                Socket socket = serverSocket.accept();
                executorService.submit(new WorkThread(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public class WorkThread implements Runnable {
        Socket socket;

        WorkThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                InputStream inputStream = socket.getInputStream();
                OutputStream outputStream = socket.getOutputStream();
                while (true) {
                    int magic = inputStream.read();
                    //魔數
                    if (magic == 0x5A) {
                        //兩個位元組用來計算長度資料長度，服務傳送的資料過大可能會出現截斷問題
                        int length1 = inputStream.read();
                        int length2 = inputStream.read();
                        int length = (length1 << 8) + length2;
                        ByteArrayOutputStream bout = new ByteArrayOutputStream(length);
                        int sum = 0;
                        byte[] bs = new byte[length];
                        while (true) {
                            int readLength = inputStream.read(bs, 0, length - sum);
                            if (readLength > 0) {
                                bout.write(bs, 0, readLength);
                                sum += readLength;
                            }
                            if (sum >= length) {
                                break;
                            }
                        }
                        ObjectInputStream objectInputStream = new ObjectInputStream(
                            new ByteArrayInputStream(bout.toByteArray()));
                        try {
                            RpcCommand commond = (RpcCommand) objectInputStream.readObject();
                            RpcResponse response = handler.handler(commond);
                            ByteArrayOutputStream objectout = new ByteArrayOutputStream(length);
                            ObjectOutputStream objectOutputStream = new ObjectOutputStream(objectout);
                            objectOutputStream.writeObject(response);
                            objectOutputStream.flush();
                            byte[] commondBytes = objectout.toByteArray();
                            int len = commondBytes.length;
                            outputStream.write(0x5A);
                            outputStream.write(len >> 8);
                            outputStream.write(len & 0x00FF);
                            outputStream.write(commondBytes);
                            outputStream.flush();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("和客戶端連線斷開了");
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        RpcHandler rpcHandler = new RpcHandler();
        rpcHandler.regist(IDemoInterface.class, new IDemoImpl());
        RpcServer servcer = new RpcServer(8081, rpcHandler);
        servcer.start();
    }
}

程式碼實現也很簡單，就是根據前面說的傳輸報文協議讀取傳輸的報文，反序列化出請求物件RpcCommand，給處理類進行處理，如果做好相容加上版本和不同協議的話，可以增加不同的處理實現。

最後是客戶端傳輸和協議處理程式碼

package com.shock.rpc;

import com.shock.rpc.demo.IDemoInterface;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * ${DESCRIPTION}
 * com.shock.rpc.${CLASS_NAME}
 * Created by zhengdong.lzd on 2016/11/29 0029.
 */
public class RpcClient {

    String       host;
    int          port;
    Socket       socket;
    InputStream  inputStream;
    OutputStream outputStream;

    public RpcClient(String host, int port) {
        try {
            socket = new Socket();
            socket.connect(new InetSocketAddress(host, port));
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //這個不能併發請求，否則會出現資料流亂的情況
    public synchronized RpcResponse invoke(RpcCommand commond) {
        RpcResponse response = new RpcResponse();
        try {
            ByteArrayOutputStream objectout = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(objectout);
            objectOutputStream.writeObject(commond);
            objectOutputStream.flush();
            byte[] commondBytes = objectout.toByteArray();
            outputStream.write(0x5A);
            int len = commondBytes.length;

            outputStream.write(len >> 8);
            outputStream.write(0x00FF & len);
            outputStream.write(commondBytes);
            outputStream.flush();
            while (true) {
                int magic = inputStream.read();
                if (magic == 0x5A) {
                    int length1 = inputStream.read();
                    int length2 = inputStream.read();
                    int length = (length1 << 8) + length2;
                    ByteArrayOutputStream bout = new ByteArrayOutputStream(length);
                    int sum = 0;
                    byte[] bs = new byte[length];
                    while (true) {
                        int readLength = inputStream.read(bs, 0, length - sum);
                        if (readLength > 0) {
                            bout.write(bs, 0, readLength);
                            sum += readLength;
                        }
                        if (sum >= length) {
                            break;
                        }
                    }
                    ObjectInputStream objectInputStream = new ObjectInputStream(
                        new ByteArrayInputStream(bout.toByteArray()));
                    RpcResponse response1 = (RpcResponse) objectInputStream.readObject();
                    return response1;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return response;
    }

    public static void main(String[] args) {
        RpcClient client = new RpcClient("localhost", 8081);
        RpcCommand command = new RpcCommand();
        command.setClassName(IDemoInterface.class.getName());
        command.setMethodName("noArgument");
        command.setArgumetsType(new String[0]);
        RpcResponse response = client.invoke(command);

        RpcCommand command2 = new RpcCommand();
        command2.setClassName(IDemoInterface.class.getName());
        command2.setMethodName("withReturn");
        command2.setArgumetsType(new String[] { "java.lang.String" });
        command2.setParams(new String[] { "shocklee" });
        RpcResponse response2 = client.invoke(command2);
        System.out.println(response.getResult());
        System.out.println(response2.getResult());
    }
}

至此整個框架部分已經完成，暫時還沒有做常見的rpc客戶端api包裝，比如包裝成從某個容器裡面根據介面取出一個遠端物件，直接呼叫遠端物件的方法。
最後貼個測試類和介面

package com.shock.rpc.demo;

/**
 * ${DESCRIPTION}
 * com.shock.rpc.demo.${CLASS_NAME}
 * Created by zhengdong.lzd on 2016/11/29 0029.
 */
public interface IDemoInterface {

    public String withReturn(String name);
    public void noReturn(String name);
    public String noArgument();
}
package com.shock.rpc.demo;

/**
 * ${DESCRIPTION}
 * com.shock.rpc.demo.${CLASS_NAME}
 * Created by zhengdong.lzd on 2016/11/29 0029.
 */
public class IDemoImpl implements IDemoInterface {
    @Override
    public String withReturn(String name) {
        System.out.println("withReturn "+name);
        return "hello " + name;
    }

    @Override
    public void noReturn(String name) {
        System.out.println("noReturn "+name);
    }

    @Override
    public String noArgument() {
        System.out.println("noArgument");
        return "noArgument";
    }
}

整個RPC功能已經都貼出來了，程式碼沒有做過整理，沒有把序列化/反序列程式碼抽象,協議部分也沒做抽象，只是想寫的快點，能夠在短時間內寫出來和標題十分鐘對應上，所以可能程式碼難看點，不過整體已經展示出來了，關鍵程式碼是不需要使用任何第三方框架和工具包的。

歡迎大家進行拍磚。

另外打個廣告吧，本人寫了一個稍微複雜點的RPC放在github上，有木有同學想一起進行寫著玩的的，趕緊約起啊，程式碼地址是
https://github.com/shocklee6315/simpleRpcServer

仿照dubbo手寫一個RPC框架
2020-11-11
RPC框架
手寫RPC框架
2019-04-01
RPC框架
十分鐘上手前端UI框架Bootstrap
2019-04-01
前端UI框架boot
使用Netty三分鐘手寫一個RPC
2019-03-30
NettyRPC
十分鐘搭建主流框架：純程式碼搭建
2015-09-15
框架
教你十分鐘構建好 SpringBoot + SSM 框架
2018-07-22
Spring BootSSM框架
十分鐘搭建主流框架：簡單的網路部分
2015-11-27
框架
基於netty手寫RPC框架
2019-11-07
NettyRPC框架
手寫RPC框架（六）整合Netty
2022-02-18
RPC框架Netty
GDB十分鐘教程
2015-11-26
寫一個RPC服務
2024-04-19
RPC
十分鐘學會用 Go 編寫 Web 中介軟體
2020-02-08
GoWeb
在spring boot中3分鐘上手RPC框架Dubbo
2019-04-29
Spring BootRPC框架
十分鐘搭建主流框架：下拉/上拉重新整理資料
2015-11-27
框架
十分鐘看懂AES加密
2020-05-17
加密
十分鐘快速上手NutUI
2020-05-21
UI
十分鐘搞定 Gradle
2019-04-05
Gradle
十分鐘學會Flask
2018-12-14
Flask
十分鐘入門 Less
2016-12-12
十分鐘入門RocketMQ
2016-12-08
MQ
十分鐘掌握SQLite操作
2016-01-09
SQLite
十分鐘通過 npm 建立一個命令列工具
2019-02-05
NPM命令列
如何在十分鐘內建立一個Chrome 外掛
2023-09-25
Chrome
設計一個分散式RPC框架
2019-02-01
分散式RPC框架
三十分鐘拿Git幹活
2018-06-04
Git
三十分鐘 Docker 新手入門
2016-10-10
Docker
十分鐘學會 Python
2015-09-30
Python
Python十分鐘入門
2012-08-24
Python
看了這篇你就會手寫RPC框架了
2020-07-24
RPC框架
徒手擼一個簡單的RPC框架
2019-01-20
RPC框架
如何實現一個分散式RPC框架
2017-07-04
分散式RPC框架
十分鐘瞭解eslint配置 && 編寫自定義eslint規則
2019-08-01
EsLint
編寫 Netty / RPC 客戶端【框架程式碼分析】
2020-12-22
NettyRPC客戶端框架
三十分鐘掌握Webpack效能優化
2019-03-04
Web優化
十分鐘搞懂分散式爬蟲
2019-08-11
分散式爬蟲
爬蟲程式十分鐘入門
2021-09-09
爬蟲
十分鐘 GET 資料分析技巧
2019-02-13
十分鐘快速入門 Python
2019-01-22
Python

十分鐘寫個RPC框架

相關文章