深入理解远程过程调用

关注

原创 2023-04-15 16:15:35 5.5k 阅读 AI 写同款· GEO 优化 ›

服务（远程）调用远程调用： RPC 跨 JVM。具体的调用方式，取决于技术方案。远程调用：第一步：基于HTTP协议的：第二步：获取到想要调用一方的实体类；第三步：把想要获取到的一方的controller的方法实现为接口；第四步：调用被调用方的方法层作为我们的service接口层第五步：在调用方，和被调用发都配置spring-cloud 第六步：引入一个启动器第七步：开启如下的配置，连接注册中心第八步：开启nacos软件，在浏览器中打开 nacos注册中心：https://nacos.io/z 阅读详情

文章目录

本文主要参考自相关书籍和网络文章，并附上自身的一些理解，如有遗漏或错误，还望海涵并指出。谢谢！

一、什么是远程过程调用

1.1、一体化调用

当使用单机服务时，所有的接口、服务都集中在一台服务器上，此时进行的是单体的函数调用(只通过操作系统自身的堆、栈、代码段等)，接口之间的调用不需要通过网络来进行。

1.2、远程过程调用

单体服务被拆分为分布式服务时，接口之间的调用会存在跨机器的调用，此时需要借助网络来进行服务通信，然后进行远程调用。

远程过程调用的形式有很多，最基础的是通过网络传递调用方的参数或序列化后的对象（严格地说，网络传输信道中只存在二进制流）传递给服务提供方，服务提供方接收到参数后调用本地接口进行处理（或再次调用远程服务），然后将产生的结果序列化后通过网络响应给调用方，这就是最基本的远程调用过程了。

当然了，真正的RPC框架（dubbo、thrift）肯定会有更加复杂的实现，譬如请求重试、请求降级、网络拥塞判断等等，这里只是简单地实现核心的操作，重点在于如何通过Socket“远程调用”，方便加深对RPC的理解。

二、用Java实现简单RPC

首先，定义一个接口和实现类：

UserService

public interface UserService {
    User getUser(long id);
    User addUser(long id, String name, int age);
}

UserServiceImpl

public class UserServiceImpl implements UserService {
    @Override
    public User getUser(long id) {
        // 获取User
        System.out.println("Server:getUser");
        return new User(id, "DtnamicRpcTest", 20);
    }

    @Override
    public User addUser(long id, String name, int age) {
        // 添加User
        System.out.println("Server:addUser");
        return new User(id, name, age);
    }
}

2.1、业务侵入型Socket

Client

public class Client {
    public static void main(String[] args) throws IOException {
        try (
                Socket socket = new Socket("127.0.0.1", 8888);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                DataOutputStream dos = new DataOutputStream(bos);
        ) {
            // 获取id为10的User
            dos.writeLong(10);
            // 通过socket远程调用server的生成user方法
            socket.getOutputStream().write(bos.toByteArray());
            socket.getOutputStream().flush();
            // 接受响应
            try (
                    DataInputStream dis = new DataInputStream(socket.getInputStream());
            ) {
                long id = dis.readLong();
                int age = dis.readInt();
                String name = dis.readUTF();
                User user = new User(id, name, age);
                System.out.println("通过RPC调用Server方法，获取到User：" + user);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

Server

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true) {
            Socket socket = serverSocket.accept();
            process(socket);
            socket.close();
        }
    }

    private static void process(Socket socket) throws IOException {
        try (
                DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
                DataInputStream dis = new DataInputStream(socket.getInputStream());
        ) {
            long id = dis.readLong();
            // 调用server的生成user方法
            System.out.println("Server的服务被调用");
            UserService userService = new UserServiceImpl();
            User user = userService.getUser(id);
            // 通过该sokcet将user所需的id、name和age返回
            dos.writeLong(user.getId());
            dos.writeInt(user.getAge());
            dos.writeUTF(user.getName());
            // 写回
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2、无业务侵入型Socket

Client

public class Client {
    public static void main(String[] args) throws IOException {
        // 使用stub封装底层通信细节
        Stub stub = new Stub();
        stub.getUser(10);
    }
}

Server

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true) {
            Socket socket = serverSocket.accept();
            process(socket);
            socket.close();
        }
    }

    private static void process(Socket socket) throws IOException {
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        long id = dis.readLong();
        // 调用server的生成user方法
        System.out.println("Server的服务被调用");
        UserService userService = new UserServiceImpl();
        User user = userService.getUser(id);
        // 通过该sokcet将user所需的id、name和age返回
        dos.writeLong(user.getId());
        dos.writeInt(user.getAge());
        dos.writeUTF(user.getName());
        // 写回
        dos.flush();
    }
}

Stub

public class Stub {
    public User getUser(long id) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8888);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        // 获取特定id的User
        dos.writeLong(id);
        // 通过socket远程调用server的生成user方法
        socket.getOutputStream().write(bos.toByteArray());
        socket.getOutputStream().flush();
        // 接受响应
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        int age = dis.readInt();
        String name = dis.readUTF();
        User user = new User(id, name, age);
        System.out.println("通过RPC调用Server方法，获取到User："+ user);
        dos.close();
        dis.close();
        socket.close();
        return user;
    }
}

2.3、动态代理无业务侵入型Socket

Client

public class Client {
    public static void main(String[] args) throws IOException {
        UserService userService = (UserService) Stub.getStub(UserService.class);
        User user1 = userService.getUser(10);
        System.out.println(user1);
        User user2 = userService.addUser(11, "ARong", 21);
        System.out.println(user2);
    }
}

Server

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true) {
            Socket socket = serverSocket.accept();
            process(socket);
            socket.close();
        }
    }

    private static void process(Socket socket) throws Exception {
        System.out.println("Server的服务被调用");
        // 使用try-with-resource的方式处理资源，无需手动close
        try (
                InputStream in = socket.getInputStream();
                ObjectInputStream ois = new ObjectInputStream(in);
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
        ) {
            // 获取到client端传过来的接口名+方法名+参数类型列表+参数列表
            String interfaceName = ois.readUTF();
            String methodName = ois.readUTF();
            System.out.println("server:获取到的接口名称为：" + interfaceName + ",方法名为：" + methodName);
            Class[] types = (Class[]) ois.readObject();
            Object[] args = (Object[]) ois.readObject();
            // 根据注册表查到该接口对应的具体业务实现类,然后通过反射获取该实现类(这里忽略了)
            UserServiceImpl userService = new UserServiceImpl();
            Method method = userService.getClass().getMethod(methodName, types);
            User user = (User) method.invoke(userService, args);
            // 将user对象返回
            oos.writeObject(user);
            // 追加空对象
            oos.writeObject(null);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Stub

public class Stub {


    /*
     * @Author ARong
     * @Description 使用clazz获取指定代理对象
     * @Date 2020/4/29 1:09 下午
     * @Param [clazz]
     * @return java.lang.Object
     **/
    public static Object getStub(Class clazz) {
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 构建代理方法
                try (
                        Socket socket = new Socket("127.0.0.1", 8888);
                        ByteArrayOutputStream bos = new ByteArrayOutputStream();
                        ObjectOutputStream oos = new ObjectOutputStream(bos);
                ) {
                    // 获取当前的接口名称
                    String interfaceName = clazz.getName();
                    // 获取需要调用的方法名和参数类型列表
                    String methodName = method.getName();
                    Class<?>[] parameterTypes = method.getParameterTypes();
                    // 将接口名+方法名+参数类型列表+参数列表写给server端
                    oos.writeUTF(interfaceName);
                    oos.writeUTF(methodName);
                    oos.writeObject(parameterTypes);
                    oos.writeObject(args);
                    // 追加空对象，防止读取时出现EOF异常
                    oos.writeObject(null);
                    socket.getOutputStream().write(bos.toByteArray());
                    socket.getOutputStream().flush();
                    // 获取到返回的user对象
                    try (ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());) {
                        User user = (User) ois.readObject();
                        return user;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }

        };
        // 生成代理对象
        Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, h);
        return o;
    }
}

2.4、Hessian序列化协议

TestHessian

public class TestHessian {
    public static void main(String[] args) throws IOException {
        hessian();
    }

    private static void hessian() throws IOException {
        User user = new User(1, "HessianTest", 20);
        ByteArrayOutputStream bis1 = new ByteArrayOutputStream();
        // 使用JDK序列化
        ObjectOutputStream oos = new ObjectOutputStream(bis1);
        oos.writeObject(user);
        oos.flush();
        System.out.println("JDK序列化字节长度："+bis1.toByteArray().length);
        // 使用hessian序列化
        ByteArrayOutputStream bis2 = new ByteArrayOutputStream();
        Hessian2Output hop = new Hessian2Output(bis2);
        hop.writeObject(user);
        hop.flush();
        System.out.println("Hessian序列化字节长度："+bis2.toByteArray().length);
        Hessian2Input hit = new Hessian2Input();
        ByteArrayInputStream bis = new ByteArrayInputStream(bis2.toByteArray());
        hit.init(bis);
        System.out.println(hit.readObject());
     }
}