RPC的全稱是Remote Procedure Call，它是一種程序間的通訊方式。允許像呼叫本地服務一樣呼叫遠端服務。

對於RPC的總結：

1. 簡單：RPC概念的語義十分簡單和清晰，這樣建立分散式計算更容易。
2. 高效：過程呼叫看起來十分簡單而且十分高效。
3. 通用：在單機計算過程中往往是不同演算法和API，在跨程序呼叫最重要的是通用的通訊機制。

對於RPC框架實現的技術點總結如下：

1. 遠端服務提供者需要一某種形式提供服務呼叫的相關資訊，包括但不限於服務介面的定義、資料結構，或者中間狀態服務定義的檔案。
2. 遠端代理物件：服務呼叫者呼叫的服務實際上市遠端服務的代理。
3. 通訊：RPC框架的與具體的通訊協議無關
4. 序列化：遠端通訊需要將物件轉換成二進位制碼流進行傳輸，不同的序列化框架支援的資料型別，資料包大小，異常型別及效能等都不相同。

最簡單的RPC框架實現：

1. 服務提供者，執行在服務端，負責服務介面定義和服務介面實現。
2. 服務釋出者，執行在RPC服務端，負責將本地服務釋出成遠端服務，供其他消費者呼叫
3. 本地服務代理，執行在RPC客戶端，通過代理呼叫遠端服務提供者，然後對結果進行封裝返回給本地消費者

下面是具體的實現，
定義EchoService介面，程式碼如下

/**
 * @author zhuowen_pan.
 * @version 1.0.0
 */
public interface
 
 EchoService {

    String sayHello(String name);

}

EchoServiceImpl定義該介面的實現類

/**
 * @author zhuowen_pan.
 * @version 1.0.0
 */
public class EchoServiceImpl implements EchoService {

    @Override
    public String sayHello(String name) {
        return name == null ? "hello nobody" : "hello " + name;
    }
}
 

RPC服務端服務釋出者程式碼的實現

/**
 * @author zhuowen_pan.
 * @version 1.0.0
 */
public class RpcExporter {

    private static Executor executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public static void exporter(String hostName, int port) throws Exception {
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(hostName, port));
        try {
            while (true) {
                executor.execute(new ExporterTasks(serverSocket.accept()));
            }
        } finally {
            serverSocket.close();
        }
    }

    private static class ExporterTasks implements Runnable {
        Socket client = null;

        public ExporterTasks(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            ObjectInputStream input = null;
            ObjectOutputStream out = null;
            try {

                input = new ObjectInputStream(client.getInputStream());
                String interfaceName = input.readUTF();
                Class<?> service = Class.forName(interfaceName);
                String methodName = input.readUTF();
                Class<?>[] paramsTypes = (Class<?>[]) input.readObject();
                Object[] args = (Object[]) input.readObject();
                Method method = service.getMethod(methodName, paramsTypes);
                Object result = method.invoke(service.newInstance(), args);
                out = new ObjectOutputStream(client.getOutputStream());
                out.writeObject(result);

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (out != null)  {
                        out.close();
                    }
                    if (input != null) {
                        input.close();
                    }
                    if (client != null) {
                        client.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

服務釋出者的主要職責

1. 作為服務端，監聽客戶端的TCP連結，接收到客戶端的餓連結之後封裝成Tsak交給執行緒池執行
2. 將客戶端傳送的碼流反序列化成物件，反射呼叫服務的實現者，獲取執行結果
3. 將結果反序列化，通過Socket傳送給客戶端
4. 遠端服務呼叫結束後，釋放資源

RPC客戶端本地服務代理原始碼如下

/**
 * @author zhuowen_pan.
 * @version 1.0.0
 */
public class RpcImporter<S> {

    public S importer(final Class<?> serviceClass, final InetSocketAddress address) {
        return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(), new Class<?>[]{serviceClass.getInterfaces()[0]}, (proxy, method, args) -> {
            Socket socket = null;
            ObjectOutputStream outputStream = null;
            ObjectInputStream inputStream = null;
            try {
                socket = new Socket();
                socket.connect(address);
                outputStream = new ObjectOutputStream(socket.getOutputStream());
                outputStream.writeUTF(serviceClass.getName());
                outputStream.writeUTF(method.getName());
                outputStream.writeObject(method.getParameterTypes());
                outputStream.writeObject(args);
                inputStream = new ObjectInputStream(socket.getInputStream());
                return inputStream.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if(outputStream != null) {
                        outputStream.close();
                    }
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    if (socket != null) {
                        socket.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return null;
        });
    }

}

本地服務的代理的功能如下

1. 將本地介面呼叫轉換成JDK的動態代理，在動態代理中實現介面的呼叫
2. 建立Socket客戶端，根據指定地址呼叫遠端服務的提供者
3. 將遠端介面呼叫所需要的介面類，方法名，引數列表等編碼後傳送給服務者
4. 同步阻塞等待服務端返回應答，獲取執行結果
   

測試程式碼

/**
 * @author zhuowen_pan.
 * @version 1.0.0
 */
public class Client {

    public static void main(String[] args) {
        new Thread(() -> {
            try {
                RpcExporter.exporter("127.0.0.1", 8088);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
       RpcImporter<EchoService> importer = new RpcImporter<>();
       EchoService echoService = importer.importer(EchoServiceImpl.class, new InetSocketAddress("127.0.0.1", 8088));
        System.out.println(echoService.sayHello(peter));
    }

}

執行結果

到這裡一個簡單RPC服務框架就實現了。