rpc远程框架的原理、核心技术点概念以及用java socket实现简单的rpc

最新推荐文章于 2025-06-15 13:24:15 发布

原创最新推荐文章于 2025-06-15 13:24:15 发布 · 501 阅读

0 ·

CC 4.0 BY-SA版权

java基础同时被 2 个专栏收录

45 篇文章

订阅专栏

rpc

2 篇文章

订阅专栏

本文介绍了RPC（远程过程调用）的基本概念、原理及其实现。RPC简化了远程服务调用，隐藏了底层通信细节。文章通过Java Socket实现了一个简单的RPC框架，涉及服务提供者、服务发布者和本地服务代理的职责，并给出了相关代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

《分布式服务框架原理与实践》

一、RPC架构

rpc，全称remote procedure call，即远程过程调用。它是一种进程间的通信方式，允许像调用本地服务一样，调用远程的服务。有很多的具体实现，如spring的http invoker、facebook的thrift二进制私有协议通信。

rpc在80s，由bruce jay nelson提出，他在论文中做了如下定义：

1）简单：rpc概念的语义十分清晰以及简单，这样建立分布式计算就更容易。

2）高效：过程调用看起来十分简单，而且高效。

3）通用：在单机计算中往往是算法和api，跨进程最重要的是通用的通信机制。

2006年后，随着互联网移动的发展以及智能终端的普及，远程分布式调用已经成为主流，开源和自研的rpc框架的普及标志

着传统垂直应用架构的终结。

二、原理

rpc框架的目标是让远程过程（服务），调用更加简单透明，rpc负责屏蔽底层传输方式（tcp udp）、序列化方式（xml json 二进制）以及通信细节。框架的使用者，只需要了解谁在什么位置，提供了什么样的远程服务即可，开发者不用关系底层的调用过程和通信细节。

框架原理图：

核心技术点：

1）远程服务提供者需要以某种形式提供服务调用的相关信息，包括但不限于接口定义、数据结构、或者中间态的服务定义文件，例如thrift的IDL文件，WS-RPC的WSDL文件定义，甚至也可以是服务端接口的说明文档。服务调用者需要通过一定的途径获取远程服务的调用的相关信息，例如服务端接口定义jar包导入，获取服务端IDL文件等。

2）远程代理对象：服务调用者调用的服务实际上是远程服务的本地代理，对于java语言，它的实现就是jdk动态代理，通过动态代理的拦截机制，将本地调用封装成远程服务调用。

3）通信：rpc与具体的协议无关，例如spring远程调用支持http invoker、rmi invoke，MessagePack使用的是私有的二进制压缩协议。

4）序列化：远程通信，需要将对象转换成二进制码流进行传输，不同的框架支持的数据类型，数据包大小，异常类型，以及性能都不同，不同的rpc框架应用场景不同，因此技术选择会存在很大差异，一些比较好的rpc框架，支持多种序列化方式，甚至支持用户自定义序列化框架（hadoop avro）。

三、简单实现一个rpc框架

分析：

分为三个部分：

1）服务提供者：运行在服务端，负责提供接口的定义以及服务具体实现类

2）服务发布者：运行在rpc服务端，负责将本地服务发布成远程服务，供消费者使用

主要职责：作为服务端，监听客户端的socket连接，接收到新的连接后，将其封装成task，由线程池执行；

将客户端发送的码流，反序列化成对象，反射调用服务提供者，获取执行结果；

将执行结果序列化，通过socket发送给客户端；

远程服务执行完毕后，关闭socket等资源，防止句柄泄露；

3）本地服务代理：运行在客户端，通过代理调用远程服务提供者，然后将结果封装返回给本地消费者

主要职责：将本地的接口调用转换成jdk动态代理，在动态代理中实现接口的远程调用；

创建socket客户端，根据ip地址，连接远程服务提供者；

将远程服务调用所需要的接口类，方法名，参数列表等编码后，发送给服务提供者；

同步阻塞，等待服务端响应，获取响应结果后返回

代码结构：

代码：

1）服务提供者：

package me.ele.remoteServiceProvider;

/**
 * 远程服务_接口
 *
 * @author LZJ
 * @create 2018-08-03 14:06
 **/
public interface DemoService {
    String demo(String ping);
}

package me.ele.remoteServiceProvider;

/**
 * 远程服务_具体实现
 *
 * @author LZJ
 * @create 2018-08-03 14:08
 **/
public class DemoServiceImpl implements DemoService {
    public String demo(String ping) {
        return ping !=null ? ping + "---->i am ok" : "i am ok";
    }
}

2）服务发布者：

package me.ele.remoteServicePublisher;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服务发布者
 *
 * @author LZJ
 * @create 2018-08-03 14:10
 **/
public class RpcPublisher {
    //返回到虚拟机的最大可用的处理器数量
    static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    public static void publish(String hostName, int port) throws IOException {

        ServerSocket server = new ServerSocket();
        server.bind(new InetSocketAddress(hostName,port));
        try {
            while (true){
                //server监听客户端请求连接，由线程池执行
                executorService.execute(new SupportTask(server.accept()));
            }
        }finally {
            server.close();
        }

    }

    private static class SupportTask implements Runnable{
        Socket socket = null;
        public SupportTask(Socket socket){
            this.socket = socket;
        }

        public void run() {
            ObjectInputStream inputStream = null;
            ObjectOutputStream outputStream = null;
            try {
                inputStream = new ObjectInputStream(socket.getInputStream());
                //获取客户端发送的类名
                String interfaceName = inputStream.readUTF();
                Class<?> service = Class.forName(interfaceName);
                //获取客户端发送的方法名
                String methodName = inputStream.readUTF();
                //获取客户端发送的参数类型
                Class<?>[] parameterTypes = (Class<?>[]) inputStream.readObject();
                //获取参数
                Object[] args = (Object[]) inputStream.readObject();
                //invoke调用对应的方法
                Method method = service.getMethod(methodName, parameterTypes);
                Object result = method.invoke(service.newInstance(), args);

                //返回执行结果给客户端
                outputStream = new ObjectOutputStream(socket.getOutputStream());
                outputStream.writeObject(result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(inputStream != null){
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(outputStream != null){
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

3）本地服务代理：

package me.ele.localServiceProxy;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * 本地服务代理
 *
 * @author LZJ
 * @create 2018-08-03 14:34
 **/
public class RpcImporter<S> {
    public S importer(final Class<?> serviceClass , final InetSocketAddress address){
        return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(),
                new Class<?>[]{serviceClass.getInterfaces()[0]},
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        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();
                        }finally {
                            if(socket != null){
                                socket.close();
                            }
                            if(inputStream != null){
                                inputStream.close();
                            }
                            if(outputStream != null){
                                outputStream.close();
                            }
                        }
                    }
                });
    }
}

4）测试：

package me.ele;

import me.ele.localServiceProxy.RpcImporter;
import me.ele.remoteServiceProvider.DemoService;
import me.ele.remoteServiceProvider.DemoServiceImpl;
import me.ele.remoteServicePublisher.RpcPublisher;

import java.io.IOException;
import java.net.InetSocketAddress;

/**
 * @author LZJ
 * @create 2018-08-03 14:01
 **/
public class Test {
    public static void main(String[] args) {

        //异步启动服务
        new Thread(new Runnable() {
            public void run() {
                try {
                    RpcPublisher.publish("localhost",9999);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //创建rpc客户端代理
        RpcImporter<DemoService> importer = new RpcImporter<DemoService>();
        //构建rpc请求参数，发起rpc调用
        DemoService localhost = importer.importer(DemoServiceImpl.class, new InetSocketAddress("localhost", 9999));

        //将调用结果输出到控制台
        String result = localhost.demo("are you ok???");
        System.out.println(result);
    }
}

5）运行结果：