brpc初步学习

一.BRPC介绍

BRPC百度开源的一个rpc框架，它具有以下特性：

基于protobuf接口的RPC框架，也提供json等其他数据格式的支持
囊括baidu内部所有RPC协议，支持多种第三方协议
模块化设计，层次清晰，很容易添加自定义协议
全面的服务发现、负载均衡、组合访问支持
可视化的内置服务和调试工具
性能上领跑目前其他所有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方式访问文本格式。

brpc支持一个端口监听多种协议，如可以同时监听baidu_std和http协议发来的请求。

详细文档参见：
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.rpm

2.安装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：回显程序

提供两个rpc：处理rpc和http格式的请求。

echo.proto文件：

syntax="proto2";
package example;option cc_generic_services = true;message EchoRequest {required string message = 1;
};message EchoResponse {required string message = 1;
};message EchoHttpRequest {};message EchoHttpResponse {};service EchoService {rpc Echo(EchoRequest) returns (EchoResponse);rpc EchoHttp(EchoHttpRequest) returns (EchoHttpResponse);
};

server.cpp

// Copyright (c) 2014 Baidu, Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//     http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.// A server to receive EchoRequest and send back EchoResponse.
#include <iostream>
#include <gflags/gflags.h>
#include <butil/logging.h>
#include <brpc/server.h>
#include "echo.pb.h"using namespace std;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());if(cntl->request_protocol() == brpc::PROTOCOL_HTTP) {const brpc::HttpHeader& http_request = cntl->http_request();const std::string& query_data = http_request.uri().query();LOG(INFO) << "Http query data: " << query_data;}// 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());}}virtual void EchoHttp(google::protobuf::RpcController* cntl_base,const EchoHttpRequest* request,EchoHttpResponse* 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);const brpc::HttpHeader& http_request = cntl->http_request();const std::string& query_data = http_request.uri().query();LOG(INFO) << "Http query data: " << query_data;// 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 exampleint 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,"/echo1 => Echo,""/echo2 => EchoHttp") != 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();cout << "Server Stopped" << endl;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 userif (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',
)

运行：
这里写图片描述 http请求：curl “http://10.130.134.24:8000/echo2?a=1&b=2” -d ‘{“message”:“hello”}’
该方法是post，如果用get需要设置请求头为：application/proto。