徒手打造 - RPC遠程通訊框架v1+v2

原創 菜鸟编程98K 2020-07-01 11:04

手寫RPC框架V1

gitee地址：https://gitee.com/kylin1991_admin/rpc_handwriting

文章目錄

Api.jar

1、寫一個IHelloService接口，類似dubbo
public interface IHelloService {
    String sayHello(String context);
  }
2、一個RpcRequest請求模型
@Data
public class RpcRequest implements Serializable {
    private String className;
    private String methodName;
    private Object[] parameters;
}

Server

1、Server 服務註冊
  public class Server {
      public static void main(String[] args) {
          IHelloService helloService = new IHelloServiceImpl();
          RpcProxyServer rpcProxyServer = new RpcProxyServer(helloService,8080);
          rpcProxyServer.publisher();
      }
  }
2、RpcProxyServer 服務發佈
public class RpcProxyServer {
    private Object service;
    private int port;

    public RpcProxyServer(Object service, int port) {
        this.service = service;
        this.port = port;
    }

    public void publisher() {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                Socket socket = serverSocket.accept();
                executor.execute(new ProcessorHandler(service,socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static final Executor executor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors(),
            60L,
            TimeUnit.MINUTES,
            new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors()),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
    );
}
3、請求處理ProcessorHandler
public class ProcessorHandler implements Runnable {
    private Object service;
    private Socket socket;

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

    @Override
    public void run() {
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
             ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream())) {

            // 接受請求
            RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject();

            // 反射調用並且返回結果
            objectOutputStream.writeObject(invoke(rpcRequest));
            objectOutputStream.flush();


        } catch (IOException | ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private Object invoke(RpcRequest rpcRequest, Object service) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class clazz = Class.forName(rpcRequest.getClassName());
        Class<?>[] parametersTypes = new Class<?>[rpcRequest.getParameters().length];
        for (int i = 0; i < parametersTypes.length; i++) {
            parametersTypes[i] = rpcRequest.getParameters()[i].getClass();
        }
        Method method = clazz.getMethod(rpcRequest.getMethodName(), parametersTypes);
        return method.invoke(service, rpcRequest.getParameters());
    }
}

Client

1、Client 發起請求
public class Client {
    public static void main(String[] args) {
        RpcProxyClient rpcProxyClient = new RpcProxyClient();
        IHelloService helloService = rpcProxyClient.proxyClient(IHelloService.class,"localhost",8080);
        System.out.println(helloService.sayHello("lilei"));;
    }
}
2、遠程調用（採用jdk動態代理）
  • RpcProxyClient
public class RpcProxyClient {
    public <T> T proxyClient(Class<?> interfacesCls, String host, int port) {
        return (T) Proxy.newProxyInstance(
                interfacesCls.getClassLoader(),
                new Class<?>[]{interfacesCls},
                new RemoteInvocationHandler(host,port));
    }
}
  • RemoteInvocationHandler 用於遠程方法調用
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 = new RpcRequest();
        rpcRequest.setClassName(method.getDeclaringClass().getName());
        rpcRequest.setMethodName(method.getName());
        rpcRequest.setParameters(args);

        //發送請求，並且獲得結果
        RpcNetTransport rpcNetTransport = new RpcNetTransport(host, port);
        return rpcNetTransport.send(rpcRequest);
    }
}
3、RpcNetTransport 調用
public class RpcNetTransport {
    private String host;
    private int port;

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

    public Object send(RpcRequest rpcRequest) {
        Object result = null;
        try (Socket socket = new Socket(host, port);
             ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream())) {

            objectOutputStream.writeObject(rpcRequest);
            objectOutputStream.flush();

            result = objectInputStream.readObject();

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return result;
    }
}

測試

1、啓動Server

2、啓動Client

測試成功！

問題

  • 是否可以用註解來實現？

手寫RPC框架V2

  • 通過註解來實現服務發佈，和服務調用

重寫Server

1、加入spring的容器
     <!--  爲了方便用spring的註解 Component -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.4.RELEASE</version>		
        </dependency>
2、創建配置類SpringConfig
@Configuration
public class SpringConfig {
    @Bean(name = "rpcServer")
    public RpcServer rpcServer() {
        return new RpcServer(8080);
    }
}
3、創建註解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component // 被Spring進行掃描，並管理
public @interface RpcService {
    Class<?> value();
}
4、RpcServer類
  • 實現ApplicationContextAware
  • 實現InitializingBean
  • setApplicationContext 中獲取被RpcService註解修飾的類。然後根據類引用路徑作爲name，對象作爲值，保存到一個map中
  • 把map作爲傳入參數傳入線程processor
@Configuration
public class RpcProxyServer implements ApplicationContextAware, InitializingBean {
    private static final Executor executor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors(),
            60L,
            TimeUnit.MINUTES,
            new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors()),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
    );
    private int port;
    private Map<String, Object> handlerMap = new HashMap<>();

    public RpcServer(int port) {
        this.port = port;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                Socket socket = serverSocket.accept();
                executor.execute(new ProcessorHandler(handlerMap, socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> serviceBeanMap = applicationContext.getBeansWithAnnotation(RpcService.class);
        if (!serviceBeanMap.isEmpty()) {
            for (Object serviceBean : serviceBeanMap.values()) {
                RpcService rpcService = serviceBean.getClass().getAnnotation(RpcService.class);
                String serviceName = rpcService.value().getName();
                handlerMap.put(serviceName, serviceBean);
            }
        }
    } 
}
5、修改ProcessorHandler
  • 接受handlerMap集合
  • 根據類名從集合中取出參數
public class ProcessorHandler implements Runnable { 
    private Socket socket;
    private Map<String, Object> handlerMap;

    public ProcessorHandler(Map<String, Object> handlerMap, Socket socket) {
        this.handlerMap = handlerMap;
        this.socket = socket;
    }

    @Override
    public void run() {
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
             ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream())) {

            // 接受請求
            RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject();

            // 反射調用並且返回結果
            objectOutputStream.writeObject(invoke(rpcRequest));
            objectOutputStream.flush();


        } catch (IOException | ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private Object invoke(RpcRequest rpcRequest) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        String className = rpcRequest.getClassName();
        Object service = handlerMap.get(className);
        if (service == null) {
            throw new RuntimeException("service not found :" + className);
        }
        Class clazz = Class.forName(className);
        Class<?>[] parametersTypes = new Class<?>[rpcRequest.getParameters().length];
        for (int i = 0; i < parametersTypes.length; i++) {
            parametersTypes[i] = rpcRequest.getParameters()[i].getClass();
        }
        Method method = clazz.getMethod(rpcRequest.getMethodName(), parametersTypes);
        return method.invoke(service, rpcRequest.getParameters());
    }
}
6、測試是否可行
@ComponentScan("org.example")
public class Server {
    public static void main( String[] args ) {
        AnnotationConfigApplicationContext configApplicationContext =new AnnotationConfigApplicationContext(Server.class);
    }
}
重寫客戶端
1、加入spring的容器
     <!--  爲了方便用spring的註解 Component -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.4.RELEASE</version>		
        </dependency>
2、修改RpcProxyClient
public class RpcProxyClient {
    private final String host;
    private final int port;

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

    public <T> T proxyClient(Class<?> interfacesCls) {
        return (T) Proxy.newProxyInstance(interfacesCls.getClassLoader(), new Class<?>[]{interfacesCls}, new RemoteInvocationHandler(host, port));
    }
}
3、創建SpringConfig
@Configuration
public class SpringConfig {
    private static final RpcProxyClient PROXY_CLIENT = new RpcProxyClient("localhost", 8080);

    @Bean
    public IHelloService iHelloService() {
        return PROXY_CLIENT.proxyClient(IHelloService.class);
    }
}
4、測試是否可行
@ComponentScan("org.example")
public class Client {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Client.class); 
        
        IHelloService iHelloService = context.getBean(IHelloService.class);

        String result = iHelloService.sayHello("lilei");
        System.out.println(result);
    }
}

備註，如果客戶端向實現更簡化的註解，那麼可以利用BeanDefinition來實現，具體看鏈接

如何把接口加入到Spring容器（任何類/接口都可以用這個方式，例如動態代理）

源碼gitee地址

支持多版本的實現

//todo 有時間在弄吧

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Dubbo技術知識總結之三——Dubbo 啓動與服務暴露、引用

接上篇《Dubbo技術知識總結之二——註冊中心》 三. Dubbo 啓動與服務暴露、引用 服務暴露：見書 5.2.2 章，文章《Dubbo服務暴露與註冊》 3.1 啓動時 dubbo 標籤解析 服務啓動時，首先解析 dub

琦小虾 2020-07-08 09:16:27

Dubbo技術知識總結之二——註冊中心

接上篇《Dubbo技術知識總結之一——Dubbo架構》 二. 註冊中心 首先需要說明的一點是，服務的暴露與註冊是兩個不同的概念。在Dubbo中，微服務之間的交互默認是通過Netty進行的，而服務之間的通信是基於TCP以全雙工的

琦小虾 2020-07-08 09:16:27

一文搞懂WebService基於CXF框架實現[JAX-RS]

前言 上一篇文章我們瞭解JAX-WS基於SOAP(面向簡單對象訪問協議)可以轉化爲XML數據格式進行遠程調用，WSDL文檔可以幫助我們清楚的瞭解到數據解析格式和要求，有興趣的同學可以點擊 一文搞懂WebService基於CXF框架

丰丰丰的csdn 2020-07-07 22:38:08

Http、REST和RPC區別

轉載自：https://blog.csdn.net/mou_it/article/details/79873612   RPC（即Remote Procedure Call，遠程過程調用）和HTTP（HyperText Transfer

cillyb 2020-07-07 20:40:11

分別以google.golang.org/grpc和net/rpc簡單理解RPC

                    篳路藍縷，以啓山林。撫有蠻夷，以屬華夏。不鳴則已，一鳴驚人。                                                                     

_雨落山岚 2020-07-07 03:29:32

mina實現rpc

http://blog.csdn.net/stevexk/article/details/2770135下載http://www.pudn.com/d

iteye_3878 2020-07-06 17:19:31

單獨使用Eureka實現服務發現、服務註冊

目錄 Eureka服務端 1.啓動類  2.yml  3.pom  Eureka客戶端 1.啓動類 2. yml 3. pom 4. 服務發現工具類 4.1 修改服務發現工具類-用於正式環境 Eureka服務端 1.啓動類  packa

祁~ 2020-07-06 15:24:51

gRPC 異常處理

最近第一次使用 gRPC 創建一個服務，在服務端我想將一個自定義異常直接拋出去，讓客戶端能看到。一開始，我這樣嘗試： // responseObserver.onError(new CustomException("

jiaobuchong 2020-07-04 14:03:27

Hadoop-Yarn源碼-RPC基礎

一.簡介 一種通過網絡從遠程計算機程序上請求服務，而不需要了解底層網絡技術的協議。RPC協議假定某些傳輸協議的存在，如TCP或UDP，爲通信程序之間攜帶信息數據。在OSI網絡通信模型中，RPC跨越了傳輸層和應用層。RPC使得開發包

李孟lm 2020-07-04 13:01:55

看Dubbo源碼存在的疑問&理解

1.configrators變更 服務提供者會重新export。但是隻是dubboProtocol重新暴露，沒有往zk註冊新的url       實驗過了，就是沒註冊新的providerUrl，這樣怎麼說呢，如果providerUrl是永

vajenec-cl 2020-07-04 04:55:05

netty整合protocol buffer

netty整合protocol buffer例子問題及解決 例子 其實netty去整合protobuf很簡單，只是我們需要新的編解碼器。 server： public class TestProtobufServer { pub

spring man 2020-07-03 14:49:22

RPC原理以及實踐

1. 認識RPC RPC(Remote Procedure Call)是指遠程過程調用，在微服務架構中，各個微服務之間的通信一般使用RPC，比如用戶微服務和訂單微服務，需求是在用戶微服務中查詢當前用戶的訂單，此時用戶服務是RPC的

Demodemon 2020-07-03 06:39:24

京東中臺化底層支撐框架技術分析及隨想

本文大約1.7萬字，閱讀需要13分鐘。 導讀：近幾年，除AIGC外，軟件領域相關比較大的變化，就是各相關業務領域開始如火如荼地建設中臺和去中臺化了。本文不探討中臺對公司組織架構涉及的變化和影響，只是從中臺化演進的思路，及使用的底層支撐技

原創 2024-04-03 11:16:28

應用監控 eBPF 版：實現 Golang 微服務的無侵入應用監控

作者：古琦 在現代軟件架構中，微服務已成爲構建可擴展和靈活應用程序的流行方式。每個微服務負責應用程序的一部分功能，它們共同工作以提供完整的服務。由於微服務架構的分散特性，監控變得至關重要，有效的微服務監控是確保高可用性、可靠性和服務質量的關

原創 2024-03-06 21:16:46

gRPC-第二代rpc服務

背景 在如今雲原生技術的大環境下，rpc服務作爲最重要的互聯網技術，蓬勃發展，誕生了許多知名基於rpc協議的框架，其中就有本文的主角gRPC技術。     一款高性能、開源的通用rpc框架 作者作爲一名在JD實習的Cpper，

原創 2024-03-04 23:57:13