专栏首页开发技术RPC 是通信协议吗 ?→ 我们来看下它的演进过程

RPC 是通信协议吗 ?→ 我们来看下它的演进过程

开心一刻

  一实习小护士给我挂针,拿着针在我胳膊上扎了好几针也没找到血管

  但这位小姑娘真镇定啊,表情严肃认真,势有不扎到血管不罢休的意思

  十几针之后,我忍着剧痛,带着敬畏的表情问小护士:你这针法跟容嬷嬷学的么?

写在前面

  单机应用中的方法调用很简单,直接调用就行,像这样

  因为调用方与被调用方在一个进程内

  随着业务的发展,单机应用会越来越力不从心,势必会引入分布式来解决单机的问题,那么调用方如何调用另一台机器上的方法呢 ?

  这就涉及到分布式通信方式,从单机走向分布式,产生了很多通信方式

  而 RPC 就是实现远程方法调用的方式之一;说 RPC 不是协议,可能很多小伙伴难以置信,以为我在骗你们

  看着你们这一身腱子肉,我哪敢骗你们;只要你们把下面的看完,骗没骗你们,你们自己说了算

RPC 的演进过程

  先说明一下,下文中的示例虽然是 Java 代码实现的,但原理是通用的,重点是理解其中的原理

第一版

    两台机器之间进行交互,那么肯定离不开网络通信协议,TCP / IP 也就成了绕不开的点,所以先辈们最初想到的方法就是通过 TCP / IP 来实现远程方法的调用

    而操作系统是没有直接暴露 TCP / IP 接口的,而是通过 Socket 抽象了 TCP / IP 接口,所以我们可以通过 Socket 来实现最初版的远程方法调用

    完整示例代码:rpc-01,核心代码如下

    Server:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;
import com.qsl.rpc.server.UserServiceImpl;
import com.qsl.rpc.service.IUserService;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Server {
    private static boolean is_running = true;

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (is_running) {
            System.out.println("等待 client 连接");
            Socket client = serverSocket.accept();
            System.out.println("获取到 client...");
            handle(client);
            client.close();
        }
        serverSocket.close();
    }

    private static void handle(Socket client) throws Exception {
        InputStream in = client.getInputStream();
        OutputStream out = client.getOutputStream();
        DataInputStream dis = new DataInputStream(in);
        DataOutputStream dos = new DataOutputStream(out);

        // 从 socket 读取参数
        int id = dis.readInt();
        System.out.println("id = " + id);

        // 查询本地数据
        IUserService userService = new UserServiceImpl();
        User user = userService.getUserById(id);

        // 往 socket 写响应值
        dos.writeInt(user.getId());
        dos.writeUTF(user.getName());
        dos.flush();

        dis.close();
        dos.close();
    }
}

    Client:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Client {

    public static void main(String[] args) throws Exception {
        Socket s = new Socket("127.0.0.1", 8888);

        // 网络传输数据
        // 往 socket 写请求参数
        DataOutputStream dos = new DataOutputStream(s.getOutputStream());
        dos.writeInt(18);
        // 从 socket 读响应值
        DataInputStream  dis = new DataInputStream(s.getInputStream());
        int id = dis.readInt();
        String name = dis.readUTF();
        // 将响应值封装成 User 对象
        User user = new User(id, name);
        dos.close();
        dis.close();
        s.close();

        // 进行业务处理
        System.out.println(user);
    }
}

    代码很简单,就是一个简单的 Socket 通信;如果看不懂,那就需要去补充下 Socket 和 IO 的知识

    测试结果如下

    可以看到 Client 与 Server 之间是可以进行通信的;但是,这种方式非常麻烦,有太多缺点,最明显的一个就是

Client 端业务代码 与 网络传输代码 混合在一起,没有明确的模块划分

      如果有多个开发者同时进行 Client 开发,那么他们都需要知道 Socket、IO

  第二版

    针对第一版的缺点,演进出了这一版,引进 Stub (早期的叫法,不用深究,理解成代理就行)实现 Client 端网络传输代码的封装

    完整示例代码:rpc-02,改动部分如下

    Stub:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

/**
 * 相当于一个静态代理,封装了网络数据传输
 * @author 青石路
 * @date 2021/1/17 9:38
 */
public class Stub {

    public User getUserById(Integer id) throws Exception {
        Socket s = new Socket("127.0.0.1", 8888);

        // 网络传输数据
        // 往 socket 写请求参数
        DataOutputStream dos = new DataOutputStream(s.getOutputStream());
        dos.writeInt(id);
        // 从 socket 读响应值
        DataInputStream dis = new DataInputStream(s.getInputStream());
        int userId = dis.readInt();
        String name = dis.readUTF();
        // 将响应值封装成 User 对象
        User user = new User(userId, name);
        dos.close();
        dis.close();
        s.close();

        return user;
    }
}

    Client:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Client {

    public static void main(String[] args) throws Exception {

        // 不再关注网络传输
        Stub stub = new Stub();
        User user = stub.getUserById(18);

        // 进行业务处理
        System.out.println(user);
    }
}

    Client 不再关注网络数据传输,一心关注业务代码就好

    有小伙伴可能就杠上了:这不就是把网络传输代码移了个位置嘛,这也算改进?

    迭代开发是一个逐步完善的过程,而这也算是一个改进哦

    但这一版还是有很多缺点,最明显的一个就是

Stub 只能代理 IUserService 的一个方法 getUserById ,局限性太大,不够通用

如果想在 IUserService 新增一个方法: getUserByName ,那么需要在 Stub 中新增对应的方法,Server 端也需要做对应的修改来支持

  第三版

    第二版中的 Stub 代理功能太弱了,那有没有什么方式可以增强 Stub 的代理功能了?

    前面的 Stub 相当于是一个静态代理,所以功能有限,那静态代理的增强版是什么了,没错,就是:动态代理

    不熟悉动态代理的小伙伴,一定要先弄懂动态代理:设计模式之代理,手动实现动态代理,揭秘原理实现

    JDK 有动态代理的 API,我们就用它来实现

    完整示例代码:rpc-03,相较于第二版,改动比较大,大家需要仔细看

    Server:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;
import com.qsl.rpc.server.UserServiceImpl;
import com.qsl.rpc.service.IUserService;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Server {
    private static boolean is_running = true;

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8888);
        while (is_running) {
            System.out.println("等待 client 连接");
            Socket client = serverSocket.accept();
            System.out.println("获取到 client...");
            handle(client);
            client.close();
        }
        serverSocket.close();
    }

    private static void handle(Socket client) throws Exception {
        InputStream in = client.getInputStream();
        OutputStream out = client.getOutputStream();
        ObjectInputStream ois = new ObjectInputStream(in);
        ObjectOutputStream oos = new ObjectOutputStream(out);

        // 获取方法名、方法的参数类型、方法的参数值
        String methodName = ois.readUTF();
        Class[] parameterTypes = (Class[]) ois.readObject();
        Object[] args = (Object[]) ois.readObject();

        IUserService userService = new UserServiceImpl();
        Method method = userService.getClass().getMethod(methodName, parameterTypes);
        User user = (User) method.invoke(userService, args);

        // 往 socket 写响应值;直接写可序列化对象(实现 Serializable 接口)
        oos.writeObject(user);
        oos.flush();

        ois.close();
        oos.close();
    }
}

    Stub:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;
import com.qsl.rpc.service.IUserService;

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.Socket;

/**
 * 动态代理,封装了网络数据传输
 * @author 青石路
 * @date 2021/1/17 9:38
 */
public class Stub {

    public static IUserService getStub() {
        Object obj = Proxy.newProxyInstance(IUserService.class.getClassLoader(),
                new Class[]{IUserService.class}, new NetInvocationHandler());
        return (IUserService)obj;
    }

    static class NetInvocationHandler implements InvocationHandler {

        /**
         *
         * @param proxy
         * @param method
         * @param args
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Socket s = new Socket("127.0.0.1", 8888);

            // 网络传输数据
            ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
            // 传输方法名、方法参数类型、方法参数值;可能会有方法重载,所以要传参数列表
            oos.writeUTF(method.getName());
            Class[] parameterTypes = method.getParameterTypes();
            oos.writeObject(parameterTypes);
            oos.writeObject(args);

            // 从 socket 读响应值
            ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
            User user = (User) ois.readObject();

            oos.close();
            ois.close();
            s.close();

            return user;
        }
    }
}

    Client:

package com.qsl.rpc;

import com.qsl.rpc.entity.User;
import com.qsl.rpc.service.IUserService;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Client {

    public static void main(String[] args) throws Exception {

        IUserService userService = Stub.getStub();
        //User user = userService.getUserById(23);

        User user = userService.getUserByName("李小龙");
        // 进行业务处理
        System.out.println(user);
    }
}

    我们来看下效果

    此时, IUserService 接口的方法都能被代理了,即使它新增接口, Stub 不用做任何修改也能代理上

    另外, Server 端的响应值改成了对象,而不是单个属性逐一返回,那么无论 User 是新增属性,还是删减属性,Client 和 Server 都不受影响了

    这一版的改进是非常大的进步;但还是存在比较明显的缺点

只支持 IUserService ,通用性还是不够完美

      如果新引进了一个 IPersonService ,那怎么办 ?

  第四版

    第三版相当于 Client 与 Server 端约定好了,只进行 User 服务的交互,所以 User 之外的服务,两边是通信不上的

    如果还需要进行其他服务的交互,那么 Client 就需要将请求的服务名作为参数传递给 Server,告诉 Server 我需要和哪个服务进行交互

    所以,Client 和 Server 都需要进行改造

    完整示例代码:rpc-04,相较于第三版,改动比较小,相信大家都能看懂

    Server:

package com.qsl.rpc;

import com.qsl.rpc.server.PersonServiceImpl;
import com.qsl.rpc.server.UserServiceImpl;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Server {
    private static boolean is_running = true;

    private static final HashMap<String, Object> REGISTRY_MAP = new HashMap();

    public static void main(String[] args) throws Exception {

        // 向注册中心注册服务
        REGISTRY_MAP.put("com.qsl.rpc.service.IUserService", new UserServiceImpl());
        REGISTRY_MAP.put("com.qsl.rpc.service.IPersonService", new PersonServiceImpl());

        ServerSocket serverSocket = new ServerSocket(8888);
        while (is_running) {
            System.out.println("等待 client 连接");
            Socket client = serverSocket.accept();
            System.out.println("获取到 client...");
            handle(client);
            client.close();
        }
        serverSocket.close();
    }

    private static void handle(Socket client) throws Exception {
        InputStream in = client.getInputStream();
        OutputStream out = client.getOutputStream();
        ObjectInputStream ois = new ObjectInputStream(in);
        ObjectOutputStream oos = new ObjectOutputStream(out);

        // 获取服务名
        String serviceName = ois.readUTF();
        System.out.println("serviceName = " + serviceName);

        // 获取方法名、方法的参数类型、方法的参数值
        String methodName = ois.readUTF();
        Class[] parameterTypes = (Class[]) ois.readObject();
        Object[] args = (Object[]) ois.readObject();

        // 获取服务;从服务注册中心获取服务
        Object serverObject = REGISTRY_MAP.get(serviceName);

        // 通过反射调用服务的方法
        Method method = serverObject.getClass().getMethod(methodName, parameterTypes);
        Object resp = method.invoke(serverObject, args);

        // 往 socket 写响应值;直接写可序列化对象(实现 Serializable 接口)
        oos.writeObject(resp);
        oos.flush();

        ois.close();
        oos.close();
    }
}

    Stub:

package com.qsl.rpc;

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.Socket;

/**
 * 动态代理,封装了网络数据传输
 * @author 青石路
 * @date 2021/1/17 9:38
 */
public class Stub {

    public static Object getStub(Class clazz) {
        Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new NetInvocationHandler(clazz));
        return obj;
    }

    static class NetInvocationHandler implements InvocationHandler {

        private Class clazz;

        NetInvocationHandler(Class clazz){
            this.clazz = clazz;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Socket s = new Socket("127.0.0.1", 8888);

            // 网络传输数据
            ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());

            // 传输接口名,告诉服务端,我要哪个服务
            oos.writeUTF(clazz.getName());

            // 传输方法名、方法参数类型、方法参数值;可能会有方法重载,所以要传参数列表
            oos.writeUTF(method.getName());
            Class[] parameterTypes = method.getParameterTypes();
            oos.writeObject(parameterTypes);
            oos.writeObject(args);

            // 从 socket 读响应值
            ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
            Object resp = ois.readObject();

            oos.close();
            ois.close();
            s.close();

            return resp;
        }
    }
}

    Client:

package com.qsl.rpc;

import com.qsl.rpc.entity.Person;
import com.qsl.rpc.entity.User;
import com.qsl.rpc.service.IPersonService;
import com.qsl.rpc.service.IUserService;

/**
 * @author 青石路
 * @date 2021/1/16 19:49
 */
public class Client {

    public static void main(String[] args) throws Exception {

        /*IUserService userService = (IUserService)Stub.getStub(IUserService.class);
        User user = userService.getUserByName("青石路");
        System.out.println(user);*/

        IPersonService personService = (IPersonService)Stub.getStub(IPersonService.class);
        Person person = personService.getPersonByPhoneNumber("123");
        System.out.println(person);
    }
}

    此版本抽象的比较好了,屏蔽了底层细节,支持任何服务的任意方法,算是一个比较完美的版本了

    至此,一个最基础的 RPC 就已经实现了

    但是,还是有大量的细节可以改善,序列化与反序列化就是其中之一

      网络中数据的传输都是二进制,所以请求参数需要序列化成二进制,响应参数需要反序列化成对象

而 JDK 自带的序列化与反序列化,具有语言局限性、效率慢、序列化后的长度太长等缺点

    序列化与反序列化协议非常多,常见的有

    这些协议孰好孰坏,本文不做过多阐述,这里提出来只是想告诉大家:序列化与反序列化协议是 RPC 中的重要一环

总结

  1、RPC 的演进过程

  2、RPC 的组成要素

    三要素:动态代理、序列化与反序列化协议、网络通信协议

    网络通信协议可以是 TCP、UDP,也可以是 HTTP 1.x、HTTP 2,甚至有能力可以是自定义协议

  3、RPC 框架

    RPC 不等同于 RPC 框架,RPC 是一个概念,是一个分布式通信方式

    基于 RPC 产生了很多 RPC 框架:Dubbo、Netty、gRPC、BRPC、Thrift、JSON-RPC 等等

    RPC 框架对 RPC 进行了功能丰富,包括:服务注册、服务发现、服务治理、服务监控、服务负载均衡等功能

  现在回到标题:RPC 是通信协议吗 ? 欢迎评论区留言

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • dubbo协议底层原理与实现

    •netty•mina•RMI 服务•servlet 容器(jetty、Tomcat、Jboss)

    IT架构圈
  • Dubbo(一) 开始认识Dubbo,分布式服务框架

    引言: 以前的车马很慢,一生只够爱一个人 以前的网站人很少,一个单应用服务着一个人 ———————————————————— 现在,动不动就谈什么高并发,千万级...

    生活创客
  • 『互联网架构』软件架构-dubbo协议底层原理与实现(44)

    1.DubboCodec.encodeRequestData() 116L // 编码request 2.DecodeableRpcInvocation.dec...

    IT架构圈
  • 手把手教你搭建SpringCloudAlibaba微服务架构——集成Dubbo、Feign实现服务注册、远程服务调用(RPC)

    Nacos肯定是要有的,上一篇已经介绍了Nacos的搭建以及配置中心的基本使用,而在这篇文章中Nacos扮演的是注册中心的角色,通过集成Dubbo与Feign完...

    敲得码黛
  • 程序员修神之路--设计一套RPC框架并非易事

    可以这么说,http协议是基于TCP协议的,底层的数据传输可以说是利用的socket

    架构师修行之路
  • 【技术创作101训练营】RPC  的前世今生

    大家好,我是goodspeed,现在是一名后端工程师。昵称比较奇怪哈,名字来自烂片之王尼古拉斯凯奇早期电影,意思是祝你好运。

    goodspeed
  • 想开发IM集群?先搞懂什么是RPC!

    本文引用了后端技术指南针公众号“浅谈RPC那些事儿1”和即时通讯网的“即时通讯新手入门:快速理解RPC技术——基本概念、原理和用途”两篇文章的部分内容。

    JackJiang
  • IM开发基础知识补课(九):想开发IM集群?先搞懂什么是RPC!

    本文引用了后端技术指南针公众号“浅谈RPC那些事儿1”和即时通讯网的“即时通讯新手入门:快速理解RPC技术——基本概念、原理和用途”两篇文章的部分内容。

    JackJiang
  • RPC 发展史

    本文主要介绍RPC基础概念以及发展历程,目的是为了让读者对RPC 的发展以及发展过程中遇到的问题有比较清晰的了解。

    goodspeed
  • 面霸篇:Dubbo 夺命 17 问

    Dubbo是一个分布式服务框架,致力于提供高性能和透明化的RPC远程服务调用方案,以及SOA服务治理方案。

    码哥字节
  • PHP程序员如何简单的开展服务治理架构(二)

    服务治理 治理的绝笔是服务,在一家公司有玩各种语言的程序员,如何去统一管理他们开发的服务,这是一个问题。

    CrazyCodes
  • 到底什么是RPC - 概述

    远古时期,每个进程各干各的,但随着发展有时候会存在A进程调用B进程某一方法,使用其功能的场景,比如说把画图统一都在某一个进程中,其他进程只需要调用它就ok了(代...

    邹志全
  • Dubbo面试题(2020最新版)

    Java面试总结汇总,整理了包括Java基础知识,集合容器,并发编程,JVM,常用开源框架Spring,MyBatis,数据库,中间件等,包含了作为一个Java...

    Java架构师必看
  • 『高级篇』docker之CICD(终结篇)(44)

    3.springboot&springcloud的内容,毕竟他们都是线下流行的跟微服务密切相关的,犹豫跟微服务相关的很多,初学者很容易混乱,让老铁在大脑中对sp...

    IT架构圈
  • 【技术创作101训练营】剖析 gRPC

    各位好,今天的主题是剖析gRPC, 我们在实际工作中大量的应用gRPC做服务之间的调用。经常用写一些proto文件,用protoc把我们的proto文件生成相应...

    lpxxn
  • PHP程序员简单的开展服务治理架构操作详解(二)

    本文实例讲述了PHP程序员简单的开展服务治理架构操作。分享给大家供大家参考,具体如下:

    砸漏
  • 网络协议 19 - RPC协议综述:远在天边近在眼前

        这几年微服务很火,想必各位博友或多或少的都接触过。微服务概念中, 各服务间的相互调用是不可或缺的一环。你知道微服务之间是通过什么方式相互调用的吗?

    北国风光
  • Rpc的实现原理以及实现一个简单的Rpc

    RPC(Remote Procedure Call)—远程过程调用,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。RPC协议假定某...

    仙士可
  • 《面试八股文》之Dubbo17卷

    今天就开启《面试八股文》系列的第一版-RPC王者Dubbo,moon 在后续的《面试八股文》系列还将继续推出mysql,spring,并发,redis,kafk...

    moon聊技术

扫码关注云+社区

领取腾讯云代金券