手写RPC第一版

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量178 收藏
点赞数
文章标签： java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011622408/article/details/106911703
版权

手写RPC第一版

前言

通过学习，将自己掌握的的技术记录下来，以便后面学习。

创建项目

创建两个项目，一个用户系统user-server，一个商品系统goods-server。系统goods-server系统有两个Module分别是goods-api（商品系统的接口模块），goods-provider（提供具体的服务）。user-server和goods-server分别部署到不同的服务器上，模拟goods-server服务中提供一个IGoodsService接口，接口中描述两个方法，queryGoodsList（），queryGoodsById（String id）。user-server服务通过socket远程调用GoodsServer中的api。
接下来我们先写goods-server这个服务

goods-api

创建一个RpcRequest类，该类作为user-server和goods-server两个服务间通过Socket远程调用时传输的数据，所以实现Serializable，序列化及反序列化。

import java.io.Serializable;
import java.util.Arrays;

/**
 * 用于socket传输数据，所以要实现Serializable接口。
 */
public class RpcRequest implements Serializable {

    // 类名称
    private String className;
    // 方法名称
    private String methodName;
    // 方法参数
    private Object[] args;
    // 参数类型
    private Class[] types;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }

    public Class[] getTypes() {
        return types;
    }

    public void setTypes(Class[] types) {
        this.types = types;
    }

    @Override
    public String toString() {
        return "RpcRequest{" +
                "className='" + className + '\'' +
                ", methodName='" + methodName + '\'' +
                ", args=" + Arrays.toString(args) +
                ", types=" + Arrays.toString(types) +
                '}';
    }
}

创建一个接口，用于客户端调用。

/**
 * 用户客户端调用的api
 */
public interface IGoodsService {

    String queryGoodsList();

    String queryGoodsById(String id);
}

goods-provider

创建一个GoodsServiceImpl，实现IGoodsService中的方法

public class GoodsServiceImpl implements IGoodsService {
    @Override
    public String queryGoodsList() {
        return "EXECUTE QUERY_LIST METHOD";
    }

    @Override
    public String queryGoodsById(String id) {
        return "EXECUTE QUERY_INFO METHOD";
    }
}

创建一个RpcProxyServer类，用来提供发布服务的方法publisher（），其中正常的Socket通信，会产生IO阻塞（客户端A调用服务，处于阻塞状态时，客户端B是无法调用服务的），所以第一版本采用线程池的方式，去提高服务端处理多客户端请求的性能。ProcessHandler这个类用来处理服务端接收到的请求以及返回客户端的数据。

public class RpcProxyServer {

    private final ExecutorService executorService = Executors.newCachedThreadPool();

    public void publisher(Object service, int port) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);// 阻塞

            while (true) {
                // 获得Socket对象
                Socket socket = serverSocket.accept();
                // 通过线程池提供服务处理客户端远程调用的能力
                executorService.execute(new ProcessHandler(service, socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ProcessHandler 类在run方法中通过ObjectInputStream获取客户端请求的参数RpcRequest，在通过invoke方法反射调用服务端的服务，在通过ObjectOutputStream将result返回给客户端。

public class ProcessHandler implements Runnable {

    private Object service;
    private Socket socket;

    public ProcessHandler(Object service, Socket socket) {
        this.service = service;
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectInputStream inputStream = null;
        ObjectOutputStream outputStream = null;

        try {
            // 读取客户端请求过来的数据
            inputStream = new ObjectInputStream(socket.getInputStream());
            RpcRequest request = (RpcRequest) inputStream.readObject();
            // 根据客户端请求参数调用服务端具体的服务
            Object result = invoke(request);
			System.out.println("服务端处理的结果：" + result);

            // 将服务端返回的数据写会给客户端
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeObject(result);
            outputStream.flush();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 根据客户端请求参数调用服务端具体的服务
    private Object invoke(RpcRequest request) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 获取请求的类名
        String className = request.getClassName();
        // 获得具体的类
        Class<?> clazz = Class.forName(className);
        // 通过方法名称及参数类型，获得具体的方法
        Method method = clazz.getMethod(request.getMethodName(), request.getTypes());
        // 通过反射调用方法
        return method.invoke(service, request.getArgs());
    }
}

user-server

接下来我们先写user-server这个服务
首先写一个动态代理类，提供clientProxy方法，该方法需要传入客户端Socket连接的Ip，和端口，以及要代理哪个类

public class RpcProxyClient {

    public <T> T clientProxy(final Class<T> interfaceCls, final String host, final int port) {
        return (T) Proxy.newProxyInstance(interfaceCls.getClassLoader(), new Class<?>[] {interfaceCls}, new RemoteInvocationHandler(host, port));
    }
}

代理对象的具体操作在RemoteInvocationHandler中去实现。首先组装RpcRequest参数，然后通过RpcNetTransport远程调用服务端

public class RemoteInvocationHandler implements InvocationHandler {
    private String host;
    private int port;

    public RemoteInvocationHandler(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 组装RpcRequest
        RpcRequest request = new RpcRequest();
        request.setClassName(method.getDeclaringClass().getName());
        request.setMethodName(method.getName());
        request.setArgs(args);
        request.setTypes(method.getParameterTypes());
        // 调用远程服务
        RpcNetTransport netTransport = new RpcNetTransport(host, port);
        Object result = netTransport.send(request);
        return result;
    }
}

RpcNetTransport 提供一个newSocket（）方法，通过host，port获取Socket连接。然后提供send（）方法，远程调用服务端。

public class RpcNetTransport {
    private String host;
    private int port;

    public RpcNetTransport(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public Socket newSocket() throws IOException {
        Socket socket = new Socket(host, port);
        return socket;
    }

    public Object send(RpcRequest request) {
        ObjectOutputStream outputStream = null;
        ObjectInputStream inputStream = null;

        try {
            // 获得Socket连接
            Socket socket = newSocket();

            // 向服务器写数据
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeObject(request);
            outputStream.flush();

            // 读取服务器返回数据
            inputStream = new ObjectInputStream(socket.getInputStream());
            Object result = inputStream.readObject();
            return result;

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

服务端测试类

public class App {
    public static void main( String[] args ) {
        IGoodsService goodsService = new GoodsServiceImpl();
        RpcProxyServer server = new RpcProxyServer();
        server.publisher(goodsService, 8080);
    }
}

客户端测试类

public class App {
    public static void main( String[] args ) {
        RpcProxyClient client = new RpcProxyClient();
        IGoodsService goodsService = client.clientProxy(IGoodsService.class, "localhost", 8080);
        System.out.println(goodsService.queryGoodsById("test"));
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
        System.out.println(goodsService.queryGoodsList());
    }
}

服务端打印结果：

服务端处理的结果：EXECUTE QUERY_INFO METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD
服务端处理的结果：EXECUTE QUERY_LIST METHOD

客户端打印结果：

EXECUTE QUERY_INFO METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD
EXECUTE QUERY_LIST METHOD

最后

本文是自己学习后，变成自己的知识，默写出来的。主要是用来以后自己查看方便使用。下篇文章将基于这个版本实现通过注解的方式调用和发布服务。

大脑袋虾
关注
商家后台-商品录入【基本信息】
huangyh技术栈
11-24 5649
1.1 需求分析 在商家后台实现商品录入功能，实际是对tb_goods、tb_goods_desc、tb_item这三张表做插入数据操作。 基本信息包括：商品名称、副标题、价格、包装列表、售后服务 问题：页面表单数据如何封装？因为我们要操作的是tb_goods、tb_goods_desc、tb_item三张表，而tb_goods和另外两张表都有关系，所以我们使用tb_goods...
电商项目---service_iml
weixin_44343477的博客
06-21 317
service_iml pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://mave
srping 框架中service层成员变量
浮沉浪似人潮的博客
09-27 9151
srping 框架中service层成员变量 service中能够用成员变量？怎么用？  这个问题实际和servlet中能否使用成员变量是一个道理，首先我们来聊一聊servlet，servlet是单实例，多线程操作， 当我们第一次访问servlet的时候，服务器创建servlet，一直到我们的服务停掉。 假设我们现在servlet定义了一个成员变量，在servlet初始化的时候，系统为该成
用SpringCloud Alibaba搭建属于自己的微服务(三十)~业务开发~扣库存接口开发
theOldCaptain的博客
08-13 471
一.概述 这一个章节开始讲解商品扣库存. 二.新建微服务server-goods 1.创建server-goods的maven工程. 2.server-goods.pom中引入mysql依赖. <dependencies> <dependency> <groupId>com.ccm</groupId> <artifactId>assembly-mysql</artifactId>
手写RPC-简陋版
weixin_38592881的博客
01-07 188
前言 最近不小心被隔离，放假思考一番，决定开始在手写序列。这个序列在之前看Nacous和网关源码的时候就有想法，只是一直没落实下来，趁着隔离行动起来。 必备知识介绍 序列化与反序列化 序列化是把对象的状态信息转化为可存储或传输的形式过程，也就是把对象转化为字节序列的过程称为对象的序列化； 反序列化是序列化的逆向过程，把字节数组反序列化为对象，把字节序列恢复为对象的过程成为对象的反序列化； 在Java中通过 JDK 提供了 Java 对象的序列化方式实现对象序列化传输，主要通过输出流java.io.Objec
手写RPC框架（一）
zzzzzzzzzzzyt的博客
05-22 511
手写RPC框架 纯手写？！ 笔记详细
手写RPC框架项目代码解读——Netty版本
qq_41523340的博客
10-15 1059
使用注解开发，而不是xml配置文件，好处是便捷性，操作性。 @Builder主要作用是用来生成对象，并能够进行链式赋值。 @RpcService放在服务实现类上。 @RpcReference放在服务引用上。
手写RPC框架项目代码解读——Socket版本
qq_41523340的博客
10-12 1856
项目地址：https://github.com/Snailclimb/guide-rpc-framework。1、RPC服务名 = 接口名字 + 组号 + 版本号 2、zookeeper服务路径规定如下： 例如： 问题描述 1、如果在服务器运行时，IP地址改变，那么钩子函数将不能在zookeeper客户端中删去结点 原因：inetSocketAddress改变，但是静态的REGISTERED_PATH_SET不会改变。 解决：REGISTERED_PATH_SET直接删除，不要加if判断 1、基于Socke
Netty4.1实战-手写RPC框架.pdf
03-26
##### 3.1 第一章：自定义配置XML - **目标**：定义一套自定义XML配置文件，以便更灵活地管理RPC服务的相关配置信息。 - **实现步骤**： 1. **定义XML Schema**：创建一个XML Schema文件（rpc.xsd），规定合法的...
手写RPC框架Feign
Lailai Monkey的博客
09-17 2636
手写RPC框架feign
从零开始手写RPC框架（番外） Netty基础知识点及常见面试题汇总
weixin_43739821的博客
03-22 1019
Bytebuf（字节容器） Bootstrap 和 ServerBootstrap（启动引导类） Channel（网络操作抽象类） Selector EventLoop（事件循环） NioEventLoopGroup ChannelHandler（消息处理器） 、 ChannelPipeline（ChannelHandler 对象链表）和 ChannelHandlerContext ChannelFuture（操作执行结果） BIO,NIO 和 AIO 有啥区别？ 为什么要用 Nett
手写RPC框架之网络传输协议设计及实现
嗷嗷嗷嗷的博客
12-10 707
本文主要介绍my-rpc框架中网络传输数据的格式设计，以及如何在发送和接收数据的过程中进行的编解码过程。 网络传输协议设计 数据在网络中是以字节（二进制）的形式传输的，要让通信的双方都能正确的接收对方发送的信息，一定要定义好数据格式，要让对方知道如何解析，从哪一位开始到哪一位代表什么含义，数据的总长度是多少，以避免多读或少读发生解析错误和粘包等问题。 参考TCP协议对TCP数据包的设计，以下是my-rpc框架设计的网络传输的数据包（my-rpc-package）格式，分为header和body两部分：
手写 RPC (二) 集成 Spring
zz_ddup的博客
08-24 483
【诗90:10】我们一生的年日是七十岁，若是强壮可到八十岁；但其中所矜夸的不过是劳苦愁烦，转眼成空，我们便如飞而去。 背景 在第一篇「手写RPC（一）基于BIO」我们已经完成了 RPC 的实现，那么服务的发布和调用怎样交给 spring 管理呢？ 这正是下面要探讨完成的事情
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 554
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 221
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 447
Android的系统结构的设计混合了分层设计和分块设计。
简单手写一个rpc框架
03-10
手写一个RPC框架需要实现以下几个步骤： 1. 定义协议：定义客户端和服务端之间通信的协议，包括数据格式、编码方式、传输协议等。 2. 生成代码：根据协议生成客户端和服务端的代码，包括序列化和反序列化的代码、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值