要使用C++访问Hbase，可以走的途径少之又少，据说当前最好的方法就是通过Thrift来实现：http://thrift.apache.org/

所以本文分成几部分：（1）安装Thrift；（2）用Thrift 生成访问Hbase所需的C++文件；（3）在程序中通过Thrift来访问Hbase。

另外，本文只包含读写Hbase数据的例子，不包含配置Hbase的方法，如需这些内容，请自行搜索。

首先声明一下，本文基于以下环境：

操作系统：RHEL 5.3，64位

Thrift 版本：0.7.0

要访问的 Hbase 版本：0.20.6

我使用0.90.4的 Hbase 安装包来生成C++所需的Hbase.h等文件（用新版的应该能兼容旧版的）

文章来源：http://www.codelast.com/

下面开始，一步步来。

（1）安装Thrift

不是一件很轻松的事。如果你的系统比较干净，可能很顺利地就搞定了，如果有依赖库缺失问题或者库冲突问题，那么就只能根据具体情况，一个个问题去fix了，谁知道会有多少麻烦。

我运气比较好，在一个干净的系统上，很快就完成了。

Thrift 至少会依赖于两个系统中一般不会带的库：libevent，boost。

libevent 到这里下载：http://monkey.org/~provos/libevent/  我使用的版本是：2.0.12-stable

boost 到这里下载：http://www.boost.org/  我使用的版本是：1.47.0

文章来源：http://www.codelast.com/

安装libevent：

./configure --prefix=/usr/local/libevent
make
make install

安装boost（boost不像一般的Linux源码安装包一样，它的安装不是configure，make，make install，有点怪）：

./bootstrap.sh --prefix=/usr/local/boost

不出错的话接着执行以下命令开始编译（也可以通过编辑project-config.jam文件调整编译参数）：

./b2
./b2 install

安装Thrift：

chmod +x configure
./configure --with-boost=/usr/local --prefix=/usr/local/thrift
make
make install

至此，安装Thrift 的工作就完成了。

文章来源：http://www.codelast.com/

（2）用Thrift 生成访问Hbase所需的C++文件

访问Hbase需要在你的程序中使用若干.h，.cpp文件，这些文件是用 Thrift 生成的。

解压Hbase源码安装包：

tar zxf hbase-0.90.4.tar.gz
cd hbase-0.90.4

在解压出来的文件中， 你可以找到一个名为 Hbase.thrift 的文件，这个文件定义了如何通过 Thrift 接口来访问Hbase。用这个Thrift文件，可以生成访问Hbase所需的C++文件：

/usr/local/thrift/bin/thrift --gen cpp ./src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift

会发现生成了gen-cpp目录：

ls gen-cpp/

输出：

Hbase_constants.cpp  Hbase_constants.h  Hbase.cpp  Hbase.h  Hbase_server.skeleton.cpp  Hbase_types.cpp  Hbase_types.h

除了Hbase_server.skeleton.cpp之外，其余文件都是在我们的程序里要用到的，将它们拷贝到我们的工程目录下。

文章来源：http://www.codelast.com/

（3）在程序中使用Thrift来访问Hbase

要能通过 Thrift 访问Hbase，你必须首先要打开HBase的 Thrift 服务，请参考其他文档确保这一点是可用的。

下一步，我们在程序中如何读取Hbase的数据？

我们先看看hbase源码安装包中自带的例子：在解压出来的安装包中的 examples/thrift/ 目录下的 DemoClient.cpp 文件，有如下代码：

  boost::shared_ptr<TTransport> socket(new TSocket("localhost", 9090));
  boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
  boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
  HbaseClient client(protocol);
  try {
    transport->open();

    // do something

    transport->close();
  } catch (TException &tx) {
    printf("ERROR: %s\n", tx.what());
  }

我们就仿照这个例子来做。从DemoClient.cpp可见，我们要先创建三个指针socket，transport和protocol，后两个分别依赖于前两个，最后再创建一个client对象，我们操作Hbase就是使用这个client对象。在操作Hbase前，需要先打开到Hbase Thrift service的连接，即 transport->open()，在操作完 Hbase之后，需要关闭连接，即 transport->close()，这下就比较清楚了：我们可以写一个自己的类CHbaseOperate，它应该有一个connect函数和一个disconnect函数，分别用于打开、关闭连接，还应该有读写Hbase的基本功能。读写Hbase的方法，请参考Hbase.h中的函数，例子还是看DemoClient.cpp。
文章来源：http://www.codelast.com/

下面上代码：
HbaseOperate.h：

#ifndef __HBASE_OPERATE_H
#define __HBASE_OPERATE_H

#include <string>
#include <protocol/TBinaryProtocol.h>
#include <transport/TSocket.h>
#include <transport/TTransportUtils.h>
#include "Hbase.h"

/**
 * Class to operate Hbase.
 *
 * @author Darran Zhang (codelast.com)
 * @version 11-08-24
 * @declaration These codes are only for non-commercial use, and are distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
 * You must not remove this declaration at any time.
 */

using namespace apache::thrift;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;
using namespace apache::hadoop::hbase::thrift;

typedef struct hbaseRet {
  std::string rowValue;
  time_t ts;

  hbaseRet() {
    ts = 0;
  }

} hbaseRet;

class CHbaseOperate
{
public:
	CHbaseOperate();
	virtual ~CHbaseOperate();

private:
  boost::shared_ptr<TTransport> socket;
  boost::shared_ptr<TTransport> transport;
  boost::shared_ptr<TProtocol> protocol;

  HbaseClient *client;

  std::string  hbaseServiceHost;
  int     hbaseServicePort;
  bool    isConnected;

public:
  bool  connect();

  bool  connect(std::string host, int port);

  bool  disconnect();

  bool  putRow(const std::string &tableName,
              const std::string &rowKey,
              const std::string &column,
              const std::string &rowValue);

  bool  getRow(hbaseRet &result,
              const std::string &tableName,
              const std::string &rowKey,
              const std::string &columnName);
};

#endif

文章来源：http://www.codelast.com/

HbaseOperate.cpp：

#include "HbaseOperate.h"
#include "log4cxx/log4cxx.h"
#include "log4cxx/propertyconfigurator.h"

static log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("HbaseOperate.cpp"));

/**
 * Class to operate Hbase.
 *
 * @author Darran Zhang (codelast.com)
 * @version 11-08-24
 * @declaration These codes are only for non-commercial use, and are distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
 * You must not remove this declaration at any time.
 */

using namespace std;

CHbaseOperate::CHbaseOperate() :
socket((TSocket*)NULL), transport((TBufferedTransport*)NULL), protocol((TBinaryProtocol*)NULL), client(NULL), hbaseServicePort(9090), isConnected(false)
{
}

CHbaseOperate::~CHbaseOperate()
{
  if (isConnected) {
    disconnect();
  }
  if (NULL != client) {
    delete client;
    client = NULL;
  }
}

/**
 * Connect Hbase.
 *
 */
bool CHbaseOperate::connect()
{
  if (isConnected) {
    LOG4CXX_INFO(logger, "Already connected, don't need to connect it again");
    return true;
  }

  try {
    socket.reset(new TSocket(hbaseServiceHost, hbaseServicePort));
    transport.reset(new TBufferedTransport(socket));
    protocol.reset(new TBinaryProtocol(transport));

    client = new HbaseClient(protocol);

    transport->open();
  } catch (const TException &tx) {
    LOG4CXX_ERROR(logger, "Connect Hbase error : " << tx.what());
    return false;
  }

  isConnected = true;
  return isConnected;
}

/**
 * Connect Hbase.
 *
 */
bool CHbaseOperate::connect(std::string host, int port)
{
  hbaseServiceHost = host;
  hbaseServicePort = port;

  return connect();
}

/**
 * Disconnect from Hbase.
 *
 */
bool CHbaseOperate::disconnect()
{
  if (!isConnected) {
    LOG4CXX_ERROR(logger, "Haven't connected to Hbase yet, can't disconnect from it");
    return false;
  }

  if (NULL != transport) {
    try {
      transport->close();
    } catch (const TException &tx) {
      LOG4CXX_ERROR(logger, "Disconnect Hbase error : " << tx.what());
      return false;
    }
  } else {
    return false;
  }

  isConnected = false;
  return true;
}

/**
 * Put a row to Hbase.
 *
 * @param tableName   [IN] The table name.
 * @param rowKey      [IN] The row key.
 * @param column      [IN] The "column family : qualifier".
 * @param rowValue    [IN] The row value.
 * @return True for successfully put the row, false otherwise.
 */
bool CHbaseOperate::putRow(const string &tableName, const string &rowKey, const string &column, const string &rowValue)
{
  if (!isConnected) {
    LOG4CXX_ERROR(logger, "Haven't connected to Hbase yet, can't put row");
    return false;
  }

  try {
    std::vector<Mutation> mutations;
    mutations.push_back(Mutation());
    mutations.back().column = column;
    mutations.back().value = rowValue;
    client->mutateRow(tableName, rowKey, mutations);

  } catch (const TException &tx) {
    LOG4CXX_ERROR(logger, "Operate Hbase error : " << tx.what());
    return false;
  }

  return true;
}

/**
 * Get a Hbase row.
 *
 * @param result      [OUT] The object which contains the returned data.
 * @param tableName   [IN] The Hbase table name, e.g. "MyTable".
 * @param rowKey      [IN] The Hbase row key, e.g. "kdr23790".
 * @param columnName  [IN] The "column family : qualifier".
 * @return True for successfully get the row, false otherwise.
 */
bool CHbaseOperate::getRow(hbaseRet &result, const std::string &tableName, const std::string &rowKey, const std::string &columnName)
{
  if (!isConnected) {
    LOG4CXX_ERROR(logger, "Haven't connected to Hbase yet, can't read data from it");
    return false;
  }

  std::vector<std::string> columnNames;
  columnNames.push_back(columnName);

  std::vector<TRowResult> rowResult;
  try {
    client->getRowWithColumns(rowResult, tableName, rowKey, columnNames);
  } catch (const TException &tx) {
    LOG4CXX_ERROR(logger, "Operate Hbase error : " << tx.what());
    return false;
  }

  if (0 == rowResult.size()) {
    LOG4CXX_WARN(logger, "Got no record with the key : [" << rowKey << "]");
    return false;
  }

  std::map<std::string, TCell>::const_iterator it = rowResult[rowResult.size() -1].columns.begin();
  result.rowValue = it->second.value;
  result.ts = it->second.timestamp;

  return true;
}

注意我在程序中使用了Apache log4cxx这个记录日志的库来打印/保存程序运行日志，使用方法可参考【此链接】。如果你不想用，可以自己改为std::cout。
代码有了，使用方法为：可以在你的程序中创建一个全局对象：

CHbaseOperate g_ho;

在需要操作Hbase之前：

g_ho.connect("192.168.55.66", 9090);

其中，“192.168.55.66”和9090分别是你的Hbase Thrift service的服务器地址和端口号，你需要正确地配置好，才能使用。本文开头已经说了，本文不讨论这方面的问题。
在操作完Hbase之后：

g_ho.disconnect();

文章来源：http://www.codelast.com/
现在再来说一下读写操作Hbase的两个函数：putRow()和getRow()。
putRow()：

bool  putRow(const std::string &tableName,
              const std::string &rowKey,
              const std::string &column,
              const std::string &rowValue);

这是向Hbase写入一条记录的函数，参数tableName为Hbase表名，即你要将记录写到哪个Hbase表中；参数rowKey为待写入的记录的key；参数column为待写入的记录的“column family:qualifier”组合，参数rowValue为待写入的记录的value。

getRow()：

bool  getRow(hbaseRet &result,
              const std::string &tableName,
              const std::string &rowKey,
              const std::string &columnName);

这是从Hbase中读取一条记录的函数，参数tableName为Hbase表名，即你要从哪个Hbase表中读取记录；参数rowKey为你要查询的记录的key；参数columnName为你要查询的记录的“column family:qualifier”组合;参数result为返回的Hbase的数据，它包含记录的value和记录的时间戳：

typedef struct hbaseRet {
  std::string rowValue;
  time_t ts; 

  hbaseRet() {
    ts = 0;
  }

} hbaseRet;

文章来源：http://www.codelast.com/
至于操作的结果对不对，可以在Hbase shell中用get, scan等命令来验证，具体方法请看Hbase shell的help。另外，最好再写一些unit test来测试。
如果你要为CHbaseOperate类添加功能，可以参考Hbase.h文件中的函数定义。如你所见，CHbaseOperate类主要也是调用了里面的函数，只不过这个类可以让一些不太熟悉Hbase概念的人可以更方便地操作Hbase罢了。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

补一句：Apache声称log4cxx的速度快、灵活性好，但是，速度快是第一位的，灵活性是第二位的（"Log4cxx claims to be fast and flexible: speed first, flexibility second."），所以，担心日志记录性能的同学更可以选择log4cxx啦。

但是，这玩意的安装、编译稍微有点麻烦，如果遇到了问题，没耐心的人可能就没兴趣折腾了，我在这里把自己遇到的问题记一下。

系统环境：RHEL 5.3，64位

首先去log4cxx的官方网站下载源码安装包：http://logging.apache.org/log4cxx/，点击左边的“Download”进入下载页面，当前（2011年8月9日）的最新版本是0.10.0，你可以下载 .tar.gz 压缩包，解压出来即可。

然后就可以直接configure，make，make install了吗？不行，因为log4cxx官方提供的源码安装包不是一个all-in-one的包，它还依赖于Apache的另外两个库：Apache Portable Runtime（APR）和Apache Portable Runtime Utility（APR-Util），你可以在这个链接找到它们：http://apr.apache.org/。

（1）安装

安装顺序不能变。首先要安装APR，下载到源码安装包后，解压出来，然后：

./configure --prefix=/usr/local/apr
make
make install

这里把APR安装到了 /usr/local/apr 目录下，注意，千万不要直接./configure，因为那样会把APR的文件安装到若干目录下，非常不利于维护。

文章来源：http://www.codelast.com/

再安装APR-Util，和上面一样，解压出来源码安装包，然后：

./configure --prefix=/usr/local/apr-util --with-apr=/usr/local/apr
make
make install

这里，通过 --with-apr 参数指定了前一步安装的APR的目录，同时也将APR-Util的安装目录设置在了/usr/local/apr-util 目录下。

最后，就是安装log4cxx了，但是在安装之前，还要再注意一点：configure的时候要指定APR和APR-Util的安装路径：

./configure --prefix=/usr/local/log4cxx --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr-util
mv libtool libtool.bak
ln -s /usr/bin/libtool libtool
make 
make install

注意，中间有两条匪夷所思的命令（mv 和 ln -s），如果不执行的话，会报错（我不太记得是在configure的时候还是make的时候报的错了）：

/usr/lib/libexpat.so: could not read symbols: File in wrong format

这些问题的解决办法是从网上搜来的，官方的指南做得不给力啊。

文章来源：http://www.codelast.com/

这样就把log4cxx安装上了，然后你需要将log4cxx整合进你的程序中，我是把 log4cxx、APR、APR-Util 的三个静态库文件全部放置到我的工程目录下的某个子目录下，然后在Makefile中指定从这个目录下去寻找库文件。三个静态库名如下：liblog4cxx.a，libapr-1.a，libaprutil-1.a。

此外，我还将 log4cxx、APR、APR-Util 的所有头文件（.h）放置到了工程目录下。并在自己的程序中include工程目录下的这些文件。

然后就是在Makefile中添加上与log4cxx相关的一切东西，包括头文件路径，库文件路径等。如果你编译的时候看到与log4cxx相关的“undefined reference ...”的错误，那么肯定是没有找到相关的库文件或头文件，这里需要提醒你的是要添加的几个库文件参数：-llog4cxx，-lapr-1，-laprutil-1。

你把上面的步骤都做好了，这个时候，你再编译你的程序，可能又会遇到以下错误（好吧，的确有点折磨人）：

./lib/log4cxx/libaprutil-1.a(apr_xml.o): In function `apr_xml_parser_geterror':

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:478: undefined reference to `XML_ErrorString'

./lib/log4cxx/libaprutil-1.a(apr_xml.o): In function `do_parse':

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:418: undefined reference to `XML_Parse'

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:422: undefined reference to `XML_GetErrorCode'

./lib/log4cxx/libaprutil-1.a(apr_xml.o): In function `cleanup_parser':

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:344: undefined reference to `XML_ParserFree'

./lib/log4cxx/libaprutil-1.a(apr_xml.o): In function `apr_xml_parser_create':

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:381: undefined reference to `XML_ParserCreate'

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:390: undefined reference to `XML_SetUserData'

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:391: undefined reference to `XML_SetElementHandler'

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:392: undefined reference to `XML_SetCharacterDataHandler'

/home/log4cxx/apr-util-1.3.12/xml/apr_xml.c:404: undefined reference to `XML_SetDefaultHandler'

collect2: ld returned 1 exit status

make: *** [cpsAPI] Error 1

文章来源：http://www.codelast.com/

这些乱七八糟的东西是怎么回事？据网上的一些文章说，这是 libaprutil 的一个bug，它不会自动链接到它的依赖项，从而导致了那些错误。要解决这个问题，你在编译的时候添加 -lexpat 参数即可——无论你是在Makefile中，还是在命令行直接用g++命令编译程序，都必须要带上这个参数，否则就会得到上面的那一堆错误（真让人恼火啊）。

这样，总算全部搞定了，程序可以编译通过了，下面，就是如何使用log4cxx来写日志的问题了，简单地说一下。在你需要写日志的类的文件中（例如MyClass.cpp），include两个log4cxx头文件：log4cxx.h和propertyconfigurator.h，然后在类的外部添加：

static log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("MyClass.cpp"));

然后在需要写日志之前，先加载log4cxx的配置文件（其实也可以不使用配置文件的，这里假设你要使用自定义的配置文件）：

log4cxx::PropertyConfigurator::configure("./log4cxx.properties");

这里指定了log4cxx.properties文件作为log4cxx的配置文件（文件名不一定是要叫log4cxx.properties），

在这个文件中定义了各种参数，例如日志文件会写到哪里去，日志的格式等等。具体的格式可以很复杂、功能很强大，这里无法给出一个详细的说明，后面会给出一个简单的文件示例。

然后就可以写日志了，例如：

LOG4CXX_INFO(logger, "Test info message.");
LOG4CXX_ERROR(logger, "Test error message.");

文章来源：http://www.codelast.com/

运行程序，看看日志是否写进去了？写进去的话就说明成功了。

上面所说的log4cxx.properties文件，给一个例子如下：

log4j.rootLogger=debug, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p (%F:%L) %c - %m%n
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=./app.log
log4j.appender.R.MaxFileSize=200KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %p (%F:%L) %c - %m%n

更多log4cxx的详细用法，可以参考log4cxx的一些官方例子：http://logging.apache.org/log4cxx/index.html
文章来源：http://www.codelast.com/
附：【使用log4cxx遇到的一些问题记录】
（1）IO Exception : status code =28
这个错误可能是由于磁盘空间满了造成的，log4cxx无法将日志写入磁盘上，请看这个链接。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

环境：

RHEL 5.3（内核2.6.18-128.el5），32位

gcc 4.1.2

Boost 1.35.0

（1）什么是Thrift？

先转一段网上的定义：

Thrift是一个跨语言服务部署框架，最初由Facebook于2007年开发，后于2008年进入Apache孵化器(Apache Incubator)。

类似于SOAP，COM 和CORBA，Thrift通过定义一个中间定义语言和Thrift代码生成工具，生成指定语言的代码。目前，Thrift支持C++,Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, Smalltalk和OCaml的代码生成。

简单分析其机理，Thrift就是实现C/S模式，通过代码生成工具将接口定义文件生成服务器端和客户端代码（可以为不同语言），从而实现服务端和客户端跨语言的支持。

（2）从源码安装Thrift的时候，也像通常的软件安装过程一样，通过configure → make → make install 的过程就可以完成。但安装过程比较烦人，我遇到了一个又一个的问题，总的来说还是比较繁琐的，特别记下来：

Thrift在configure的时候提示找不到php-config的话，需要手动指定其路径（如果没装PHP则需安装）。

PHP 5.3.4安装的过程中，configure的时候出现error，提示找不到libxml2，于是我安装了libxml2-devel-2.6.26-2.1.2.7.i386.rpm。

你还需要预先安装libevent库，我安装的是libevent-2.0.9-rc版本。

文章来源：http://www.codelast.com/

如果你没有安装Boost就执行Thrift的configure，则会看到下面的提示：

Building C++ Library ......... : no

此时，如果你make，也得不到Thrift的C++库。

以默认参数安装了Boost之后（我安装的是1.35.0版本），configure的时候就会看到下面的提示：

Building C++ Library ......... : yes

然后重新开始make。

文章来源：http://www.codelast.com/

到了某一步，如果提示下面的错误：

src/protocol/fastbinary.c:20:20: error: Python.h: No such file or directory

（中间一堆的错误，此处省略）

error: command 'gcc' failed with exit status 1

这是怎么回事呢？打开 lib/py/src/protocol/fastbinary.c 文件，看看第一行未注释的代码：

#include <Python.h>

说明在系统路径中要能找到Python.h文件，而这个文件，是在你安装了python开发包之后才有的，所以，去安装然后再make吧。

我安装的包：python-devel-2.4.3-24.el5.i386.rpm

文章来源：http://www.codelast.com/

在成功make了之后，可以看到输出的提示：

Build complete.

然后再make install，就可以在 /usr/local/lib/ 下（依系统不同，目录也不一定是这个）找到Thrift的库文件啦：

-rw-r--r--  1 root root 5762970 Dec 15 17:41 libThrift.a

-rwxr-xr-x  1 root root     949 Dec 15 17:41 libThrift.la

-rw-r--r--  1 root root  468526 Dec 15 17:41 libThriftnb.a

-rwxr-xr-x  1 root root     963 Dec 15 17:41 libThriftnb.la

lrwxrwxrwx  1 root root      20 Dec 15 17:41 libThriftnb.so -> libThriftnb.so.0.0.0

lrwxrwxrwx  1 root root      20 Dec 15 17:41 libThriftnb.so.0 -> libThriftnb.so.0.0.0

-rwxr-xr-x  1 root root  339359 Dec 15 17:41 libThriftnb.so.0.0.0

lrwxrwxrwx  1 root root      18 Dec 15 17:41 libThrift.so -> libThrift.so.0.0.0

lrwxrwxrwx  1 root root      18 Dec 15 17:41 libThrift.so.0 -> libThrift.so.0.0.0

-rwxr-xr-x  1 root root 3308490 Dec 15 17:41 libThrift.so.0.0.0

-rw-r--r--  1 root root  184672 Dec 15 17:41 libThriftz.a

-rwxr-xr-x  1 root root     956 Dec 15 17:41 libThriftz.la

lrwxrwxrwx  1 root root      19 Dec 15 17:41 libThriftz.so -> libThriftz.so.0.0.0

lrwxrwxrwx  1 root root      19 Dec 15 17:41 libThriftz.so.0 -> libThriftz.so.0.0.0

-rwxr-xr-x  1 root root  145732 Dec 15 17:41 libThriftz.so.0.0.0

文章来源：http://www.codelast.com/

然后就可以开始你的Thrift C++开发之旅了！

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

假设你有上百G的数据，你要统计出这些数据中，含有某些你感兴趣的内容的数据的有多少条，你会怎么做？在硬件条件允许的情况下，用hadoop并行计算是一个不错的选择。

为了使本文得以清晰地说明，我们不妨假设如下的情况：

我们有100G的数据，分别保存在5个文件中，它们位于 /data/ 目录下。这5个数据文件的内容均为相同的格式，即，文件的内容大致如下：

ABCDSDFKJDKF kkk 2890876

SDKFJIEORUEW nnn 1231238

LSFKDFSSDRDE bbb 9234999

说明：每一行内容中，首先是一个12字节的字符串，然后是一个3字节的字符串，然后是一个7个数字组成的字符串。字符串之间是用空格分隔的。

我们的问题是：在这100G的数据中，请统计出第二项字符串为“kkk”和“nnn”的数据分别有多少条？

如果用一个非分布式的应用程序来计算这个问题，如果计算机硬件配置不够强劲的话，那么估计得算到天荒地老了。

而用hadoop来并行计算，一切都是那么简单。

下面，我们就来看看，如何用C++开发一个hadoop上的应用程序，来完成我们的任务。

尽管hadoop平台是用Java写的，但是它仍然支持用C++来开发应用程序，这里不讨论优劣对比，只是基于这样一个事实：有些人觉得用C++写更熟悉，所以我们才用C++写。

先说明：本文基于hadoop 0.20.2版本。

文章来源：http://www.codelast.com/

（1）首先我们需要知道map-reduce的基本原理，这里不说了。其次我们需要知道，在用C++编写hadoop应用程序时，需要包含三个头文件：

#include "Pipes.hh"

#include "TemplateFactory.hh"

#include "StringUtils.hh"

这三个文件在hadoop安装包的 “c++\Linux-amd64-64\include\” 或 “c++\Linux-i386-32\include\” 子目录下（根据你的操作系统是64位或32位，分别对应不同的目录）。

既然有头文件，就需要有对应的实现文件，或者动态/静态库，这里我用的是静态库 libhadooppipes.a 和 libhadooputils.a 。静态库是在Makefile中指定的，后面再说。这里特别提醒一下大家：如果你的hadoop集群不是只有一台服务器，那么如果你编译时使用了任何动态库的话，在运行的时候就要保证在别的hadoop服务器上也能找到相应的动态库，否则就会在hadoop JobTracker的详细信息中看到找不到动态库的错误提示。

文章来源：http://www.codelast.com/

（2）下面来看看程序：

#include"Pipes.hh"
#include"TemplateFactory.hh"
#include"StringUtils.hh"

class DataCountMap:public HadoopPipes::Mapper {
public:
  DataCountMap(HadoopPipes::TaskContext&context){}
  void map(HadoopPipes::MapContext&context) {
    std::vector<std::string>words=HadoopUtils::splitString(context.getInputValue()," ");    // 这里是分割字符串，如前文所述，每一行数据中的各项是以空格来分割的。分割的结果保存到了一个std::vector中
    if("kkk"==words[1]) {
      context.emit("kkk","1");
    } else if("nnn"==words[1]) {
      context.emit("nnn","1");
    }
  }
};

class DataCountReduce:public HadoopPipes::Reducer {
public:
  DataCountReduce(HadoopPipes::TaskContext&context){}
  void reduce(HadoopPipes::ReduceContext&context)
  {
    int sum=0;
    while(context.nextValue()) {
      sum++;
    }
    context.emit(context.getInputKey(),HadoopUtils::toString(sum));
  }
};

int main(int argc,char*argv[])
{
  return HadoopPipes::runTask(HadoopPipes::TemplateFactory<DataCountMap, DataCountReduce>());
}

上面的程序挺简单的，只要你知道了map-reduce的基本原理。

一个map类，一个reduce类，一个执行任务的main函数。

map类对每一行数据进行拆分，当找到我们感兴趣的“kkk”或“nnn”时，就生成一条输出的记录（emit函数的作用）；recude类对map的数据进行汇总，这里只是简单地计数，所以每次+1。

文章来源：http://www.codelast.com/

（3）有了代码，我们接着就要编写相应的Makefile了。我的Makefile如下：

HADOOP_INSTALL = /usr/local/hadoop

INCLUDE_PATH = $(HADOOP_INSTALL)/src/c++/

CC              = g++

CXXFLAGS = -Wall -g \

                  -I${INCLUDE_PATH}pipes/api/hadoop \

                  -I${INCLUDE_PATH}utils/api/hadoop

LDFLAGS = -ljvm -lhadooppipes -lhadooputils -lpthread

OBJECTS=dz_count.o

dz_count: $(OBJECTS)

$(CC) $(CXXFLAGS) -o $@ $(OBJECTS) $(LDFLAGS)

其中，HADOOP_INSTALL是你的hadoop安装路径，其余的 INCLUDE_PATH 等请对照你的目录做相应更改，最后生成的可执行程序名为dz_count。这里没有考虑release，因为仅作简单的说明用。

文章来源：http://www.codelast.com/

（4）有了代码和Makefile，就可以编译了。编译得到可执行程序dz_count。将其上传到hdfs中：

hadoop fs -put dz_count /my_dir/

其中 “/my_dir/” 是你在hdfs中的目录。

文章来源：http://www.codelast.com/

（5）下面就可以运行我们的hadoop程序了：

hadoop pipes -D hadoop.pipes.java.recordreader=true -D hadoop.pipes.java.recordwriter=true -input /data/ -output /my_dir/output -program /my_dir/dz_count

其中，-input /data/ 表明你的输入数据（即你的源数据）所处的hdfs目录为 /data/，-output /my_dir/output 表明你的输出文件目录为 /my_dir/output，“output” 这一级目录必须不存在（如果存在会报错），程序运行时会生成它。-program /my_dir/dz_count 表明你要运行的程序为 /my_dir/ 目录下的 dz_count 程序。

回车之后程序就开始执行，随后你可以在命令行下看到它的状态在更新，或者在hadoop JobTracker中也可以观察到程序的运行状态。

文章来源：http://www.codelast.com/

（6）等程序执行完后，如果任务没有失败的话，我们可以看到，你前面指定的hdfs输出目录 /my_dir/output 里生成了一个文件（假设其名为“part-00000”），我们就可以查看执行结果了：

hadoop fs -cat /my_dir/output/part-00000

输出结果形为：

kkk   178099387

nnn   678219805

表明第二项为“kkk”的数据行共有178099387条，而“nnn”则为678219805条。

文章来源：http://www.codelast.com/

顺便再说一点废话：

（1）如何中止一个hadoop任务？当你在命令行下提交了一个hadoop job后，就算你按Ctrl+C，也不能中止掉那个job，因为它已经被Jobtracker接管了。这时，你要用如下命令中止它：

hadoop job -kill Job_ID

其中，Job_ID就是你提交的job的ID，可以在Jobtracker中查看到。

（2）一些基本概念：

map-reduce过程中，在map时，hadoop会将输入的数据按一定的大小（例如100M，这个值是可以配置的）分为若干块来处理，一个块对应一个map类，也就是说，一个块只会执行map类的构造函数一次。而每一行记录则对应一个map()方法，也就是说，一行记录就会执行一次map()方法。因此，如果你有什么信息需要输出（例如std::cout）的话，就要注意了：如果在map()方法中输出，则当输入数据量很大时，可能就会输出太多的信息，如果可以在map的构造函数中输出的话，则输出的信息会少得多。

在reduce时，对map输出的同一个key，有一个reduce类，也就是说，无论你的同一个key有多少个value，在reduce的时候只要是同一个key，就会出现在同一个reduce类里，在这个类里的reduce方法中，你用 while (context.nextValue()) 循环可以遍历所有的value，这样就可以处理同一个key的N个value了。
正因为在默认情况下，相同key的记录会落到同一个reducer中，所以，当你的key的数量比你设置的reducer的数量要少的时候，就导致了某些reducer分配不到任何数据，最终输出的某些文件（part-r-xxxxx）是空文件。如果你设置的reducer数量要少于key的数量（这是最常见的情况），那么就会有多个key落入同一个reducer中被处理，但是，每一次reduce()方法被调用时，其中将只包含一个key，同一个reducer里的多个key就会导致reduce()方法被多次调用。

文章来源：http://www.codelast.com/

这样，我们就完成了一个完整的C++ hadoop分布式应用程序的编写。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：