RPC功能的简单Java方式实现以及思考

最新推荐文章于 2025-10-20 08:35:55 发布

原创最新推荐文章于 2025-10-20 08:35:55 发布 · 417 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#计算机 #网络

计算机网络专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个简单的远程过程调用(RPC)框架实现，包括客户端和服务端的交互过程，并讨论了可能的改进方向。

每篇一句：

We laughed and kept saying ‘see u soon’, but inside we both knew we’d never see each other again.

RPC简介：

RPC（Remote Procedure Call）—-远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如 TCP 或 UDP ，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

RPC采用 客户机/服务器 模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。

Java实现：

Server提供：

HelloWorldService.java

public interface HelloWorldService {
    public String hello(String name);
}

HelloWorldServiceImpl.java

public class HelloWorldServiceImpl implements HelloWorldService {
    @Override
    public String hello(String name) {
        return "Hello! " + name;
    }
}

RPC_Server.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;

public class RPC_Server {
    public static void main(String[] args){
        ServerSocket ss = null;
        Socket socket = null;
        ObjectOutputStream out  = null;
        try {
            ss = new ServerSocket(8090);
            while(true){
                System.out.println("----Server Start!-----");
                socket = ss.accept();

                // 从socket获取信息
                ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                // 获取消息的顺序要与客户端添加的顺序一致
                String interface_name = input.readUTF(); // 请求调用的接口名称
                System.out.println("调用的服务为：" + interface_name);
                String method_name = input.readUTF();  // 请求调用的方法名称
                System.out.println("调用的方法为：" + method_name);
                Class<?>[] parameterType = (Class<?>[]) input.readObject();  // 被调用方法的参数类型列表
                Object[] arguments = (Object[]) input.readObject();  // 客户端传过来的参数列表
                System.out.println("参数列表为 : " + Arrays.toString(arguments));

                // 根据得到的被调用接口名称得到Server的Class
                Class<?> service_Interface_Class = Class.forName(interface_name);
                // 根据方法名称和参数类型得到Server的method
                Method method = service_Interface_Class.getMethod(method_name, parameterType);
                // 服务实例化
                Object service = service_Interface_Class.newInstance();
                // 反射执行这个方法
                Object result = method.invoke(service, arguments);

                // 写回处理结果
                out = new ObjectOutputStream(socket.getOutputStream());
                out.writeObject(result);

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

Client调用：

RPC_Client.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class RPC_Client {
    public void hello(String name){

        ObjectOutputStream out = null;
        Socket socket = null;
        try {
            // 即将调用的接口名
            String interFaceName = "HelloWorldServiceImpl";
            // 即将调用的方法名
            String methodName = "hello";
            // 参数类型列表
            Class<?>[] arguments_types = {java.lang.String.class};
            // 参数
            Object[] arguments = {name};


            socket = new Socket("127.0.0.1", 8090);

            // 将调用的信息写入out
            out = new ObjectOutputStream(socket.getOutputStream());
            out.writeUTF(interFaceName);
            out.writeUTF(methodName);
            out.writeObject(arguments_types);
            out.writeObject(arguments);

            // 获取结果
            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            Object result = in.readObject();

            System.out.println(result.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        RPC_Client c = new RPC_Client();
        c.hello("RPC");
    }
}

测试结果：
- Server端:
- Client端：

过程分析：

在这个简单的Demo中，Client端远程调用Server端的hello() 方法，其内部操作大致如下：

启动RPC_Server，服务器端开始监听本机的8090端口；
启动RPC_Client，客户端将即将调用方法的相关信息（类名、方法名、参数类型列表、参数列表）写入流，通过新建的socket通过8090端口传到服务器；
服务器端检测到有客户端调用本机提供的服务，从socket获取信息；
根据获取到的信息，调用本机对应的服务，执行远程过程；
服务器端将执行结果写入流，通过socket传回客户端；
客户端接受服务器端返回的执行结果。

总结：

本文只是RPC功能的简单实现，效率较慢，还存在着很多可以改进的方面：

比如：

通信机制：本文采用的通信方式socket是基于BIO实现的，I/O效率不高，可以使用NIO或直接使用Netty代替BIO实现；
数据传输：本文数据传输速率较慢，可以采用基于JSON数据传输的方式；
序列化：在服务器端与客户端进行通信时，需要将对象名称、方法名称、参数等信息转换成二进制传输，本文采用的是Java原生的readUTF()，writeUTF()等序列化机制，占内存太多，运行效率也不高，可以使用其他开源的序列化机制，如：Hadoop Avro与Google protobuf等；

另外：