MyRPC版本3

已于 2022-02-09 11:40:28 修改
阅读量537 收藏
点赞数 2
分类专栏： 网络编程 netty 文章标签： rpc java 网络 netty
于 2022-02-09 11:36:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58680364/article/details/122838610
版权

RPC的概念

背景知识
  • RPC的基本概念，核心功能

image-20200805001037799

常见的RPC框架

Duboo基本功能
  1. 远程通讯
  2. 基于接口方法的透明远程过程调用
  3. 负载均衡
  4. 服务注册中心
RPC过程

client 调用远程方法-> request序列化 -> 协议编码 -> 网络传输-> 服务端 -> 反序列化request -> 调用本地方法得到response -> 序列化 ->编码->……

版本迭代过程

目录

从0开始的RPC的迭代过程：

  • version0版本：以不到百行的代码完成一个RPC例子
  • version1版本：完善通用消息格式（request，response），客户端的动态代理完成对request消息格式的封装
  • version2版本：支持服务端暴露多个服务接口， 服务端程序抽象化，规范化
  • version3版本：使用高性能网络框架netty的实现网络通信，以及客户端代码的重构
  • version4版本：自定义消息格式，支持多种序列化方式（java原生， json…）
  • version5版本: 服务器注册与发现的实现，zookeeper作为注册中心
  • version6版本: 负载均衡的策略的实现

3.MyRPC版本3

背景知识
  • netty高性能网络框架的使用
本节问题

如何提升这个rpc的性能? 可以从两个方面入手，网络传输从BIO到NIO，序列化要减少字节流长度，提高序列化反序列化效率

知名的rpc框架：dubbo， grpc都是使用netty底层进行通信的

升级过程：

前提： maven pom.xml文件引入netty

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.51.Final</version>
</dependency>

升级1： 重构客户端代码

客户端的代码太乱了， 我们先进行代码重构，才有利于后面使用netty的方式实现客户端，使之不同方式网络连接的客户端有着同样的结构，同样的api

假如我们现在已经有了两个客户端：SimpleRPCClient(使用java BIO的方式)， NettyRPCClient（使用netty进行网络传输），那么它们两者的共性是啥?发送请求与得到response是共性， 而建立连接与发送请求的方式是不同点。

// 共性抽取出来
public interface RPCClient {
    RPCResponse sendRequest(RPCRequest response);
}
// SimpleRPCClient实现这个接口，不同的网络方式有着不同的实现
@AllArgsConstructor
public class SimpleRPCClient implements RPCClient{
    private String host;
    private int port;
    // 客户端发起一次请求调用，Socket建立连接，发起请求Request，得到响应Response
    // 这里的request是封装好的，不同的service需要进行不同的封装， 客户端只知道Service接口，需要一层动态代理根据反射封装不同的Service
    public RPCResponse sendRequest(RPCRequest request) {
        try {
            // 发起一次Socket连接请求
            Socket socket = new Socket(host, port);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            System.out.println(request);
            objectOutputStream.writeObject(request);
            objectOutputStream.flush();
            RPCResponse response = (RPCResponse) objectInputStream.readObject();
            //System.out.println(response.getData());
            return response;
        } catch (IOException | ClassNotFoundException e) {
            System.out.println();
            return null;
        }
    }
}

而RPCClientProxy类中需要加入一个RPCClient类变量即可， 传入不同的client(simple,netty), 即可调用公共的接口sendRequest发送请求，所以客户端代码结构很清晰了:

  • RPCClient: 不同的网络连接，网络传输方式的客户端分别实现这个接口

  • XXXRPCClient: 具体实现类

  • RPCClientProxy： 动态代理Service类，封装不同的Service请求为Request对象，并且持有一个RPCClient对象，负责与服务端的通信，

由此，客户端代码重构完毕，结构更为清晰，一个使用用例为：

// 构建一个使用java Socket传输的客户端
SimpleRPCClient simpleRPCClient = new SimpleRPCClient("127.0.0.1", 8899);
// 把这个客户端传入代理客户端
RPCClientProxy rpcClientProxy = new RPCClientProxy(simpleRPCClient);
// 代理客户端根据不同的服务，获得一个代理类， 并且这个代理类的方法以或者增强（封装数据，发送请求）
UserService userService = rpcClientProxy.getProxy(UserService.class);
// 调用方法
User userByUserId = userService.getUserByUserId(10);

升级2： 使用netty方式传输数据：实现NettyRPCServer， NettyRPCCLient，这里建议先学习下netty的启动代码

netty 服务端的实现

/**
 * 实现RPCServer接口，负责监听与发送数据
 */
@AllArgsConstructor
public class NettyRPCServer implements RPCServer {
    private ServiceProvider serviceProvider;
    @Override
    public void start(int port) {
        // netty 服务线程组boss负责建立连接， work负责具体的请求
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workGroup = new NioEventLoopGroup();
        System.out.printf("Netty服务端启动了...");
        try {
            // 启动netty服务器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 初始化
            serverBootstrap.group(bossGroup,workGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new NettyServerInitializer(serviceProvider));
            // 同步阻塞
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            // 死循环监听
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
    @Override
    public void stop() {
    }
}

netty server初始化类

/**
 * 初始化，主要负责序列化的编码解码， 需要解决netty的粘包问题
 */
@AllArgsConstructor
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
    private ServiceProvider serviceProvider;
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        // 消息格式 [长度][消息体], 解决粘包问题
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4));
        // 计算当前待发送消息的长度，写入到前4个字节中
        pipeline.addLast(new LengthFieldPrepender(4));
        // 这里使用的还是java 序列化方式， netty的自带的解码编码支持传输这种结构
        pipeline.addLast(new ObjectEncoder());
        pipeline.addLast(new ObjectDecoder(new ClassResolver() {
            @Override
            public Class<?> resolve(String className) throws ClassNotFoundException {
                return Class.forName(className);
            }
        }));
        pipeline.addLast(new NettyRPCServerHandler(serviceProvider));
    }
}

netty server具体的handler

/**
 * 因为是服务器端，我们知道接受到请求格式是RPCRequest
 * Object类型也行，强制转型就行
 */
@AllArgsConstructor
public class NettyRPCServerHandler extends SimpleChannelInboundHandler<RPCRequest> {
    private ServiceProvider serviceProvider;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RPCRequest msg) throws Exception {
        //System.out.println(msg);
        RPCResponse response = getResponse(msg);
        ctx.writeAndFlush(response);
        ctx.close();
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
    RPCResponse getResponse(RPCRequest request) {
        // 得到服务名
        String interfaceName = request.getInterfaceName();
        // 得到服务端相应服务实现类
        Object service = serviceProvider.getService(interfaceName);
        // 反射调用方法
        Method method = null;
        try {
            method = service.getClass().getMethod(request.getMethodName(), request.getParamsTypes());
            Object invoke = method.invoke(service, request.getParams());
            return RPCResponse.success(invoke);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
            System.out.println("方法执行错误");
            return RPCResponse.fail();
        }
    }
}

客户端netty的实现

/**
 * 实现RPCClient接口
 */
public class NettyRPCClient implements RPCClient {
    private static final Bootstrap bootstrap;
    private static final EventLoopGroup eventLoopGroup;
    private String host;
    private int port;
    public NettyRPCClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    // netty客户端初始化，重复使用
    static {
        eventLoopGroup = new NioEventLoopGroup();
        bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                .handler(new NettyClientInitializer());
    }
    /**
     * 这里需要操作一下，因为netty的传输都是异步的，你发送request，会立刻返回， 而不是想要的相应的response
     */
    @Override
    public RPCResponse sendRequest(RPCRequest request) {
        try {
            ChannelFuture channelFuture  = bootstrap.connect(host, port).sync();
            Channel channel = channelFuture.channel();
            // 发送数据
            channel.writeAndFlush(request);
            channel.closeFuture().sync();
            // 阻塞的获得结果，通过给channel设计别名，获取特定名字下的channel中的内容（这个在hanlder中设置）
            // AttributeKey是，线程隔离的，不会由线程安全问题。
            // 实际上不应通过阻塞，可通过回调函数
            AttributeKey<RPCResponse> key = AttributeKey.valueOf("RPCResponse");
            RPCResponse response = channel.attr(key).get();
            System.out.println(response);
            return response;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

初始化： 与服务端一致，就不贴代码了

ClientHandler设计：

public class NettyClientHandler extends SimpleChannelInboundHandler<RPCResponse> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RPCResponse msg) throws Exception {
        // 接收到response, 给channel设计别名，让sendRequest里读取response
        AttributeKey<RPCResponse> key = AttributeKey.valueOf("RPCResponse");
        ctx.channel().attr(key).set(msg);
        ctx.channel().close();
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
结果：

image-20200807172435854

image-20200807172418651

总结

此版本我们完成了客户端的重构，使之能够支持多种版本客户端的扩展（实现RPCClient接口）

并且使用netty实现了客户端与服务端的通信

此RPC最大痛点

java自带序列化方式（Java序列化写入不仅是完整的类名，也包含整个类的定义，包含所有被引用的类），不够通用，不够高效

冬日追梦少年
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyRPC:一个易用、实用、高可用的分布式RPC框架，基于netty，Protostuff，Zookeeper，Quartz等框架
04-26
一、背景 dubbo在开源rpc界是无敌的存在，稳定，用户多，但是在某些领域，例如javase，非web场景，或者不使用spring的场景，就急需一个轻量级别的rpc框架，于是MyRPC就这样被背景下诞生了, 二、简介 MyRPC是一个可用于生产环境的轻量级，高可用，高性能，高易用分布式远程调用框架，参考dubbo的设计，是一个五脏俱全的简易版dubbo,支持同步调用，异步调用，服务自动注册，定时调度系统等。 1.架构 2.特性： 连通性 注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小，服务提供者向注册中心注册其提供的服务，服务消费者向注册中心获取服务提供者地址列表，并根据负载算法直接调用提供者 注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者 健壮性 注册中心对等集群，任意
探索高效远程调用：MyRPC - 简单、快速、可扩展
gitblog_00043的博客
04-23 416
探索高效远程调用：MyRPC - 简单、快速、可扩展 项目地址:https://gitcode.com/Sniper2016/MyRPC 项目简介 MyRPC 是一个轻量级的、高性能的Java RPC（远程过程调用）框架，旨在简化分布式系统间的通信。通过MyRPC，开发者可以像调用本地方法一样调用远端服务，极大地提高了开发效率并降低了复杂性。 技术分析 MyRPC的核心特性包括： 基于HTTP...
核心项目：MyRPC——基于Java语言实现的RPC框架
燕双嘤
09-05 7960
RPC：Remote Procedure Call，即远程过程调用。远程过程调用是一种像调用本地过程一样调用远程机器上的过程，而不需要了解网络细节的远程过程访问支持机制。 由于基于套接字的开发方式，因此带来了开发繁琐和排错困难的问题。
myRpc
Tzecto
05-20 257
文章目录集群和分布式集群单机服务器切换到集群服务器所有服务器共同构成一个聊天系统集群和分布式分布式问题RPC通信原理protobuf的使用从业务出发谈怎么使用一个框架定义protobuf，然后生成相关代码本地服务怎么发布成RPC服务框架使用MprpcApplicationRpcProvider这里使用ServiceInitprovider+channelRpcProvider的网络服务在rpc上面发布服务-map表接受一个rpc调用请求的时候，它怎么知道要调用应用程序的哪个服务对象的哪个rpc方法呢？请求的
造轮子实现RPC框架_01_MyRPCFramework简介
hellosrc的博客
03-08 1508
项目简介: 造轮子实现"MyRPCFramework"框架 RPC介绍: RPC是让客户端远程调用服务端方法 就像 调用本地方法一样简单的一种设计理念 一个最简单的 RPC 框架架构 ： 技术要点: SPI+注册中心+Socket编程+享元模式+动态代理+反射 MyRPCFramework框架流程: 服务端集群 把自己能提供的服务 注册进ZooKeeper 客户端定义一个和服务端相同的接口, 然后生成这个接口的代理实现类, 代理负责(封装数据包, 拆解数据包, 访问ZooKeerper得到服务端ip
myrpc
02-21
myrpc
myRpc一个极简单的RPC框架
10-20
一个自己实现的极为简单的RPC框架，可以用来做Hessian等技术框架研究的参考。
myrpc-自主实习的RPC工具框架
03-26
自主实现的RPC工具框架，非常方便使用与学习，非常高效，可靠
my_rpc:通过RabbitMq的RPC的简单实现
04-09
docker run -d --rm --hostname localhost --name rabbitmq -p 15672:15672 -p 5672:5672 rabbitmq:3-management 呼叫者 要启动呼叫者的服务，请运行以下命令： iex -S mix MyRpc.Application.start_caller() 这将...
MyRPC版本4
冬日追梦少年的博客
02-09 511
RPC是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据
My-RPC-Framework:一个简单的RPC框架的实现
04-14
My-RPC-Framework My-RPC-Framework 是一款基于 Nacos 实现的 RPC 框架。网络传输实现了基于 Java 原生 Socket 与 Netty 版本，并且实现了多种序列化与负载均衡算法。 架构 消费者调用提供者的方式取决于消费者的客户端选择，如选用原生 Socket 则该步调用使用 BIO，如选用 Netty 方式则该步调用使用 NIO。如该调用有返回值，则提供者向消费者发送返回值的方式同理。 特性 实现了基于 Java 原生 Socket 传输与 Netty 传输两种网络传输方式 实现了四种序列化算法，Json 方式、Kryo 算法、Hessian 算法与 Google Protobuf 方式（默认采用 Kryo方式序列化） 实现了两种负载均衡算法：随机算法与轮转算法 使用 Nacos 作为注册中心，管理服务提供者信息 消费端如采用 Netty 方式，
简单的netty实现的rpc
张艳秋的博客
03-28 3434
 一，自定义rpc框架的思路RPC（RemoteProcedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。RPC采用客户机...
手写一个简单的RPC
yinbucheng的博客
04-21 2126
public class MyRPC { private static ExecutorService threadTool = Executors.newFixedThreadPool(5); // 客户端 public static Object getProxy(Class clazz, String ip, int port) throws Exception { //
RPC 框架梳理——rpc框架对远程调用的处理流程梳理
qq_39515533的博客
05-20 380
背景   当rpc服务的发布方启动了rpc服务的发布节点后，rpc服务的提供方便进入阻塞状态，等待远程的rpc调用请求。   首先我们要梳理，在run中，rpc框架主要做了哪些事情。因为myrpc框架是基于木朵网络库开发的，所以网络部分使用了muduo的epoll+多线程。Run()主要工作就是提供rpc网络监听。   主要设置有新连接时的回调处理、设置有新消息（有rpc请求）时的回调处理。本文主要梳理当有rpc请求时的框架处理流程。 有rpc
RPC 框架梳理——RPC使用方的调用流程梳理
qq_39515533的博客
05-22 493
背景  myrpc是基于protobuf开发的远程调用框架，对于rpc服务，在proto文件中的定义如下：    经过protoc编译后，会生成两个类：UserServiceRpc 和 UserServiceRpc_Stub，在之前的文章中已经分析过，UserServiceRpc_Stub类是继承于UserServiceRpc，两者均继承于protobuf中是service这个基类，其中UserServiceRpc_Stub是供rpc访问的消费者（调用方）使用。
自主实现RPC工具-myrpc
路漫漫 始于足下
03-16 1178
    源码位置：https://github.com/AsPhilosopher/myrpc    源码下载：https://download.csdn.net/download/jobsandczj/10309380    RPC(Remote Procedure Call)，远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。在如今分布式盛行的年代，这一...
UE4 RPC进行网络同步
最新发布
zxh1592000的博客
06-11 364
PS:引申：考虑到每一位客户端对该actor接管网络消息所有权都需要SetOwner，可能会导致网络延迟或安全性隐患，此处可以根据实际情况进行优化为通过经过玩家进行RPC同步，如由玩家的component发起。3、注意如果 RPC 是从Client调用并在Server上执行，客户端就必须拥有调用 RPC 的 Actor。所以在属性同步的地方设置此Actor的Owner，主要用于网络复制，玩家离开交互时Owner置空。服务端的处理：定义自定义事件，注意勾选同步范围，代表客户端同步在仅Server运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值