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

最新推荐文章于 2024-02-18 13:23:19 发布

置顶借汝之光，得以光明

最新推荐文章于 2024-02-18 13:23:19 发布

阅读量642

点赞数 4

分类专栏：分布式

本文链接：https://blog.csdn.net/weixin_44588495/article/details/104855903

版权

分布式专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1、什么是RPC？

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

本地调用

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

远程调用

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

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的思路

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的服务的。

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

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

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

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

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

代码实现：

项目目录：

顶层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);
}

<?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">
    <parent>
        <artifactId>MyRPC</artifactId>
        <groupId>com.rpc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-api</artifactId>


</project>

dobbo-provider

<?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">
    <parent>
        <artifactId>MyRPC</artifactId>
        <groupId>com.rpc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-provider</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.rpc</groupId>
            <artifactId>dubbo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>


</project>

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

<?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">
    <parent>
        <artifactId>MyRPC</artifactId>
        <groupId>com.rpc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dobbo-consumer</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.rpc</groupId>
            <artifactId>dubbo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>


</project>

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

借汝之光，得以光明

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
手动搭建springboot + dubbo + zookeeper的RPC框架

1、什么是RPC？rpc全称Remote Procedure Call，中文 = 远程调用。我们先来看一下本地调用。本地调用例如：我们在程序里的controller调用了service层的一个方法，在一台机器上这就是本地调用。也就是说这个方法（服务）与调用的程序是在同一个进程中。这样我们通过底层指针（地址）就可以直接找到调用的是哪个方法了。远程调用但是对于一些并发量超过二十...
复制链接

扫一扫