bprc二次封装 - 技术栈

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、封装的思想
二、封装单个服务的信道管理类
- 1.成员变量
- 2.成员函数
三、封装总体的服务信道管理类
- 1.成员变量
- 2.成员函数

一、封装的思想

brpc的二次封装:

brpc本质上来说--进行rpc调用的，但是向谁调用什么服务得管理起来 -- 搭配etcd实现的注册中心管理

原因:通过注册中心，能够获知谁能提供什么服务，进而能够连接它发起这个服务调用。

封装思想:

主要是管理起来网络通信的信道----将不同服务节点主机的通信信道管理起来

封装的是服务节点信道的管理，而不是rpc调用的管理。

封装:

1.指定服务的信道管理类:

一个服务可能会有多个节点提供服务，每个节点都有自己的channe

建立服务与信道的映射关系，并且关系是一对多，采用RR轮转策略进行获取

2.总体的服务信道管理类

将多个服务的信道管理对象管理起来

二、封装单个服务的信道管理类

1.成员变量

1.需要一个string来表视当前服务的信道管理类的服务名称因为我们是把一个服务的信道管理起来，所以需要知道该服务的名称。

2.一个服务可能会有多个主机，也就是一个服务可能会有多个信道。所以我么需要一个数组来存储当前服务节点的信道。

3.当一个节点主机下线后，我们需要删除释放这个channel，所以我们需要一个哈希表来进行主机地址与channel的映射关系，方便我们进行删除。

4.需要一个rr轮转下标，当需要对该服务进行rpc调用时，可以使用rr轮转负载均衡式的返回channel.

5.需要一个互斥锁，保证容器的线程安全。

cpp 复制代码

 std::mutex _mutex;
 int32_t _index; //rr轮转下标
 std::string _service_name;  //服务名称
 std::vector<ChannelPtr> _channels;  //当前服务对应的通信集合
 std::unordered_map<std::string,ChannelPtr> _hosts;  //主机地址与信道映射关系

2.成员函数

构造函数中，只需要初始化服务名称，然后轮转下标初始化为0.

cpp 复制代码

ServiceChannel(const std::string& service_name)
        :_index(0),_service_name(service_name)
    {

    }

当服务上线一台主机时，需要创建一个channel进行管理，那么该函数中需要有一个参数，就是主机的地址。

cpp 复制代码

void append(const std::string& host)
    {
        //创建一个channel,并进行连接
        ChannelPtr channel = std::make_shared<brpc::Channel>();
        brpc::ChannelOptions options;
        options.connect_timeout_ms = -1;
        options.timeout_ms = -1;
        options.max_retry = 3;
        options.protocol = "baidu_std";
        int ret = channel->Init(host.c_str(), &options);
        if (ret == -1) {
            LOG_ERROR("初始化{}-{}信道失败!", _service_name, host);
            return;
        }

        std::unique_lock<std::mutex> lock(_mutex);
        _hosts.insert(std::make_pair(host, channel));
        _channels.push_back(channel);

    }

对应的，当主机下线时，需要将该主机的channel删除并释放

cpp 复制代码

 void remove(const std::string& host)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        auto it = _hosts.find(host);
        if (it == _hosts.end()) {
            LOG_WARN("{}-{}节点删除信道时，没有找到信道信息！", _service_name, host);
            return;
        }

        for (auto vit = _channels.begin(); vit != _channels.end(); ++vit) {
            if (*vit == it->second) {
                _channels.erase(vit);
                break;
            }
        }
        _hosts.erase(it);
    }

当需要对该服务发起rpc调用时，我们可以返回该服务的channel。通过rr轮转方式实现一个负载均衡。

cpp 复制代码

ChannelPtr choose()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        if (_channels.size() == 0) {
            LOG_ERROR("当前没有能够提供 {} 服务的节点！", _service_name);
            return ChannelPtr();
        }
        int32_t idx = _index++ % _channels.size();
        return _channels[idx];
    }

三、封装总体的服务信道管理类

我们的服务有多个，而每一个服务也会有多个主机节点。因此我们需要把这些服务总的管理起来。

1.成员变量

1.需要一个哈希表来实现服务名称和该服务的信道管理类的映射关系。

2.项目有多个服务，而我们并不是对所有的服务都要关心的。我们需要使用一个unordered_set来记录我们关心的服务。

3.一个互斥锁，保证容器的线程安全。

2.成员函数

添加一个关心的服务，只需要把服务名称传递进来，进行一个插入即可

cpp 复制代码

 void declared(const std::string& service_name)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        _follow_services.insert(service_name);
    }

当一个对应的服务上线一个主机节点时，为该服务节点主机创建一个channel，并管理起来。这里直接调用上面的服务的信道管理类就行。

cpp 复制代码

void onServiceOnline(const std::string &service_instance,const std::string& host)
    {
        std::string service_name = getServiceName(service_instance);
        ServiceChannel::ptr service;
            {
                std::unique_lock<std::mutex> lock(_mutex);
                auto fit = _follow_services.find(service_name);
                if (fit == _follow_services.end()) {
                    LOG_DEBUG("{}-{} 服务上线了，但是当前并不关心！", service_name, host);
                    return;
                }
                //先获取管理对象，没有则创建，有则添加节点
                auto sit = _services.find(service_name);
                if (sit == _services.end()) {
                    service = std::make_shared<ServiceChannel>(service_name);
                    _services.insert(std::make_pair(service_name, service));
                }else {
                    service = sit->second;
                }
            }

            if (!service) {
                LOG_ERROR("新增 {} 服务管理节点失败！", service_name);
                return ;
            }
        service->append(host);
        LOG_DEBUG("{}-{} 服务上线新节点，进行添加管理！", service_name, host);
    }

服务主机节点下线时，需要找到对应服务的信道管理类，来进行一个对应主机节点的channel的删除和释放。

cpp 复制代码

void onServiceOffline(const std::string &service_instance,const std::string& host)
    {
        std::string service_name = getServiceName(service_instance);
        ServiceChannel::ptr service;
            {
                std::unique_lock<std::mutex> lock(_mutex);
                auto fit = _follow_services.find(service_name);
                if (fit == _follow_services.end()) {
                    LOG_DEBUG("{}-{} 服务下线了，但是当前并不关心！", service_name, host);
                    return;
                }
                //先获取管理对象，没有则创建，有则添加节点
                auto sit = _services.find(service_name);
                if (sit == _services.end()) {
                    LOG_WARN("删除{}服务节点时，没有找到管理对象", service_name);
                    return;
                }
                service = sit->second;
            }
        service->remove(host);
        LOG_DEBUG("{}-{} 服务下线节点，进行删除管理！", service_name, host);
    }

上面的两个接口，是当服务的主机节点上线和下线时调用的，形参中的两个参数就是服务名称和主机节点。

那么什么时候会调用这两个函数呢？我们怎么知道什么时候主机上线下线呢？在前面我们封装了一个etcd，在服务发现客户端中，我们是同watcher来监控一个服务。当服务的数据发送改变时，就会调用我们传入的两个回调函数，那么这里的两个函数就可以作为俩个回调函数传入。也就是当服务新增节点和删除节点时调用。

获取指定服务的节点信道，传入指定服务，返回一个服务的信道。

cpp 复制代码

//获取指定服务的节点信道
    ServiceChannel::ChannelPtr choose(const std::string& service_name)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        auto sit = _services.find(service_name);
        if (sit == _services.end()) {
            LOG_ERROR("当前没有能够提供 {} 服务的节点！", service_name);
            return ServiceChannel::ChannelPtr();
        }
        
        return sit->second->choose();
    }