Go最新如何手写一个RPC？，持续更新大厂面试笔试题

2401_84904661

于 2024-05-17 05:30:08 发布

阅读量610

点赞数 14

分类专栏：面试学习路线阿里巴巴文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84904661/article/details/138987344

版权

面试同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

学习路线

2 篇文章 0 订阅

订阅专栏

阿里巴巴

2 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

三个项目：rpc-api、rpc-provider和rpc-consumer

API工程是整个服务的标准：
各类服务传输过程当中的传输对象的标准，包括接口的标准。

Provider工程：
将依赖于上面的标准，就是API工程，并且将会去实现IService，即实现标准当中定义的接口。还要基于网络对外提供服务，因此会包含Net Server这个模块来提供网络服务。主要用来接收和解析网络请求，并去调用 Service Dispatch 来完成整个服务的调用和分发。

Consumer工程：
Net Client 主要是完成网络的调用。
ProxyFactory，动态代理模式，主要在调用的过程当中屏蔽网络通讯相关的一些细节，使得我们开发人员在使用过程中不再关注网络细节。

工程搭建步骤

为了简单演示，rpc-api项目中只有一个接口，接口中有一个方法：addUser();
接口的具体实现在rpc-provider中；rpc-consumer中模拟调用addUser() 方法。

建立三个maven项目，首先创建API工程

搭建 rpc-api

如何新建maven工程这里就不做介绍了，下面只包含具体代码

1、pom文件

只包含一个lombok依赖，主要是为了方便不用手写getter和setter

<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://maven.apache.org/maven-v4\_0\_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-api</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.30</version>
    </dependency>
  </dependencies>

</project>

2、UserDto

三个属性name、age、userId
因为需要在网络中传输，实现了Serializable，并添加了序列化id

package com.mntalk.dto;


import lombok.Data;
import java.io.Serializable;

@Data
public class UserDto implements Serializable {
    private static final long serialVersionUID = 4266781378102409837L;

    private String name;
    private int age;
    private String userId;
}

3、UserService

定义接口和方法

package com.mntalk.api;

import com.mntalk.dto.UserDto;

public interface UserService {
    // 添加用户
    public UserDto addUser(UserDto userDto);

}

4、RPACommonReqDto

定义统一的传输标准，这里先定义成这样，后面再详细解释，为什么会包含者几个属性

package com.mntalk.dto;

import lombok.Data;
import java.io.Serializable;
/\*\*
 \* 统一传输标准
 \*/
@Data
public class RPACommonReqDto implements Serializable {

    private static final long serialVersionUID = 6212822493972023391L;
    // 方法名
    private String methodName;

    // 类的全路径名
    private String classPath;

    // 形参列表
    private Object[] args;
}

5、将工程打成jar包，方便provider和consumer工程引入进行实现和调用

具体怎么打包就不做介绍了，可以使用命令打包，也可以接触idea打包

搭建 rpc-provider

提供接口实现，并使用Socket网络编程，模拟等待调用

1、pom文件

引入rpc-api工程

<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://maven.apache.org/maven-v4\_0\_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-privider</artifactId>
  <version>1.0-SNAPSHOT</version>


  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

2、实现UserService

实现具体的addUser方法，这里就模拟已经添加到数据库，并生成了userId，然后将生成的信息返回。
UserServiceImpl业务实现

package com.mntalk.impl;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;

import java.util.Random;

public class UserServiceImpl implements UserService {
    @Override
    public UserDto addUser(UserDto userDto) {
        // todo xxx

        // 模拟插入数据库并生成了userId
        System.out.println("接收：" + userDto);
        userDto.setUserId(new Random().nextInt(100000) + "");
        System.out.println("设置了用户id：" + userDto);

        return userDto  ;
    }
}

3、NetServer

根据上面实现手写RPC的思路图，现在需要Socket网络编程，模拟等待consumer来进行调用。

这里采用线程池来进行异步实现，为什么不不直接在主线程中等待呢？
因为ServerSocket的accept() 是典型的 Blocking IO，会阻塞工作线程。

package com.mntalk.net;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/\*\*
 \* 对外提供服务
 \*/
public class NetServer {

    static final ExecutorService threadPool = Executors.newFixedThreadPool(50);

    public static void startUp(int port) throws IOException {

        ServerSocket serverSocket = new ServerSocket(port);


// // 阻塞等待客户端连接
// Socket socket = serverSocket.accept();
//
// // 典型的 Blocking IO，会阻塞工作线程
// socket.getOutputStream();
// socket.getInputStream();

        // 多线程方式
        // 线程池
        while (true) {
            Socket socket = serverSocket.accept();
            threadPool.submit(new RPCProcessor(socket));
        }

    }

}

4、RPCProcessor

具体的socket处理，实现Runnable接口，方便放入多线程处理。
其中很重要的一点就是模拟服务的分发 ServiceDispatch.dispatch(reqObject);

package com.mntalk.net;

import com.mntalk.dispatch.ServiceDispatch;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Optional;

public class RPCProcessor implements Runnable {

    ObjectInputStream objectInputStream = null;
    ObjectOutputStream objectOutputStream = null;

    private final Socket socket;

    /\*\*
 \* 因为需要处理socket的流，所以需要注入socket
 \*/
    public RPCProcessor(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {


        try {
            // 将输入输出流包装成对象流
            objectInputStream = new ObjectInputStream(socket.getInputStream());

            // 读取客户端对象
            Object reqObject = objectInputStream.readObject();
            // 服务分发
            Object respObj = ServiceDispatch.dispatch(reqObject);


            // 将结果进行输出
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(respObj);
            objectOutputStream.flush();


        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (Optional.ofNullable(objectInputStream).isPresent()) {

                    objectInputStream.close();
                }
                if (Optional.ofNullable(objectOutputStream).isPresent()) {

                    objectOutputStream.close();
                }
            } catch (IOException e) {
                System.out.println("远程调用流关闭错误：" + e.getMessage());
            }
        }

    }
}

5、ServiceDispatch 服务分发

在这里详细解释一下，为什么之前要定义一个 RPACommonReqDto 标准传输对象，并且包含三个属性：
最主要的就是为了下面通过反射生成具体的instance，然后调用方法。

通过classPath可以生成字节码对象；通过方法参数列表，可以得到参数类型列表，然后再通过方法名，就可以得到具体的方法；
然后就可以进行方法调用了。

package com.mntalk.dispatch;


import com.mntalk.dto.RPACommonReqDto;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ServiceDispatch {

    /\*\*
 \* 服务分发
 \*/
    public static Object dispatch(Object reqObject) {
        // 大胆猜测一下，reqObject 中应该包含了分发的内容属性
        // type == 1 --> addUser
        // type == 2 --> deleteUser
        // 上面的这样太呆板了



        // 基于反射机制，就很灵活 instance方法的调用
        // classpath 全路径
        // 方法名 + 形参列表的类型列表
        // 实例对象 Class.newInstance
        // 方法在调用过程当中参数的值 ( getType 可以获得 形参列表的类型列表 )
        RPACommonReqDto reqDto = (RPACommonReqDto)reqObject;
        String classPath = reqDto.getClassPath();
        String methodName = reqDto.getMethodName();
        Object[] args = reqDto.getArgs();

        Class[] types = null;

        if (args != null && args.length > 0) {
            types = new Class[args.length];
            for (int i = 0; i < args.length; i++) {
                types[i] = args[i].getClass();
            }
        }

        Object respObject = null;

        // 方法获取及调用
        try {
            Class<?> clazz = Class.forName(classPath);
            Method method = clazz.getDeclaredMethod(methodName, types);
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            respObject = method.invoke(constructor.newInstance(), args);

        } catch (Exception e) {
            e.printStackTrace();
        }


        return  respObject;
    }


}

搭建 rpc-consumer

模拟调用

1、pom文件

引入rpc-api工程

<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://maven.apache.org/maven-v4\_0\_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mntalk</groupId>
  <artifactId>rpc-consumer</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>com.mntalk</groupId>
      <artifactId>rpc-api</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

2、TestRPC

模拟调用

package com.mntalk;

import com.mntalk.api.UserService;
import com.mntalk.dto.UserDto;
import com.mntalk.proxy.FactoryProxy;

public class TestRPC {
    public static void main(String[] args) {

        UserService userService = FactoryProxy.getInstanceByClassType(UserService.class);

        UserDto userDto = new UserDto();
        userDto.setName("feiz");
        userDto.setAge(18);

        System.out.println("invoke before: " + userDto);

        userDto = userService.addUser(userDto); // 实际上是跑到RPCInvocationHandler的invoke方法中去执行逻辑了

        System.out.println("invoke after: " + userDto);
    }
}

3、FactoryProxy 代理工厂

通过JDK的动态代理，底层会采用ASM字节码重组技术，会生成一个新的class字节码对象，
然后由ClassLoader将字节码对象加载到JVM进程当中，经由这个类的实例，
去创建出来了一个实例对象，这个class对象实现了interfaceClazz接口。

package com.mntalk.proxy;


![img](https://img-blog.csdnimg.cn/img_convert/53add736382a37f754c065291ae9a700.png)
![img](https://img-blog.csdnimg.cn/img_convert/5fabd91a2caddf3410fa515db2313d69.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

yProxy 代理工厂


通过JDK的动态代理，底层会采用ASM字节码重组技术，会生成一个新的class字节码对象，  
 然后由ClassLoader将字节码对象加载到JVM进程当中，经由这个类的实例，  
 去创建出来了一个实例对象，这个class对象实现了interfaceClazz接口。

package com.mntalk.proxy;

[外链图片转存中…(img-r4fcrvIE-1715894984561)]
[外链图片转存中…(img-CBhB4BeO-1715894984561)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

2401_84904661

关注

14
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
Go最新如何手写一个RPC？，持续更新大厂面试笔试题

rpc-api、rpc-provider和rpc-consumer各类服务传输过程当中的传输对象的标准，包括接口的标准。将依赖于上面的标准，就是API工程，并且将会去实现IService，即实现标准当中定义的接口。还要基于网络对外提供服务，因此会包含Net Server这个模块来提供网络服务。主要用来接收和解析网络请求，并去调用 Service Dispatch 来完成整个服务的调用和分发。Net Client 主要是完成网络的调用。
复制链接

扫一扫