10个类手写实现 RPC 通信框架原理

最新推荐文章于 2024-01-16 09:31:05 发布
最新推荐文章于 2024-01-16 09:31:05 发布
阅读量288 收藏
点赞数
文章标签： java spring rpc aop proxy

点击上方 "程序员小乐"关注, 星标或置顶一起成长

每天凌晨00点00分, 第一时间与你相约

每日英文

Someday, you will find the one, who will watch every sunrise with you until the sunset of your life.

总有一天，你会遇上那个人，陪你看每一次日出，直到你的人生落幕。

每日掏心话

有时候不是不明白，而是明白了也不知道该怎么做，于是就保持了沉默。

来自：Autu | 责编：乐乐

链接：autumn200.com/2020/06/21/write-rpc/

程序员小乐(ID:study_tech)第 954 次推文  图源：百度

往日回顾：老板说“把系统升级到https”，我用一个脚本实现了，而且永久免费！

     

   正文   

什么是rpc

RPC：remote procedure call Protocol 远程过程调用 调用远程服务，就像调用本地的服务一样，不用关心调用细节，就像调用本机的服务一样的

RPC原理

实现RPC通信的程序包括5个部分：rpc-client、客户端proxy、socket、服务端proxy、rpc-server

request

  • 客户端：当rpc-client发起远程调用时，实际上是通过客户端代理 将要调用的接口、方法、参数、参数类型进行序列化，然后通过socket实时将封装调用参数的实例发送到服务端。

  • 服务端：socket接收到客户端传来的信息进行反序列化，然后通过这些信息委派到具体的实现对象

response

  • 服务端：目标方法执行完成后，将执行结果返回给socket

  • 客户端：socket接收到结果后，返回给rpc-client，调用结束

应用到的技术

  • java

  • spring

  • 序列化

  • socket

  • 反射

  • 动态代理

项目GitHub地址

https://github.com/autumnqfeng/write_rpc

服务端项目

项目结构

rpc-server项目包含2个子项目：order-api、order-provider

  • order-api中存放请求接口与RpcRequest（类名、方法名、参数的实体类）

  • order-provider为请求接口实现、socket、proxy相关类

order-api

order-provider

服务注册

要想实现动态调用ServiceImpl，关键就需要将service类管理起来，那问题来了，我们如何管理这些服务类呢？

关注公众号程序员小乐回复关键字“offer”获取算法面试题和答案。

我们可以参照spring中的@Service注解，通过自定义注解的方式来做到服务注册，我们定义一个注解@RpcRemoteService作用在ServiceImpl类上，将标记此注解的类名、方法名保存到Map中，以此来定位到具体实现类。

@RpcRemoteService注解
/**
 * 服务端服务发现注解
 *
 * @author: ***
 * @date: 2020/6/21 16:21
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface RpcRemoteService {
}
服务注册类InitialMerdiator

在spring容器初始化完成之后，扫描到@RpcRemoteService标记的类，并保存到Mediator.ROUTING中。

/**
 * 初始化中间代理层对象
 *
 * @author: ***
 * @date: 2020/6/21 16:33
 */
@Component
public class InitialMerdiator implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //加了服务发布标记的bean进行远程发布
        if (bean.getClass().isAnnotationPresent(RpcRemoteService.class)) {
            Method[] methods = bean.getClass().getDeclaredMethods();
            for (Method method : methods) {
                String routingKey = bean.getClass().getInterfaces()[0].getName() + "." + method.getName();
                BeanMethod beanMethod = new BeanMethod();
                beanMethod.setBean(bean);
                beanMethod.setMethod(method);
                Mediator.ROUTING.put(routingKey, beanMethod);
            }
        }
        return bean;
    }
}

socket监听

socket监听客户端请求

socket启动类SocketServer

spring容器加载完成之后，启动socket

/**
 * spring 容器启动完成之后，会发布一个ContextRefreshedEven
 * 容器启动后启动socket监听
 *
 * @author: ***
 * @date: 2020/6/21 16:51
 */
@Component
public class SocketServer implements ApplicationListener<ContextRefreshedEvent> {
    private final ExecutorService executorService= Executors.newCachedThreadPool();

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        ServerSocket serverSocket=null;
        try {
            serverSocket = new ServerSocket(8888);
            while (true) {
                Socket accept = serverSocket.accept();
                // 线程池处理socket
    executorService.execute(new ProcessorHandler(accept));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

socket处理类ProcessorHandler

处理监听到的每个socket

public class ProcessorHandler implements Runnable {

    private Socket socket;

    public ProcessorHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectInputStream inputStream = null;
        ObjectOutputStream outputStream = null;
        try {
            inputStream = new ObjectInputStream(socket.getInputStream());
            // 反序列化
            RpcRequest rpcRequest = (RpcRequest) inputStream.readObject();

            // 中间代理执行目标方法
            Mediator mediator = Mediator.getInstance();
            Object response = mediator.processor(rpcRequest);
            System.out.println("服务端的执行结果："+response);

            outputStream = new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeObject(response);
            outputStream.flush();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeStream(inputStream, outputStream);
        }
    }

    private void closeStream(ObjectInputStream inputStream, ObjectOutputStream outputStream) {
        // 关闭流
        if(inputStream!=null){
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (outputStream!=null){
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

服务端代理

Mediator

/**
 * 服务端socket与目标方法的中间代理层
 *
 * @author: ***
 * @date: 2020/6/21 16:25
 */
public class Mediator {

    /** 用来存储发布的服务的实例(服务调用的路由) */
    public static Map<String, BeanMethod> ROUTING = new ConcurrentHashMap<>();

    /** 单例模式创建该代理层实例 */
    private volatile static Mediator instance;

    private Mediator() {
    }

    public static Mediator getInstance() {
        if (instance == null) {
            synchronized (Mediator.class) {
                if (instance == null) {
                    instance = new Mediator();
                }
            }
        }
        return instance;
    }

    public Object processor(RpcRequest rpcRequest) {
        // 路由key
        String routingKey = rpcRequest.getClassName() + "." + rpcRequest.getMethodName();
        BeanMethod beanMethod = ROUTING.get(routingKey);
        if (beanMethod == null) {
            return null;
        }
        // 执行目标方法
        Object bean = beanMethod.getBean();
        Method method = beanMethod.getMethod();
        try {
            return method.invoke(bean, rpcRequest.getArgs());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

BeanMethod

/**
 * 中间层反射调用时，存储目标方法、目标类的实体
 *
 * @author: ***
 * @date: 2020/6/21 16:43
 */
public class BeanMethod {

    private Object bean;

    private Method method;

    // setter、getter略
}

客户端项目

项目结构

服务发现

服务发现我们同样使用注解来做，这就需要参照Spring中@Autowired的原理实现，我们自定义@RpcReference注解，定义在字段上，将接口实现的代理类注入到该字段上。

关注公众号程序员小乐回复关键字“Java”获取Java面试题和答案。

@RpcReference注解

/**
 * 服务注入注解
 *
 * @author: ***
 * @date: 2020/6/20 22:41
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface RpcReference {
}
服务发现类ReferenceInvokeProxy

在spring容器初始化之前，扫描bean中所有@RpcReference注解标记的字段。

/**
 * 远程动态调用service代理
 *
 * @author: ***
 * @date: 2020/6/20 22:44
 */
@Component
public class ReferenceInvokeProxy implements BeanPostProcessor {

    @Autowired
    private RemoteInvocationHandler invocationHandler;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(RpcReference.class)) {
                field.setAccessible(true);
                // 针对这个加了RpcReference注解的字段，设置为一个代理的值
                Object proxy = Proxy.newProxyInstance(field.getType().getClassLoader(), new Class<?>[]{field.getType()}, invocationHandler);
                try {
                    // 相当于针对加了RpcReference的注解，设置了一个代理，这个代理的实现是invocationHandler
                    field.set(bean, proxy);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return bean;
    }
}

客户端代理

客户端动态代理InvocationHandler实现类RemoteInvocationHandler

将目标方法名、目标类名、参数信息封装到RpcRequest，然后交给socket发送到服务端。

/**
 * @author: ***
 * @date: 2020/6/20 22:51
 */
@Component
public class RemoteInvocationHandler implements InvocationHandler {

    @Autowired
    private RpcNetTransport rpcNetTransport;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RpcRequest rpcRequest = new RpcRequest();
        rpcRequest.setClassName(method.getDeclaringClass().getName());
        rpcRequest.setMethodName(method.getName());
        rpcRequest.setTypes(method.getParameterTypes());
        rpcRequest.setArgs(args);
        return rpcNetTransport.send(rpcRequest);
    }
}
客户端socket

网络传输RpcNetTransport

/**
 * rpc socket 网络传输
 *
 * @author: ***
 * @date: 2020/6/20 22:59
 */
@Component
public class RpcNetTransport {
    @Value("${rpc.host}")
    private String host;
    @Value("${rpc.port}")
    private int port;


    public Object send(RpcRequest rpcRequest) {
        ObjectOutputStream outputStream = null;
        ObjectInputStream inputStream = null;
        try {
            Socket socket = new Socket(host, port);
            // 发送目标方法信息
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeObject(rpcRequest);
            outputStream.flush();
   // 接收返回值
            inputStream = new ObjectInputStream(socket.getInputStream());
            return inputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            closeStream(inputStream, outputStream);
        }
        return null;
    }

    private void closeStream(ObjectInputStream inputStream, ObjectOutputStream outputStream) {
        // 关闭流
        if(inputStream!=null){
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (outputStream!=null){
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

欢迎在留言区留下你的观点，一起讨论提高。如果今天的文章让你有新的启发，欢迎转发分享给更多人。欢迎加入程序员小乐技术交流群，在后台回复“加群”或者“学习”即可。

猜你还想看

阿里、腾讯、百度、华为、京东最新面试题汇集

不想CRUD干到老，就来看看这篇OOM排查的实战案例！

面试鹅厂，我被虐的体无完肤！糗大了！

Nginx + Spring Boot 实现负载均衡

关注订阅号「程序员小乐」，收看更多精彩内容

嘿，你在看吗？

程序员小乐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手写一个RPC框架（造轮子）
q952194436的博客
12-16 3548
偶然间看到一个RPC的框架项目，感觉与其他的项目与众不同，所以准备跟着实现一下。由于教程比较少，因此写下这边记录，慢慢踩坑。既然是重复造轮子，自然是以学习框架与组件的运用为主。 1 涉及的知识点 RPC的概念及运作流程。 RPC协议及RPC框架的概念。 Netty的基本使用，修复高并发情况下，netty导致的内存泄漏问题。 Java序列化以及反序列化，protobuf和kryo序列化协议，配置即用。 Zookeeper作为注册中心的基本使用。 自定义注释实现特殊业务逻辑 Java动态代理 自定义Sprin
手写rpc rpc简单源码 rpc源码学习 rpc过程了解 rpc通信原理
09-20
在提供的"school-rpc(手写rpc)"压缩包中，我们可以看到作者实现的客户端和服务端源代码，通过阅读这些代码，可以深入理解RPC的工作流程和实现细节，有助于提升对分布式系统和网络通信的理解。在实际项目中，我们还...
手写简易RPC框架
loseyourself94的博客
05-18 936
手写简易RPC框架
手把手教你手写一个RPC框架
qq_250161537
11-24 5565
前言 最近在看dubbo的源码，所以就参考着这本书籍作为辅助（这个诣极总是让我看成了极诣，嗯，极诣狂战士）： dubbo在3.0版本就有三十万行代码，光看个核心功能的代码就快折磨死人了，为了加强理解，我觉得动手实现一个rpc框架倒是个非常不错的方法。 本文主要会围绕RPC的基本功能来展开。主要是对RPC有个认知，至于SPI、注册中心、负载均衡、netty传递信息等的实现，我会放在下一篇文章中进行讲解。 开篇 市面上有很多RPC框架，虽然种类比较多，但是他们所围绕的中心思想是一样的。我们看下书中是这么介绍的
RPC通信
个人技术博客
04-16 2495
跨语言平台PRC框架，根据IDL（Interface Description Language接口描述语言）定义服务端提供的接口与通信所使用的消息。编译时通过protobuf工具编译成对应的代码，生成的代码与业务代码编译到一起。
由浅入深RPC通信原理实战
赵广陆
05-15 1382
目录 1 背景知识 2 RPC概述 3 RPC框架实现要点 3.1 注册中心 3.2 代理技术 3.3 序列化技术 3.4 RPC通信协议 3.5 系统IO 3.6 超时重试机制 3.7 时间轮算法 3.8 负载均衡策略 3.9 熔断限流 3.10 滑动窗口算法 3.11 限流组件
Netty4.1实战-手写RPC框架.pdf
09-01
本专题主要通过三个章节实现一个rpc通信的基础功能，来学习RPC服务中间件是如何开发和使用。章节内以源码加说明实战方式来讲解，请尽可能下载源码学习。 - 手写RPC框架第一章《自定义配置xml》 - 手写RPC框架第二章...
手写RPC底层实现原理
09-19
在这个“手写RPC底层实现原理”的主题中，我们将深入探讨RPC的工作流程、关键组件以及如何通过Socket进行通信。 一、RPC基本概念 RPC使得分布式系统中的服务可以透明地调用，无需关心调用方与被调用方的实际位置。...
手写RPC框架V1.zip
04-03
本资源“手写RPC框架V1.zip”提供了作者手动实现的一个RPC框架的源代码，包括`rpc-server`和`rpc-client`两个部分，便于学习者深入理解RPC的工作原理。 ### RPC框架概述 RPC框架的核心目标是简化分布式系统间的通信...
Java使用传统socket手写的远程RPC框架调用框架
11-10
通过以上介绍，我们可以看到这个基于Java Socket的手写RPC框架是如何利用核心概念实现远程服务调用的。它简化了分布式系统间的通信，提高了开发效率。然而，实际生产环境中，为了提高性能、稳定性和可扩展性，我们...
RPC通信原理
边博磊的博客
12-21 1431
RPC是一种远程调用技术，能极大地简化分布式应用的开发
聊聊分布式架构04——RPC通信原理
Elaine2391的博客
10-06 2135
RPC（Remote Procedure Call）是一种远程过程调用协议，用于在分布式系统中进行远程通信，允许一个计算机程序调用另一个地址空间（通常是在不同的机器上）的函数或过程，就像调用本地函数一样。在RPC（Remote Procedure Call，远程过程调用）中使用反射的主要目的是实现透明的远程调用，即使在客户端和服务器之间存在远程分离，也可以像调用本地方法一样调用远程服务。
手写一个简单的RPC框架
Miao的博客
03-22 2293
RPC（Remote Procedure Call）即远程过程调用，不同于本地调用，RPC是指调用远端机器的函数或方法，且不需要关心底层的调用细节，如网络协议和传输协议等，对于调用者来说，和调用本地方法没有什么区别。
手写简易版rpc框架，理解远程过程调用原理
lijiale的博客
03-11 2208
手写简易版RPC框架，理解Rpc底层调用原理
如何手写一个RPC？
最新发布
码农小郑有话说的博客
01-16 1372
在学习 RPC 框架之前，我们先来手写一个RPC。我们在学习的过程中，一定要做到知其然，还要知其所以然。
【手写RPC框架（一）】简单RPC实现
xpl_1620的博客
05-03 1164
文章目录一、RPC基本结构二、实现简单的RPC2.1 服务端2.1.1 接口、实现类和序列化2.1.2 服务端逻辑2.2 客户端2.2.1 客户端逻辑2.3 通过RPC远程调用 一、RPC基本结构 \quad\quadRPC(Remote Procedure Call)，即远程过程调用，主要应用在分布式应用中，将服务部署在不同的机器上，通过RPC框架调用远程服务器中的内容。RPC 框架包含三个最重要的组件，分别是客户端、服务端和注册中心。在一次 RPC 调用流程中，这三个组件是这样交互的： 服务端在启动
RPC通讯框架详解
eyes++的博客
05-20 3717
RPC基本理论 从单机走向分布式，产生了很多分布式的通信方式 最古老也是最有效，并且永不过时的，TCP/UDP的二进制传输。事实上所有的通信方式归根结底都是TCP/UDP CORBA Common Object Request Broker Architecture：古老而复杂的，支持面向对象的通信协议 web Service (SOA SOAP RDDI WSDL…)：基于http + xml的标准化Web API RestFul (Representational State Transfer)，回归
手写RPC-简陋版
weixin_38592881的博客
01-07 184
前言 最近不小心被隔离，放假思考一番，决定开始在手写序列。这个序列在之前看Nacous和网关源码的时候就有想法，只是一直没落实下来，趁着隔离行动起来。 必备知识介绍 序列化与反序列化 序列化是把对象的状态信息转化为可存储或传输的形式过程，也就是把对象转化为字节序列的过程称为对象的序列化； 反序列化是序列化的逆向过程，把字节数组反序列化为对象，把字节序列恢复为对象的过程成为对象的反序列化； 在Java中通过 JDK 提供了 Java 对象的序列化方式实现对象序列化传输，主要通过输出流java.io.Objec
RPC实现和原理解析
secret2316352792的博客
09-30 2063
RPC 又名远程过程调用协议RPC（Remote Procedure Call Protocol)

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值