版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/okiwilldoit/article/details/82144578
一.BRPC介绍
BRPC百度开源的一个rpc框架，它具有以下特性：
1. 基于protobuf接口的RPC框架，也提供json等其他数据格式的支持
2. 囊括baidu内部所有RPC协议，支持多种第三方协议
3. 模块化设计，层次清晰，很容易添加自定义协议
4. 全面的服务发现、负载均衡、组合访问支持
5. 可视化的内置服务和调试工具
6. 性能上领跑目前其他所有RPC产品
支持的协议
baidu_std（默认）
hulu-pbrpc协议
nova-pbrpc协议
public/pbrpc协议
sofa-pbrpc协议
UB协议
ubrpc协议
HTTP协议
HTTPS协议
凤巢ITP协议
memcache协议
redis协议
mongo协议
hadoop rpc协议
任何使用brpc::Server的进程，都能用HTTP方式直接访问server本身的端口，返回内容为各种内置服务。
通过浏览器直接访问图形界面更加直观；否则用curl方式访问文本格式。
详细文档参见：
https://github.com/brpc/brpc
二.Linux下安装brpc
1. 编译环境安装gcc-4.8.2
（1）先安装gcc-c++.x86_64
yum install gcc-c++.x86_64（2）编译安装gcc-4.8.2
下载gcc-4.8.2-with-all-requires.tar
指定gcc安装路径 –prefix=/usr/local/gcc4.8.2，在”./configure -enable-threads=posix -disable-checking -disable-mutilib -enable-languages=c,c++ “之后增加一个参数 –prefix=/usr/local/gcc4.8.2
执行 install.sh (执行两遍，第一遍解压，第二遍编译安装，编译时间较长请耐心等待)
（3）更新依赖库
添加 /usr/local/gcc4.8.2/lib、 /usr/local/gcc4.8.2/lib64 至 /etc/ld.so.conf，
在/etc/ld.so.conf文件末尾增加一行 “/usr/local/lib”，保存之后执行ldconfig。
注意每个路径独占一行。执行 ldconfig
ln -sf /usr/local/gcc4.8.2/bin/gcc /usr/bin/gcc
ln -sf /usr/local/gcc4.8.2/bin/g++ /usr/bin/g++（4）安装 libstdc++
下载 libstdc++-4.8.2-1.x86_64.rpm
rpm -ivh libstdc++-4.8.2-1.x86_64.rpm2.安装brpc
（1）依赖包安装
yum install libssl-dev realpath libgflags-dev libprotobuf-dev libprotoc-dev \
protobuf-compiler libgtest-dev libleveldb-dev libsnappy-dev \
gperf libgoogle-perftools-dev（2）下载brpc源代码编译安装
git clone https://github.com/brpc/brpc.git
cd ./brpc/
sh config_brpc.sh --headers=/usr/include --libs=/usr/lib --nodebugsymbols
make（3）把brpc的include和lib文件放到系统目录下，ldconfig下，方便调用。
三. 小示例example：回显程序
echo.proto文件：
扫描二维码关注公众号，回复：
2947272 查看本文章
syntax="proto2";
package example;
option cc_generic_services = true;
message EchoRequest {
required string message = 1;
};
message EchoResponse {
required string message = 1;
};
service EchoService {
rpc Echo(EchoRequest) returns (EchoResponse);
};server.cpp
#include <gflags/gflags.h>
#include <butil/logging.h>
#include <brpc/server.h>
#include "echo.pb.h"
DEFINE_bool(echo_attachment, true, "Echo attachment as well");
DEFINE_int32(port, 8000, "TCP Port of this server");
DEFINE_int32(idle_timeout_s, -1, "Connection will be closed if there is no "
"read/write operations during the last `idle_timeout_s'");
DEFINE_int32(logoff_ms, 2000, "Maximum duration of server's LOGOFF state "
"(waiting for client to close connection before server stops)");
// Your implementation of example::EchoService
// Notice that implementing brpc::Describable grants the ability to put
// additional information in /status.
namespace example {
class EchoServiceImpl : public EchoService {
public:
EchoServiceImpl() {};
virtual ~EchoServiceImpl() {};
virtual void Echo(google::protobuf::RpcController* cntl_base,
const EchoRequest* request,
EchoResponse* response,
google::protobuf::Closure* done) {
// This object helps you to call done->Run() in RAII style. If you need
// to process the request asynchronously, pass done_guard.release().
brpc::ClosureGuard done_guard(done);
brpc::Controller* cntl =
static_cast<brpc::Controller*>(cntl_base);
// The purpose of following logs is to help you to understand
// how clients interact with servers more intuitively. You should
// remove these logs in performance-sensitive servers.
LOG(INFO) << "Received request[log_id=" << cntl->log_id()
<< "] from " << cntl->remote_side()
<< " to " << cntl->local_side()
<< ": " << request->message()
<< " (attached=" << cntl->request_attachment() << ")";
// Fill response.
response->set_message(request->message());
// You can compress the response by setting Controller, but be aware
// that compression may be costly, evaluate before turning on.
// cntl->set_response_compress_type(brpc::COMPRESS_TYPE_GZIP);
if (FLAGS_echo_attachment) {
// Set attachment which is wired to network directly instead of
// being serialized into protobuf messages.
cntl->response_attachment().append(cntl->request_attachment());
}
}
};
} // namespace example
int main(int argc, char* argv[]) {
// Parse gflags. We recommend you to use gflags as well.
google::ParseCommandLineFlags(&argc, &argv, true);
// Generally you only need one Server.
brpc::Server server;
// Instance of your service.
example::EchoServiceImpl echo_service_impl;
// Add the service into server. Notice the second parameter, because the
// service is put on stack, we don't want server to delete it, otherwise
// use brpc::SERVER_OWNS_SERVICE.
if (server.AddService(&echo_service_impl,
brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {
LOG(ERROR) << "Fail to add service";
return -1;
}
// Start the server.
brpc::ServerOptions options;
options.idle_timeout_sec = FLAGS_idle_timeout_s;
if (server.Start(FLAGS_port, &options) != 0) {
LOG(ERROR) << "Fail to start EchoServer";
return -1;
}
// Wait until Ctrl-C is pressed, then Stop() and Join() the server.
server.RunUntilAskedToQuit();
return 0;
}client.cpp
#include <gflags/gflags.h>
#include <butil/logging.h>
#include <butil/time.h>
#include <brpc/channel.h>
#include "echo.pb.h"
DEFINE_string(attachment, "foo", "Carry this along with requests");
DEFINE_string(protocol, "baidu_std", "Protocol type. Defined in src/brpc/options.proto");
DEFINE_string(connection_type, "", "Connection type. Available values: single, pooled, short");
DEFINE_string(server, "0.0.0.0:8000", "IP Address of server");
DEFINE_string(load_balancer, "", "The algorithm for load balancing");
DEFINE_int32(timeout_ms, 100, "RPC timeout in milliseconds");
DEFINE_int32(max_retry, 3, "Max retries(not including the first RPC)");
DEFINE_int32(interval_ms, 1000, "Milliseconds between consecutive requests");
DEFINE_string(http_content_type, "application/json", "Content type of http request");
int main(int argc, char* argv[]) {
// Parse gflags. We recommend you to use gflags as well.
google::ParseCommandLineFlags(&argc, &argv, true);
// A Channel represents a communication line to a Server. Notice that
// Channel is thread-safe and can be shared by all threads in your program.
brpc::Channel channel;
// Initialize the channel, NULL means using default options.
brpc::ChannelOptions options;
options.protocol = FLAGS_protocol;
options.connection_type = FLAGS_connection_type;
options.timeout_ms = FLAGS_timeout_ms/*milliseconds*/;
options.max_retry = FLAGS_max_retry;
if (channel.Init(FLAGS_server.c_str(), FLAGS_load_balancer.c_str(), &options) != 0) {
LOG(ERROR) << "Fail to initialize channel";
return -1;
}
// Normally, you should not call a Channel directly, but instead construct
// a stub Service wrapping it. stub can be shared by all threads as well.
example::EchoService_Stub stub(&channel);
// Send a request and wait for the response every 1 second.
int log_id = 0;
while (!brpc::IsAskedToQuit()) {
// We will receive response synchronously, safe to put variables
// on stack.
example::EchoRequest request;
example::EchoResponse response;
brpc::Controller cntl;
request.set_message("hello world");
cntl.set_log_id(log_id ++); // set by user
if (FLAGS_protocol != "http" && FLAGS_protocol != "h2c") {
// Set attachment which is wired to network directly instead of
// being serialized into protobuf messages.
cntl.request_attachment().append(FLAGS_attachment);
} else {
cntl.http_request().set_content_type(FLAGS_http_content_type);
}
// Because `done'(last parameter) is NULL, this function waits until
// the response comes back or error occurs(including timedout).
stub.Echo(&cntl, &request, &response, NULL);
if (!cntl.Failed()) {
LOG(INFO) << "Received response from " << cntl.remote_side()
<< " to " << cntl.local_side()
<< ": " << response.message() << " (attached="
<< cntl.response_attachment() << ")"
<< " latency=" << cntl.latency_us() << "us";
} else {
LOG(WARNING) << cntl.ErrorText();
}
usleep(FLAGS_interval_ms * 1000L);
}
LOG(INFO) << "EchoClient is going to quit";
return 0;
}本程序用blade构建编译程序，BUILD文件：
cc_binary(
name = 'echo_server',
srcs = 'server.cpp',
deps = [
':echo_proto',
'#brpc',
'#gflags',
]
)
cc_binary(
name = 'echo_client',
srcs = 'client.cpp',
deps = [
':echo_proto',
'#brpc',
'#gflags',
]
)
proto_library(
name = 'echo_proto',
srcs = 'echo.proto',
)运行：
