MyRPC版本2

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

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版本: 负载均衡的策略的实现

2.MyRPC 版本2

背景知识
  • 代码解耦
  • 线程池
本节问题：

如果一个服务端要提供多个服务的接口， 例如新增一个BlogService，怎么处理?

// 自然的想到用一个Map来保存，<interfaceName, xxxServiceImpl>
UserService userService = new UserServiceImpl();
BlogService blogService = new BlogServiceImpl();
Map<String, Object>.put("***.userService", userService);
Map<String, Object>.put("***.blogService", blogService);
// 此时来了一个request，我们就能从map中取出对应的服务
Object service = map.get(request.getInterfaceName())
版本升级过程

更新前的工作： 更新一个新的服务接口样例和pojo类

// 新的服务接口
public interface BlogService {
    Blog getBlogById(Integer id);
}
// 服务端新的服务接口实现类
public class BlogServiceImpl implements BlogService {
    @Override
    public Blog getBlogById(Integer id) {
        Blog blog = Blog.builder().id(id).title("我的博客").useId(22).build();
        System.out.println("客户端查询了"+id+"博客");
        return blog;
    }
}
// pojo类
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Blog implements Serializable {
    private Integer id;
    private Integer useId;
    private String title;
}

更新1： HashMap<String, Object> 添加多个服务的实现类

public class TestServer {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        BlogService blogService = new BlogServiceImpl();
        Map<String, Object> serviceProvide = new HashMap<>();
        // 暴露两个服务接口， 即在RPCServer中加一个HashMap
        serviceProvide.put("com.ganghuan.myRPCVersion2.service.UserService",userService);
        serviceProvide.put("com.ganghuan.myRPCVersion2.service.BlogService",blogService);
        RPCServer RPCServer = new SimpleRPCRPCServer(serviceProvide);
        RPCServer.start(8899);
    }
}
// 这里先不去讨论实现其中的细节，因为这里还应该进行优化，我们先去把服务端代码松耦合，再回过来讨论

更新2： 服务端代码重构

  1. 抽象RPCServer，开放封闭原则
// 把RPCServer抽象成接口，以后的服务端实现这个接口即可
public interface RPCServer {
    void start(int port);
    void stop();
}
  1. RPCService简单版本的实现
/**
 * 这个实现类代表着java原始的BIO监听模式，来一个任务，就new一个线程去处理
 * 处理任务的工作见WorkThread中
 */
public class SimpleRPCRPCServer implements RPCServer {
    // 存着服务接口名-> service对象的map
    private Map<String, Object> serviceProvide;
    public SimpleRPCRPCServer(Map<String,Object> serviceProvide){
        this.serviceProvide = serviceProvide;
    }
    public void start(int port) {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务端启动了");
            // BIO的方式监听Socket
            while (true){
                Socket socket = serverSocket.accept();
                // 开启一个新线程去处理
                new Thread(new WorkThread(socket,serviceProvide)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }
    public void stop(){
    }
}
  1. 为了加强性能，我们还提供了线程池版的实现
public class ThreadPoolRPCRPCServer implements RPCServer {
    private final ThreadPoolExecutor threadPool;
    private Map<String, Object> serviceProvide;
    public ThreadPoolRPCRPCServer(Map<String, Object> serviceProvide){
        threadPool = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                1000, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
        this.serviceProvide = serviceProvide;
    }
    public ThreadPoolRPCRPCServer(Map<String, Object> serviceProvide, int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue){
        
        threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.serviceProvide = serviceProvide;
    }
    @Override
    public void start(int port) {
        System.out.println("服务端启动了");
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while(true){
                Socket socket = serverSocket.accept();
                threadPool.execute(new WorkThread(socket,serviceProvide));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void stop() {
    }
}
  1. 工作任务类，从服务端代码分离出来，简化服务端代码，单一职责原则
/**
 * 这里负责解析得到的request请求，执行服务方法，返回给客户端
 * 1. 从request得到interfaceName 2. 根据interfaceName在serviceProvide Map中获取服务端的实现类
 * 3. 从request中得到方法名，参数， 利用反射执行服务中的方法 4. 得到结果，封装成response，写入socket
 */
@AllArgsConstructor
public class WorkThread implements Runnable{
    private Socket socket;
    private Map<String, Object> serviceProvide;
    @Override
    public void run() {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            // 读取客户端传过来的request
            RPCRequest request = (RPCRequest) ois.readObject();
            // 反射调用服务方法获得返回值
            RPCResponse response = getResponse(request);
            //写入到客户端
            oos.writeObject(response);
            oos.flush();
        }catch (IOException | ClassNotFoundException e){
            e.printStackTrace();
            System.out.println("从IO中读取数据错误");
        }
    }
    private RPCResponse getResponse(RPCRequest request){
        // 得到服务名
        String interfaceName = request.getInterfaceName();
        // 得到服务端相应服务实现类
        Object service = serviceProvide.get(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();
        }
    }
}

服务端代码第一次重构完毕。

更新3： 服务暴露类，这里回到了更新1**，我们发现服务接口名是我们**直接手写的，这里其实可以利用class对象自动得到

/**
 * 之前这里使用Map简单实现的
 * 存放服务接口名与服务端对应的实现类
 * 服务启动时要暴露其相关的实现类0
 * 根据request中的interface调用服务端中相关实现类
 */
public class ServiceProvider {
    /**
     * 一个实现类可能实现多个接口
     */
    private Map<String, Object> interfaceProvider;
    public ServiceProvider(){
        this.interfaceProvider = new HashMap<>();
    }
    public void provideServiceInterface(Object service){
        String serviceName = service.getClass().getName();
        Class<?>[] interfaces = service.getClass().getInterfaces();
        for(Class clazz : interfaces){
            interfaceProvider.put(clazz.getName(),service);
        }
    }
    public Object getService(String interfaceName){
        return interfaceProvider.get(interfaceName);
    }
}

前面服务端的代码中有Sevicerprovide 这个HashMap的地方需要改成ServiProvider，比如

public class TestServer {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        BlogService blogService = new BlogServiceImpl();
//        Map<String, Object> serviceProvide = new HashMap<>();
//        serviceProvide.put("com.ganghuan.myRPCVersion2.service.UserService",userService);
//        serviceProvide.put("com.ganghuan.myRPCVersion2.service.BlogService",blogService);
        ServiceProvider serviceProvider = new ServiceProvider();
        serviceProvider.provideServiceInterface(userService);
        serviceProvider.provideServiceInterface(blogService);
        
        RPCServer RPCServer = new SimpleRPCRPCServer(serviceProvider);
        RPCServer.start(8899);
    }
}
结果
// 客户中添加新的测试用例        
BlogService blogService = rpcClientProxy.getProxy(BlogService.class);
Blog blogById = blogService.getBlogById(10000);
System.out.println("从服务端得到的blog为：" + blogById);

image-20200805221430990

总结：

在一版本中，我们重构了服务端的代码，代码更加简洁，

添加线程池版的服务端的实现，性能应该会有所提升（未测）

并且服务端终于能够提供不同服务了， 功能更加完善，不再鸡肋

此RPC最大的痛点
  1. 传统的BIO与线程池网络传输性能低
冬日追梦少年
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
myrpc
02-21
2. **RPC原理**：RPC的基本思想是客户端发起一个请求，包含要调用的远程服务方法和参数，服务器接收到请求后执行相应的方法，然后将结果返回给客户端。myrpc实现这一过程时，可能涉及到序列化和反序列化（如JSON或...
MyRPC:一个易用、实用、高可用的分布式RPC框架，基于netty，Protostuff，Zookeeper，Quartz等框架
04-26
2.特性： 连通性 注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小，服务提供者向注册中心注册其提供的服务，服务消费者向注册中心...
myRpc一个极简单的RPC框架
10-20
在这个名为“myRpc”的项目中，我们看到作者提供了一个非常基础的RPC实现，它可能是为了帮助学习者理解RPC的基本原理和工作流程，以及对比更成熟的框架如Hessian。 首先，我们要了解RPC的基本概念。RPC框架的核心...
myrpc-自主实习的RPC工具框架
03-26
2. **服务消费者（Service Consumer）**：客户端应用，通过RPC框架来调用服务提供者提供的服务。客户端并不需要知道服务提供者的具体位置，只需调用接口即可。 3. **服务注册与发现（Service Registry & Discovery...
my_rpc:通过RabbitMq的RPC的简单实现
04-09
MyRpc 这是带有标头交换的基于RabbitMQ的RPC的简单实现。 我受到一篇文章的启发。 安装 使用以下命令下载并运行RabbitMQ服务： docker run -d --rm --hostname localhost --name rabbitmq -p 15672:15672 -p 5672:...
RPC与服务的注册发现
AaronCao
07-14 1125
主要介绍RPC的工作流程和原理以及和REST的区别，同时针对RPC相关的实施gRPC进行实践，最后介绍了关于RPC的服务注册与发现相关的实现。
DangerWind-RPC-framework---八、Netty网络通信
m0_60424152的博客
07-15 557
客户端与服务端之间发送数据需要进行网络通信，而Netty恰好是一款出色的网络通信框架，Netty底层实现依赖于NIO，其工作线程组EventLoopGroup中的每一个EventLoop可以理解为一个线程，与NIO类似，EventLoopGroup的工作也是基于事件响应的，可以理解为bossEventLoop负责监听连接事件，并建立连接，众多workEventLoop监听读事件，在channel可读时读入数据并进行处理。因此需要自定义rpc协议，这也是rpc与http的区别之一。
第二章：pod-运行于kubernetes中的容器
weixin_54279427的博客
07-17 822
本章内容包括pod是kubernetes中最为重要的核心概念，其他对象仅仅为管理、暴露pod或被pod使用。
第五章：卷-将磁盘挂载到容器
weixin_54279427的博客
07-17 588
Kubernetes的卷是pod的一个组成部分，因此卷在pod的规范中定义。它们不是独立的Kubernetes资源，也不能单独创建或删除。pod中所有容器都可以使用卷，但必须先将它挂载在每个需要访问它的容器中。在每个容器中都可以在文件系统的任意位置挂载卷。
使用Java和Apache Thrift构建高效的RPC服务
微赚淘客开发者博客
07-18 694
Apache Thrift是一种开源的RPC框架，支持多种编程语言，能够高效地进行跨语言服务调用。本文将介绍如何使用Java和Apache Thrift构建高效的RPC服务，包括Thrift的基础配置、IDL定义、服务实现和客户端调用等。通过本文的介绍，我们了解了如何使用Java和Apache Thrift构建高效的RPC服务，包括Thrift接口定义、服务端和客户端实现、性能优化和容错设计等方面。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！首先，创建一个实现了。
DangerWind-RPC-framework---七、序列化算法
m0_60424152的博客
07-14 248
Kryo序列化算法性能较好，但是是线程不安全的，因此需要进行线程隔离，通过ThreadLocal为每个线程维护一个Kryo对象，使用完毕后就remove掉，之后需要使用时再次在threadLocal中初始化一个Kryo对象，这也是withInitial懒加载的过程。三种序列化算法的实现过程中，主要是需要对线程不安全的隐患进行处理，比如进行隔离等操作，以保证序列化操作的正确执行。客户端与服务端的在交互过程中需要互相发送交换数据，这就需要对传输对象进行序列化与反序列化操作，此过程涉及到序列化算法的使用。
RPC 的原理和示例
goTsHgo的博客
07-15 1007
/ 定义服务// 定义一个RPC方法// 请求消息// 响应消息。
什么是RPC
最新发布
weixin_60246228的博客
07-18 66
在Java中，我们可以通过直接使用某个服务接口的代理对象来执行方法，而底层则通过构造HTTP请求来调用远端的方法，所以，有一种说法是RPC协议是HTTP协议之上的一种协议，也是可以理解的。RPC调用和HTTP调用是有区别的，RPC表示的是一种调用远程方法的方式，可以使用HTTP协议、或直接基于TCP协议来实现RPC，RPC，表示远程过程调用，对于Java这种面试对象语言，也可以理解为远程方法调用，
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 819
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 888
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1018
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 824
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【JAVA】相关程序组件
qq_44077764的博客
07-15 153
【JAVA】相关程序组件
【Java算法】前缀和 下
2302_79806056的博客
07-18 681
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 511
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值