手动搭建springboot + dubbo + zookeeper的RPC框架

约定不等于承诺〃 2023-07-14 10:32 1阅读 0赞

## 1、什么是RPC？ ##

rpc全称**Remote Procedure Call**，中文 = 远程调用。我们先来看一下本地调用。

### 本地调用 ###

例如：我们在程序里的controller调用了service层的一个方法，在一台机器上这就是本地调用。也就是说这个方法（服务）与调用的程序是在同一个进程中。这样我们通过底层指针（地址）就可以直接找到调用的是哪个方法了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70][]

## 远程调用 ##

但是对于一些并发量超过二十万以上，基于高并发、高性能、高可靠的考虑一般采用分布式应用，将共享的东西可以单独拿出来放到一类服务器上面，让别的服务去调用。这样的就是远程调用的rpc服务。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 1][]

## 2、如何进行RPC服务呢？ ##

1、在我们经常做的系统又B/S这种架构，让Impl的服务暴露一个接口，然后进行调用。但是这样有很大的问题，每次都需要写发送Http的代码，这样不太好，很不优雅。我们考虑的是能否像**本地调用**一样呢？

2、结合Spring IoC一起使用，通过Spring注入service对象，注入时，如果扫描到对象加了@Reference注解，那么就给它生成一个代理对象，将这个代理对象放进容器中。而这个代理对象的内部，就是通过httpClient来实现RPC远程过程调用的。

@Reference
    private Service service;
    
    ...
    
    service.add(1,2);
    
    ...

咱们今天说的dubbo就是采用这样的思路。

### RPC要解决的两个问题： ###

**（1）解决分布式系统中，服务之间的调用问题。**

**（2）远程调用时，要能够像本地调用一样方便，让调用者感知不到远程调用的逻辑。**

### 实现RPC的思路 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 2][]

application就是rpc调用方，Client Stub就是我们上面说到的代理对象，也就是那个看起来像是Service的实现类，其实内部是通过rpc方式来进行远程调用的代理对象，至于Client Run-time Library，则是实现远程调用的工具包，比如jdk的Socket，最后通过底层网络实现实现数据的传输。

这个过程中最重要的就是**序列化**和**反序列化**了，因为数据传输的数据包必须是二进制的，你直接丢一个Java对象过去，人家可不认识，你必须把Java对象序列化为二进制格式，传给Server端，Server端接收到之后，再反序列化为Java对象。

## 3、利用Springboot + Dubbo + Zookeeper实现RPC。 ##

先分别介绍一下dubbo和zookeeper

### dubbo的一些核心功能： ###

（1）透明化的远程方法调用，就像调用本地方法一样调用远程方法。不同服务之间方法的相互调用(说的更直白一点就是接口调用)，一个服务可能是服务提供者也可能服务消费者。

（2）负载均衡及容错机制，负载均衡策略默认是随机，可配置选择。

（3）服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。常用Zookeeper做注册中心。

## Zookeeper： ##

zookeeper是一个注册中心，用于注册client和server的服务的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 3][]

首先呢，面包服务和火腿肠服务分别在不同的服务器上，我们管他们叫做provider（提供者），我们假设他们是配置好相关的dubbo和zookeeper，当他们启动程序的时候，会向服务中心注册好他们的一个信息，我们利用zookeeper可视化工具是可以看到的，体现在java中就是@Service的这个注解，这个不是spring提供的，是dubbo提供的。

然后是client启动我们叫做consumer（消费者），启动之后发现有@Reference这个注解，它也会去注册中心进行注册找到对应的服务，如果它只想要一种服务例如（火腿肠），那么就只注册一次。

最后是调用，consumer需要远程调用服务时，会向注册中心发出申请，然后注册中心返回这种服务的列表，然后选择其中一个服务进行调用，同时呢也会把列表加入缓存（非必须），下次调用直接用这个列表就可以了。

注意：消费者和提供者只在启动的时候与zookeeper交互一次，且只一次。

因为：注册中心宕机了并不影响消费者和提供者的运行，即使zookeeper服务器宕机了，消费者和提供者依然正常运行。消费者在启动的时候从zookeeper获取了服务提供者列表。注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表。注册中心宕掉后，但不能注册新服务。不能再注册新服务了，旧的服务不影响运行。

### 代码实现： ###

项目目录：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 4][]

### 顶层maven的pom ###

<?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://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.rpc</groupId>
        <artifactId>MyRPC</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>dubbo-api</module>
            <module>dobbo-consumer</module>
            <module>dubbo-provider</module>
        </modules>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.RELEASE</version>
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
            <curator-framework.version>4.0.1</curator-framework.version>
            <zookeeper.version>3.4.13</zookeeper.version>
            <dubbo.starter.version>0.2.0</dubbo.starter.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba.boot</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.starter.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.curator</groupId>
                <artifactId>curator-framework</artifactId>
                <version>${curator-framework.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
                <version>${zookeeper.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
    </project>

### dobbo-api ###

package com.rpc.service;
    
    public interface MistraService {
    
        String printInfo(String msg);
    }

dobbo-provider

package com.rpc.service.impl;
    
    import com.alibaba.dubbo.config.annotation.Service;
    import com.rpc.service.MistraService;
    
    @Service(version = "${mistra.service.version}")
    public class MistraServiceImpl implements MistraService {
    
        @Override
        public String printInfo(String msg) {
            return "hello " + msg;
        }
    }

package com.rpc;
    
    import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    @SpringBootApplication
    @EnableDubbo
    public class DubboProviderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DubboProviderApplication.class, args);
        }
    }

spring.application.name = dubbo-provider
    server.port = 9090
    dubbo.application.name = dubbo-provider
    mistra.service.version = 1.0.0
    dubbo.protocol.name = dubbo
    dubbo.protocol.port = 20880
    dubbo.registry.address = zookeeper://localhost:2181
    dubbo.provider.timeout = 1000

### dobbo-consomer ###

package com.rpc;
    
    import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    @EnableDubbo
    public class DubboConsumerApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DubboConsumerApplication.class, args);
        }
    
    }

package com.rpc.rest;
    
    import com.alibaba.dubbo.config.annotation.Reference;
    import com.rpc.service.MistraService;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("test")
    public class TestRestController {
    
        @Reference(version = "${mistra.service.version}")
        private MistraService mistraService;
    
        @RequestMapping("/sayHello/{name}")
        public String sayHello(@PathVariable("name") String name) {
            return mistraService.printInfo(name);
        }
    }

spring.application.name = dubbo-consumer
    server.port = 9091
    dubbo.application.name = dubbo-consumer
    mistra.service.version = 1.0.0
    dubbo.protocol.name = dubbo
    dubbo.protocol.port = 20880
    dubbo.registry.address = zookeeper://localhost:2181
    dubbo.consumer.timeout = 5000

项目的地址：git@github.com:Zesystem/my-rpc.git

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70]: /images/20230529/2cac63d1fc414056a73c2849ec1afca4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 1]: /images/20230529/8bd7e3fc14c84ccc83bd301d2c17100c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 2]: /images/20230529/2f0d17cec6e744b29da06c96f456af49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 3]: /images/20230529/6991d237ec474d37b4d7d46af1103990.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU4ODQ5NQ_size_16_color_FFFFFF_t_70 4]: /images/20230529/916efd37263948298682a95b07f4c5a2.png