运行Pig脚本时报错：

Error before Pig is launched
----------------------------
ERROR 2997: Encountered IOException. org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.
Was expecting one of:
    <IDENTIFIER> ...
    <OTHER> ...
    <LITERAL> ...
    <SHELLCMD> ...
java.io.IOException: org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.
Was expecting one of:
    <IDENTIFIER> ...
    <OTHER> ...
    <LITERAL> ...
    <SHELLCMD> ...

        at org.apache.pig.impl.PigContext.doParamSubstitution(PigContext.java:408)
        at org.apache.pig.Main.runParamPreprocessor(Main.java:783)
        at org.apache.pig.Main.run(Main.java:446)
        at org.apache.pig.Main.main(Main.java:158)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:497)
        at org.apache.hadoop.util.RunJar.run(RunJar.java:221)
        at org.apache.hadoop.util.RunJar.main(RunJar.java:136)
Caused by: org.apache.pig.tools.parameters.ParseException: Encountered "<EOF>" at line 1, column 8.

（4）树莓派的GPIO应用（一）
4.1 GPIO 接口编程(1)：LED 闪烁( OUTPUT )
4.2 GPIO 接口编程(2)：按钮控制 LED ( INPUT ) ——包括Pooling及Interrupt实现，Software Switch Debouncing实现
4.3 GPIO 接口编程(3)：LED 呼吸灯&驱动压电元件( PWM )

（5）树莓派的GPIO应用（二）
5.1 人体接近感应灯
5.2 控制步进电机
5.3 驱动液晶屏——包括多GPIO口及I2C总线驱动LCD1602实现

（6）树莓派项目实践（一）——可用 web 控制的人体感应小夜灯
6.1 需求分析
6.2 人体接近感应功能的实现
6.3 让树莓派系统正确走时
6.4 前后端程序实现

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

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

Raspberry Pi是什么？简单地说，它就是一个基于ARM CPU的、信用卡那么大的迷你计算机。
In short, Pi is an ARM-based mini computer which has a credit card size.

本文主要内容：
在Raspberry Pi上，通过调用OpenCV库，自己写一个简单的C程序来控制摄像头拍照，并保存图片。
在阅读本文之前，请确保你已经阅读过我的另一篇配置Pi的文章，因为本文是在它的基础上进行的。
The main content of this article:
Write a simple C program by invoking the OpenCV library on Raspberry Pi to control a webcam to take photos & save them.
Before reading this article, please make sure that you've read my another article about Pi configuration, because this article is based on that.

【1】安装OpenCV / Install OpenCV
命令：
Command:

pacman -S opencv opencv-samples

上面的命令连OpenCV的sample一起装上了，这样我们在安装好之后就可以编译几个sample来测试。
This command will install the samples of OpenCV, too. So we can compile & run several samples to have a test after the installation.

【2】带动摄像头 / Drive the webcam
在驱动已经可用的情况下，把一个USB摄像头接在USB口上也不一定能让它工作，因为Pi的USB口的电流供应可能不足。请看这个链接的玩家自制的一根增强供电的USB线，如果你想简单安全，那么你可以把摄像头接在一个有外部供电的USB HUB上，再把Pi的USB接到USB HUB上，这样摄像头的供电就充足了。
Plug the USB webcam into the USB interface of Pi might not able to make it work, even the driver has been available, because the current provided by Pi's USB interface may not be sufficient to drive a camera. You can learn to DIY a current-enhancement USB cable via this link, but the easier way may be buying a powered USB HUB and use it to connect the webcam & Pi.

【3】让opencv的sample跑起来 / Run a sample of OpenCV
为了验证在Pi上安装的OpenCV是可用的，所以至少要让一个sample可以跑起来。
为了不把安装目录弄得一团乱，首先把安装好的OpenCV的sample目录拷贝到其他地方：
To make sure that the installed OpenCV related packages are "correct", I decided to run at least one of the OpenCV samples.
Copy the installed OpenCV sample directory to other place for the sake of not messing up the installation directory:

mkdir /root/opencv
cp -r /usr/share/OpenCV/samples/ /root/opencv/

我们看到里面有“c”，“cpp”和“gpu”三种sample，选最简单的，我们进入“c”，先为所有文件加上写权限：
There are 3 kinds of samples in it, "c", "cpp" & "gpu", so I choose the simplest - "c", and enter the "c" directory, add write permission to all files:

chmod +w *

然后我们看到“c”目录里有编译脚本 build_all.sh，执行它，看到出了一堆相似的错误，没有一个程序可以成功编译，例如以下错误：
Execute the build_all.sh script to compile an sample, then I got lots of similar errors, e.g. :

[root@alarmpi c]# ./build_all.sh contours.c 

 compiling contours

 /usr/bin/ld: /tmp/cch4zRSn.o: undefined reference to symbol 'lrint@@GLIBC_2.4'

 /usr/bin/ld: note: 'lrint@@GLIBC_2.4' is defined in DSO /usr/lib/libm.so.6 so try adding it to the linker command line

 /usr/lib/libm.so.6: could not read symbols: Invalid operation

 collect2: error: ld returned 1 exit status

#!/bin/sh                           

if [ $# -gt 0 ] ; then
        base=`basename $1 .c`
        echo "compiling $base"
        gcc -ggdb `pkg-config opencv --cflags --libs` $base.c -o $base -lm
else
        for i in *.c; do
            echo "compiling $i"
            gcc -ggdb `pkg-config --cflags opencv` -o `basename $i .c` $i `pkg-config --libs opencv` -lm;
        done
        for i in *.cpp; do
            echo "compiling $i"
            g++ -ggdb `pkg-config --cflags opencv` -o `basename $i .cpp` $i `pkg-config --libs opencv` -lm;
        done
fi

文章来源：http://www.codelast.com/
还忘了说一句，由于上面的脚本在编译时使用了pkg-config，所以在编译前，我们还需要先安装 pkg-config：
Sorry, I forget to mention that because of using pkg-config, we need to install pkg-config before compiling the sample:

pacman -S pkg-config

然后再编译，成功。
Then the compiling will succeed.
那么下面，我们再接着尝试把编译出的sample运行起来：
Then run the executable program we just compiled:

[root@alarmpi c]# ./contours 

This program creates an image to demonstrate the use of the "c" contour
functions: cvFindContours() and cvApproxPoly() along with the storage
functions cvCreateMemStorage() and cvDrawContours().
It also shows the use of a trackbar to control contour retrieval.
 
Usage :
./contours
 
(image:460): Gtk-WARNING **: cannot open display:

很明显，运行不起来。
看样子是跟gtk相关，并且我在网上搜到这跟X server什么的可能有关系，于是安装gtk和X server：
It failed, unfortunately.
And Google told me that the error is related to X server, too, so I installed gtk & X server:

pacman -S gtk xorg-server

再修改配置文件 /etc/ssh/sshd_config ：
Modify the config file /etc/ssh/sshd_config :

#AllowTcpForwarding yes
AllowTcpForwarding yes
#GatewayPorts no
#X11Forwarding no
X11Forwarding yes
#X11DisplayOffset 10
#X11UseLocalhost yes
X11UseLocalhost yes

注意，没有注释的那三行是我添加的。
Note that the 3 uncommented lines are added by me.
文章来源：http://www.codelast.com/
重启Pi的系统，运行X server：
Reboot Pi & run X server:

X

没错，命令就是这么简单。然后又出错了：
Yes, the command is just so simple, but it failed to start:

[root@alarmpi c]# X       

 

 X.Org X Server 1.13.0

 Release Date: 2012-09-05

 X Protocol Version 11, Revision 0

 Build Operating System: Linux 3.0.15-1-ARCH+ armv6l 

 Current Operating System: Linux alarmpi 3.2.27-11-ARCH+ #1 PREEMPT Sat Oct 13 22:46:16 UTC 2012 armv6l

 Kernel command line: dma.dmachans=0x7f35 bcm2708_fb.fbwidth=1920 bcm2708_fb.fbheight=1080 bcm2708.boardrev=0x3 bcm2708.serial=0x398ca41f smsc95xx.macaddr=B8:27:EB:8C:A4:1F vc_mem.mem_base=0xc000000 vc_mem.mem_size=0x10000000  sdhci-bcm2708.enable_llm=1 sdhci-bcm2708.sync_after_dma=0 smsc95xx.turbo_mode=N dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 loglevel=2 root=/dev/mmcblk0p2 init=/bin/systemd rootfstype=ext4 rootwait

 Build Date: 14 October 2012  10:05:22PM

  

 Current version of pixman: 0.26.2

  Before reporting problems, check http://wiki.x.org

  to make sure that you have the latest version.

 Markers: (--) probed, (**) from config file, (==) default setting,

  (++) from command line, (!!) notice, (II) informational,

  (WW) warning, (EE) error, (NI) not implemented, (??) unknown.

 (==) Log file: "/var/log/Xorg.0.log", Time: Mon Oct 15 14:30:03 2012

 (==) Using config directory: "/etc/X11/xorg.conf.d"

 Initializing built-in extension Generic Event Extension

 Initializing built-in extension SHAPE

 Initializing built-in extension MIT-SHM

 Initializing built-in extension XInputExtension

 Initializing built-in extension XTEST

 Initializing built-in extension BIG-REQUESTS

 Initializing built-in extension SYNC

 Initializing built-in extension XKEYBOARD

 Initializing built-in extension XC-MISC

 Initializing built-in extension SECURITY

 Initializing built-in extension XINERAMA

 Initializing built-in extension XFIXES

 Initializing built-in extension RENDER

 Initializing built-in extension RANDR

 Initializing built-in extension COMPOSITE

 Initializing built-in extension DAMAGE

 Initializing built-in extension MIT-SCREEN-SAVER

 Initializing built-in extension DOUBLE-BUFFER

 Initializing built-in extension RECORD

 Initializing built-in extension DPMS

 Initializing built-in extension X-Resource

 Initializing built-in extension XVideo

 Initializing built-in extension XVideo-MotionCompensation

 Initializing built-in extension XFree86-VidModeExtension

 Initializing built-in extension XFree86-DGA

 Initializing built-in extension XFree86-DRI

 Initializing built-in extension DRI2

 Loading extension GLX

 

 Fatal server error:

 no screens found

 (EE) 

 Please consult the The X.Org Foundation support 

   at http://wiki.x.org

  for help. 

 (EE) Please also check the log file at "/var/log/Xorg.0.log" for additional information.

 (EE) 

 Server terminated with error (1). Closing log file.

既然它让我看日志文件 /var/log/Xorg.0.log，那我就看。在日志文件的最后，发现提示找不到 fbdev 模块/库，于是翻遍Google，找到一个答案：应该安装 xf86-video-fbdev 包：
Since it told me to check log file /var/log/Xorg.0.log, then I did. At the last few lines of the log file, I found an error message which indicated a fbdev module/lib missing, so I ask Google again for a while, and I realized that I should install package xf86-video-fbdev:

pacman -S xf86-video-fbdev

文章来源：http://www.codelast.com/
再用“X”命令启动X server，成功了：
Then run "X" again, it succeeded:

[root@alarmpi ~]# X

 

 X.Org X Server 1.13.0

 Release Date: 2012-09-05

 X Protocol Version 11, Revision 0

 Build Operating System: Linux 3.0.15-1-ARCH+ armv6l 

 Current Operating System: Linux alarmpi 3.2.27-11-ARCH+ #1 PREEMPT Sat Oct 13 22:46:16 UTC 2012 armv6l

 Kernel command line: dma.dmachans=0x7f35 bcm2708_fb.fbwidth=1920 bcm2708_fb.fbheight=1080 bcm2708.boardrev=0x3 bcm2708.serial=0x398ca41f smsc95xx.macaddr=B8:27:EB:8C:A4:1F vc_mem.mem_base=0xc000000 vc_mem.mem_size=0x10000000  sdhci-bcm2708.enable_llm=1 sdhci-bcm2708.sync_after_dma=0 smsc95xx.turbo_mode=N dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 loglevel=2 root=/dev/mmcblk0p2 init=/bin/systemd rootfstype=ext4 rootwait

 Build Date: 14 October 2012  10:05:22PM

  

 Current version of pixman: 0.26.2

  Before reporting problems, check http://wiki.x.org

  to make sure that you have the latest version.

 Markers: (--) probed, (**) from config file, (==) default setting,

  (++) from command line, (!!) notice, (II) informational,

  (WW) warning, (EE) error, (NI) not implemented, (??) unknown.

 (==) Log file: "/var/log/Xorg.0.log", Time: Mon Oct 15 14:32:34 2012

 (==) Using config directory: "/etc/X11/xorg.conf.d"

 Initializing built-in extension Generic Event Extension

 Initializing built-in extension SHAPE

 Initializing built-in extension MIT-SHM

 Initializing built-in extension XInputExtension

 Initializing built-in extension XTEST

 Initializing built-in extension BIG-REQUESTS

 Initializing built-in extension SYNC

 Initializing built-in extension XKEYBOARD

 Initializing built-in extension XC-MISC

 Initializing built-in extension SECURITY

 Initializing built-in extension XINERAMA

 Initializing built-in extension XFIXES

 Initializing built-in extension RENDER

 Initializing built-in extension RANDR

 Initializing built-in extension COMPOSITE

 Initializing built-in extension DAMAGE

 Initializing built-in extension MIT-SCREEN-SAVER

 Initializing built-in extension DOUBLE-BUFFER

 Initializing built-in extension RECORD

 Initializing built-in extension DPMS

 Initializing built-in extension X-Resource

 Initializing built-in extension XVideo

 Initializing built-in extension XVideo-MotionCompensation

 Initializing built-in extension XFree86-VidModeExtension

 Initializing built-in extension XFree86-DGA

 Initializing built-in extension XFree86-DRI

 Initializing built-in extension DRI2

 Loading extension GLX

文章来源：http://www.codelast.com/
再试着运行OpenCV的sample，依然不行，Google搜索到一篇在Pi上运行OpenCV的文章，作者做了这样一件事情：
Then I tried to run the OpenCV sample again, still the same error("cannot open display"), so I Googled another article about using OpenCV on Pi and found that the author did one thing:

export DISPLAY=192.168.3.65:0.0

其中，192.168.3.65是Pi的IP地址。这样设置之后，再运行，程序不再报错了！再一看相同的目录下，生成了一个 contours.xml 文件，说明程序执行成功了。
In which the "192.168.3.65" is your Pi's IP address. After setting this, the sample could run without any error occurred, and a contours.xml file was generated under the same directory, which indicated that we succeeded.

【4】写一个简单的OpenCV C程序 / Write a simple OpenCV C program
现在该写一个简单的OpenCV C程序来控制摄像头了。
Now we should write a simple C program to control the webcam by using OpenCV.

直接看程序：
Let's check the C code:

#include <stdio.h>
#include <stdlib.h>
#include "highgui.h"
#include "opencv.hpp"

int main(int argc, char **argv) {
	/* init camera */
	CvCapture* pCapture = cvCreateCameraCapture(0);
	cvSetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_WIDTH, 320); 
	cvSetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_HEIGHT, 240);
	//cvSetCaptureProperty(pCapture, CV_CAP_PROP_FPS, 5);

	IplImage *pFrame = 0;

	if (NULL == pCapture) {
		fprintf(stderr, "Can't initialize webcam!\n");
		return 1;
	}

	pFrame = cvQueryFrame(pCapture);	// query a frame 

	if(NULL == pFrame) {
		fprintf(stderr, "Can't get a frame!\n" );
		return 1;
	}

	const char *pImageFileName = "webcam.jpg";
	cvSaveImage(pImageFileName, pFrame);

	cvReleaseCapture(&pCapture);	// free memory

	return 0;
}

此程序做的事情非常简单：初始化摄像头，抓取一帧，然后保存为名为“webcam.jpg”的图片。
This program does a very simple job: initialize the camera, capture a frame & save it to a image file named "webcam.jpg".
文章来源：http://www.codelast.com/
编译自己的webcam程序：
Then compile the webcam program:

g++ -I/usr/include/opencv/ -I/usr/include/opencv2/  `pkg-config --cflags opencv --libs opencv` webcam.c -o webcam

会生成一个可执行程序“webcam”，运行它：
This will generate an executable bin "webcam", just run it:

./webcam

然后在相同目录下，会看到生成了一个“webcam.jpg”图片，正是摄像头拍的照。
Then we'll get a "webcam.jpg" image file under the same directory, which is just the photo took by the camera.

这样，本文的主要目的就达成了。可以在此基础上继续开发其他的程序，来实现更为有用的功能，例如像摄像头娘一样的运动检测功能。
So the main purpose of this article has been reached. We can develop more useful programs base on it, e.g. a program similar to the Camera Girl, which implements the motion detection functionality.
文章来源：http://www.codelast.com/
【5】遗留问题 / Unsolved problems
在上述过程中，其实我还遇到了一些未解决的问题，暂时没有时间深究，在此先记录如下。
In the above process I met some unsolved problems and have no time to explore them yet, so I just write them down here for further study.

①拍照时使用稍高的分辨率就导致程序崩溃 / Use a little high resolution will cause the program crash
在上面的程序中，如下两句是用于设置分辨率的（宽*高）：
In the above codes, the two lines below are used to set the resolution:

cvSetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_WIDTH, 320); 
cvSetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_HEIGHT, 240);

根据我的试验，160*120的低分辨率比较少出问题，尽管320*240的分辨率对摄像头来说也根本不算高的，但是就算是使用320*240的分辨率，程序还是偶尔会崩溃的，报错如下：
According to my experiments, the 160*120 low resolution cause less crashes than higher resolutions. Even 320*240 is not a high resolution for a webcam nowadays, it still made the program crashed some times, and the error messages are:

[root@alarmpi c]# ./webcam 
VIDIOC_QUERYMENU: Invalid argument
VIDIOC_QUERYMENU: Invalid argument
VIDIOC_QUERYMENU: Invalid argument
VIDIOC_REQBUFS: Cannot allocate memory
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
Unable to stop the stream.: Bad file descriptor
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
munmap: Invalid argument
HIGHGUI ERROR: V4L: Initial Capture Error: Unable to load initial memory buffers.
Can't get a frame!

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

VIDIOC_REQBUFS: Cannot allocate memory
HIGHGUI ERROR: V4L/V4L2: Could not obtain specifics of capture window.

Unable to stop the stream.: Bad file descriptor
VIDIOC_QBUF: Bad file descriptor
Can't get a frame!

我不确定这是跟Pi的CPU计算能力较弱有关呢，还是跟Pi的RAM太小有关呢，还是跟摄像头的供电不足有关呢（我没有使用带电源的USB HUB来接摄像头），或者是跟摄像头的驱动有关呢？
如果你知道解决办法，请赐教，非常感谢。
I'm not sure whether the problem is caused by the weak computation capability of Pi's CPU, or the too-small RAM on Pi, or the insufficient current supply of the webcam(I didn't use a powered USB HUB to connect the webcam to Pi), or the webcam's Linux driver...
If you know something, please tell me and thank you in advance.

2015-02-19更新：
在树莓派model B+上，使用OpenCV 2.4.10版的上述程序，已经没有了上面所说的问题，经我测试，每隔2秒一次，连续抓取了将近30分钟的图像，一次都没有问题。

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

The Raspberry Pi is a credit card sized single-board computer developed in the UK by the Raspberry Pi Foundation with the intention of stimulating the teaching of basic computer science in schools.

简单地说，它就是一个基于ARM CPU的、信用卡那么大的迷你计算机。
In short, Pi is an ARM-based mini computer which has a credit card size.

这货能拿来干嘛？由于它是一台计算机，并且它有着很迷你的体积，最关键的，它还很便宜，因此，用处实在太多了。有人拿它来控制玩具，有人拿它来酿酒，甚至还有人拿它来做超级计算机！
是的，这帮人确实太能玩了...
What can you use it for? Because it's a computer which has a very mini size, and most importantly, it's cheap enough, so it's really useful. Someone use it to control a toy(people outside China mainland may not able to visit this video link due to copyright reason), someone use it to brew beer, and someone even used Pis to build a supercomputer!
文章来源：http://www.codelast.com/
我在Raspberry Pi上安装的系统是官方推荐的几个系统之一：Arch Linux ARM（这不是第一推荐的那个Raspbian）。
What I installed on Pi is one of the official recommended Operation Systems: Arch Linux ARM(but this is not the most recommended Raspbian).

一开始我也是先尝试使用官方推荐的Raspbian，但是由于在刷好系统之后，进入系统之前进行配置的时候，对键盘布局的配置无论如何都无法保存，一直有一个error，导致无法正常使用键盘，所以我最终只能放弃了它，转而使用Arch Linux ARM，这就意味着自己需要做很多的配置工作了。
下面各项，就是我在折腾的过程中遇到的各种问题以及解决办法。
At first I was trying to use the most official recommended OS - Raspbian, but after writing the OS image to my SD card, and before logging into the system, I met an keyboard layout configuration error in the configuration step, no matter how many times I tried, it's always the same, so I had to turn to Arch Linux ARM, which means that I need to do lots of configuration work myself.
Below notes, are the problems I met in the process of configuring Pi and the solutions.

【1】关于分区 / About the partitions
如果你是在Windows下刷的Arch Linux ARM系统，那么，你可能是用官方推荐的Win32DiskImager软件来刷的。Arch Linux ARM的镜像文件（一个.img文件）有约1.8G大，用Win32DiskImager将其刷到SD卡上之后，会发现根目录“/”所在的分区只有1点几G大，并且没有交换空间（swap），这很麻烦，因为我们随便装几个软件就会占满根目录所在分区，例如一个emacs就有几百M大。
If you wrote the OS image to SD card on Windows, you might use the official recommended Win32DiskImager to do the work. The Arch Linux ARM OS image file(an .img file) has a size about 1.8GB, after you use Win32DiskImager to write it to a SD card, you'll find that the partition which contains the root directory "/" has a space of 1.X GB, and there is no swap partition - this is a trouble because the partition space will be used up soon, e.g. installing emacs related packages will use more than 200 MB space.

所以，我们要让根目录几乎使用全部的SD卡空间。例如，我的SD卡是16G的，我想把1G空间拿来做swap，其余的就给根目录了。
So, I need to let the root directory partition use almost the whole SD card space. For example, I have a 16GB SD card, then I want 1GB to be the swap, and the left space to be the root directory partition.
Youtube上有教程说明如何用GParted（一款开源软件）来操作SD卡，从而将更改系统分区的大小，我也曾尝试，不幸的是我在调整好空间大小之后，一点击“Apply”应用我的修改就出错，无法继续下去。所以我最后是采取了一个最简单，也成功了的办法，那就是：使用Ubuntu系统自带的磁盘管理工具来重新分区，听我慢慢道来：
There is a video tutorial on Youtube teaching you how to resize the partition to full SD card capacity by using GParted(an open-source software). I tried that, but failed all the times, whenever I clicked the "Apply" button I got an error and couldn't continue, so at last I used a very simple way to do the same work, and it worked, that is, I used the disk management tool in Ubuntu to "resize" the SD card partition, as following:
（1）进入Ubuntu系统，将SD卡上1点几G的那个分区（也就是根目录所在的分区）里的文件备份成tar包：
Logging into Ubuntu and backup the files in the SD card root partition with a size of 1.X GB to a tar package:

tar cf os.tar XXX/*

其中，XXX是指你的SD卡目录。
这个备份出来的tar包在后面我们修改完分区大小之后，恢复系统的时候要用。
The XXX refers to you SD card directory and the tar package will be used to restore your OS after resizing the partition.
文章来源：http://www.codelast.com/
（2）用Ubuntu系统自带的图形化磁盘管理工具（具体名字记不得了），删除掉1点几G的那个SD卡分区，同时你会发现，有一个十几G的未分配的空间，这就是我们要利用的宝贵空间。然后划分出一个13G的ext4分区（Pi官方推荐的那个Arch Linux ARM镜像刷出来的系统用的就是ext4文件系统），这将作为新的系统所在分区。
Use the graphical disk management tool(I forget the software name, sorry) to delete the SD card partition with the size of 1.X GB, and you'll find that there is an "unallocated" partition which has a size of > 10GB(NOTE: my SD card is a 16GB card) - it's just the free space we want to use. Then create a 13GB partition with ext4 format, which will be used as the new OS partition.
（3）将剩下的空间划分为一个交换空间（swap），如果你觉得此空间太大有点浪费，那么你可以在上一步里把空间设大一点，那么这里剩下的swap空间就会小一点，总之，自己衡量。
Use the left space to create a swap partition. If you think that it's a waste to allocate so much space to swap, you can allocate more space to OS partition in the previous step. Anyway, judge it by yourself.
（4）待Ubuntu操作完成，把SD卡挂载上去，现在，你就有了一个十几G的系统分区和一个1G的swap分区。但是，由于重新分区，系统已经没了，我们怎么恢复？用刚才备份的tar文件就可以恢复。将其中的文件解压到十几G的系统分区里，你原来的设置、安装的软件都不会丢。但是要注意，可能你解压文件的时候，用的不是root用户，而是其他用户，那么你要保证解压出来之后，要修改所有文件的权限为root：
After the partition operation finished, just mount the SD card, then you'll find that you have a > 10GB OS partition and a swap partition, but you lost the OS on the partition, so, how to restore the OS? Remember the tar file we backup before? Yes, unpack the files in the tar package to the OS partition, you'll get your previous OS back! But note that, when unpacking the tar file, you may use a non-root Ubuntu account, so after the unpacking done, we should change the ownership of all files/directories:

chown -R root:root XXX/

其中，XXX为你的SD卡的挂载目录。这是因为刚刷到Pi上的Arch Linux ARM只有一个root用户，我没有添加其他用户，所有文件owner均为root。
The XXX refers to your SD card mounted directory. I do this because I didn't add any other user for my Arch Linux ARM, except the root user.
（5）把SD卡umount下来，插入Pi的卡槽中，启动系统，发现一切正常，成功了！
Then umount the SD card from Ubuntu, plug it into Pi, and boot Pi, everything is OK, it works with no problem.
文章来源：http://www.codelast.com/
【2】添加开机启动的程序 / Run your program on OS startup
要让Pi开机启动一个脚本/执行一个命令怎么办？
我们知道，RedHat有 /etc/rc.local 文件，在里面写上要执行的命令就可以开机执行了，这是最简单的办法，而Arch Linux ARM没有这个东西，它是按下面的方法设置的：
假设我要开机执行一句shell命令，把它写在文件 /etc/rc.local 中（在Arch Linux中，此文件一开始是不存在的）：
How to execute a shell script/a command on Pi startup?
For RedHat it's very easy, it has a /etc/rc.local file, we just add the commands to the file, while Arch Linux ARM doesn't have such thing, and I'm a beginner of Arch, so after asking Google for many times, I find a way to do that - suppose I need to execute a shell command, so I create the /etc/rc.local file & write the shell command to it:

#!/bin/bash
# this file defines the commands that will be executed at system startup

echo "abc" > /root/test.txt

为此文件赋予可执行权限：
Give the file the executable permission:

chmod +x /etc/rc.local

然后创建一个文件 /usr/lib/systemd/system/rc-local.service ，内容为：
Then create a file /usr/lib/systemd/system/rc-local.service , with the content of:

[Unit]

Description=/etc/rc.local Compatibility

ConditionPathExists=/etc/rc.local

 

[Service]

Type=forking

ExecStart=/etc/rc.local start

TimeoutSec=0

StandardOutput=tty

RemainAfterExit=yes

SysVStartPriority=99

 

[Install]

WantedBy=multi-user.target

文章来源：http://www.codelast.com/
创建一个软链接：
Create a symbol link:

cd /etc/systemd/system/multi-user.target.wants
ln -s /usr/lib/systemd/system/rc-local.service rc-local.service

启用服务：
Enable the service:

systemctl enable rc-local.service

重启系统，然后就可以开机执行你的shell命令了。如果要立即启用，则执行以下命令：
Restart Pi, then you'll be able to execute the shell command on OS startup. If you want to execute it without restarting Pi, just execute the following command:

systemctl start rc-local.service

这是使用systemd的启动方式，非常麻烦。
如果你只是简单地要设置一个命令的别名，可以把命令写在 /etc/profile 中，ssh登录Pi的时候就自动会执行。
This seems to be the so-called "systemd" way to start something, and I think the setup process is very tedious.
You can also add the shell command to /etc/profile, and it will be executed when you logging into Pi using ssh.

【3】安装软件 / Install packages
在Arch Linux上安装软件使用pacman很方便，它相当于Ubuntu中的apt-get。例如，要安装gcc，可以这样：
It's very convenient to use pacman to install something on Arch Linux, and it's the equivalent of apt-get on Ubuntu. For example, you can install gcc by typing:

pacman -S gcc

然后Arch Linux ARM会提示你要下载的软件包的情况，以及向你确认是否要进行安装。
在下载软件包的过程中，我的Pi一直提示下载不到某一个软件包的错误，重试无数遍都一样，于是我就只能尝试升级pacman以及系统了，执行：
Then Arch Linux will prompt you the info of the packages which will be downloaded/installed, and ask you to confirm the installation.
In the process of downloading a gcc related package, I met an URL not found error and I tried many times but solved nothing, so at last I tried to update pacman and the OS:

pacman -Syu

升级时间较长（大约小于10分钟），之后再安装gcc，就成功了。
This consumes a bit long time(but < 10 min, depends on your Internet connection speed), and after this I tried to install gcc again, it succeeded.
文章来源：http://www.codelast.com/
【4】配置静态IP地址 / Set up a static IP address
相比设置一个静态的IP地址，我更愿意采取另一种简单的办法来让Pi每次都得到一个固定的IP地址，即：在路由器里为Pi所对应的Mac地址保留一个固定的IP地址。
由于我对Pi所接入的网络的路由器有完全的控制权，所以我可以这样做。由于每种路由器的管理界面是不相同的，所以在此我就不把路由器管理界面的图贴上来了，大家自己看看你路由器的说明书就会弄了。
Comparing to setting up a static IP for Pi, I would like more to take another simple way to let Pi get a fixed IP everytime it accesses to the same network, that is, let the router to allocate(reserve) a fixed IP for Pi's Mac address.
This can be done only because I have full control over the router which Pi accesses. Because different routers have different admin interfaces, so I post no sample images here and you can check the instruction book of your router to figure out how to set it.

【5】设置系统时区 & 时间 / System timezone & time setup
以上海为例，先编辑文件 /etc/rc.conf，添加上如下内容：
Use Shanghai as an example, first we should edit file /etc/rc.conf and add the following content:

LOCALE="en_US.UTF-8"

DAEMON_LOCALE="no"

HARDWARECLOCK="localtime"

TIMEZONE="Asia/Shanghai"

然后做软链接：
Then make a symbolic link:

ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

/etc/localtime 原来是指向 /usr/share/zoneinfo/Europe/London，在做这外软链接之后，就指向了 /usr/share/zoneinfo/Asia/Shanghai。
The /etc/localtime was initially pointed to /usr/share/zoneinfo/Europe/London and after we made a new link, it will points to /usr/share/zoneinfo/Asia/Shanghai.
文章来源：http://www.codelast.com/
这样就算设置好了时区了。下面该设置系统时间了。由于树莓派没有实时时钟，因此，最好利用网络来对时，所以使用OpenNTPD是个非常好的选择。
So the timezone setup is done. Then we should setup the system time. Because Pi doesn't has a real-time clock built in, we better use the network to synchronize the system time, so using the OpenNTPD is a good choice.
我系统中安装的OpenNTPD（我不记得是系统自带的还是我安装的了）：
The OpenNTPD in my Arch Linux ARM(I forget whether it's installed by me or not):

[root@alarmpi ~]# pacman -Q | grep ntp
openntpd 3.9p1-19

确保 /etc/rc.conf 中有OpenNTPD的启动项：
Make sure that the OpenNTPD is in the auto startup list in /etc/rc.conf :

DAEMONS=(syslog-ng network netfs crond openntpd sshd)

然后重启系统，会发现时间自动同步正确了。
Then reboot the system and you'll find that the time is correct.
如果你发现时间无法同步，那么请执行一下ntpd命令，该命令会加载ntpd配置文件 /etc/ntpd.conf，如果配置文件内容有错，它会提示出来。就算配置文件是正确的，有其他错误也会打印出来。
例如，我升级了如下版本的系统：
If you find that the time cannot be synchronized, then you should execute the ntpd command to see what the problem is. The ntpd command will load configuration file /etc/ntpd.conf and if there is any problem in it, the command will tell you. Even the content of the conf file is correct, the ntpd command will print other error messages out.
E.g. I upgraded my OS to following version:

[root@alarmpi ~]# cat /proc/version 
Linux version 3.2.27-14-ARCH+ (nobody@nitrogen) (gcc version 4.7.2 (GCC) ) #1 PREEMPT Tue Nov 20 23:58:09 UTC 2012

然后就遇到了无法同步时间的问题。执行ntpd命令会提示“ntpd: unknown user ntp”。网上Google了一堆文章，找到最后唯一一个可行的解决办法就是：为系统添加一个“ntp”用户：
Then I couldn't synchronized the time. When executing ntpd command it prompted "ntpd: unknown user ntp". After Googling a lot of solutions I found the only one which can solve the problem, that is, add a "ntp" user for the OS:

useradd ntp

然后查看 /etc/passwd 文件，会看到已经添加了该用户。
Then check /etc/passwd to make sure the user has been added.
为安全，编辑 /etc/passwd 文件，将此用户设置为无法ssh登录系统：
For security reason, edit /etc/passwd to forbid the user to login the OS:

ntp:x:1000:1000::/home/ntp:/sbin/nologin

文章来源：http://www.codelast.com/
另外，你也可以用ntpdate（现在已经被官方弃用了）来对时，但首先你必须安装ntp包：
You can also use ntpdate(which is now deprecated) to sync the time, but you have to install package ntp first:

pacman -S ntp

然后，找一个可用的时间服务器来同步时间：
And then find an available time server to sync the time:

ntpdate  time.buptnet.edu.cn

【6】配置Emacs编辑C++代码的自动补全功能 / Configure the auto-complete for editing C++ source in Emacs
如果要在树莓派上用Emacs开发C++程序，那么配置好代码自动补全/自动完成功能大有帮助。
If you want to use Emacs to write C++ code on Pi, then the auto-completion should be a big help to you.
CEDET实现了该功能，用的人也比较多，不过，由于树莓派的性能较低，并且CEDET很慢（很多文章都这么说，我没试），所以就不要考虑在树莓派上用这玩意了。
Many people use CEDET to do the auto-completion job, but because of the low performance of Pi, and the CEDET is very slow(many articles said that, but I didn't try it), so just choose something else but not CEDET on Pi.
文章来源：http://www.codelast.com/
那么应该选择什么Emacs插件来实现呢？auto-complete-clang是一个很好的选择。
So what Emacs plugin we should use? the auto-complete-clang is a good choice.
下面，就介绍一下如何配置该插件，让自动完成功能在Emacs中用起来。
Then I'll tell you how to configure the plugin to get the auto-completion work.
为了安装auto-complete-clang，你需要先安装两个东西：auto-complete 和 clang。
Before installing auto-complete-clang, you must install another two software first:auto-complete and clang.
①安装auto-complete / Install auto-complete
首先你要下载auto-complete的源码包，解压之后编译，安装（安装的过程中会询问你安装到哪个目录）：
Download the source package, unpack it, compile it & install it(you'll be asked to type an installation directory in the process):

make
make install
Install to: /root/.emacs.d/auto-complete

注意，我把它安装到了一个自己创建的目录下，后面要用到这个目录里的文件。
Note that I installed it to a directory created by me and we'll use the directory later.
在Emacs配置文件.emacs中添加如下四行：
Add the following 4 lines in the Emacs configuration file .emacs:

(add-to-list 'load-path "/root/.emacs.d/auto-complete")

(require 'auto-complete-config)

(add-to-list 'ac-dictionary-directories "/root/.emacs.d/auto-complete/ac-dict")

(ac-config-default)

上面的路径就是和刚才的安装路径，如果你和我安装的路径不一样，请把它改成你自己的路径。
The paths above are just the installation directory, if yours are different from mine, change them.
文章来源：http://www.codelast.com/
②安装clang / Install clang
用pacman安装clang是最方便的：
Using pacman to install clang is the most convenient way:

pacman -S clang

如果你不幸遇到了下面的错误：
If you get the following errors unfortunately:

error: failed retrieving file 'llvm-3.1-4-armv6h.pkg.tar.xz' from mirror.archlinuxarm.org : The requested URL returned error: 404

warning: failed to retrieve some files from extra

error: failed retrieving file 'clang-3.1-4-armv6h.pkg.tar.xz' from mirror.archlinuxarm.org : The requested URL returned error: 404

warning: failed to retrieve some files from extra

error: failed to commit transaction (download library error)

pacman -Syu

然后再用pacman安装clang，应该就没有上面的问题了。
Then install clang again, and the errors should not occur.
③安装auto-complete-clang / Install auto-complete-clang
其实这一步所谓的安装，不过是下载+配置，并没有像上面一样的编译过程。
Actually the so-called installation in this step is just a process of downloading & configuration, there is no compilation as previous steps.
下载配置文件auto-complete-clang.el，我把它放到了 .emacs.d/auto-complete-clang 目录下。
Download the configuration file auto-complete-clang.el and I put it to directory .emacs.d/auto-complete-clang .
在.emacs中添加下面一句：
Add the following line in Emacs configuration file .emacs:

(add-to-list 'load-path "~/.emacs.d/auto-complete-clang")

该目录就是你放置 auto-complete-clang.el 文件的目录。
The directory is just where you put file auto-complete-clang.el into.
然后再继续添加如下内容（从网上抄来的）：
Then continue to add following content(I got this from the Internet):

(require 'auto-complete-clang)

(setq ac-auto-start t)

(setq ac-quick-help-delay 0.5)

;; (ac-set-trigger-key "TAB")

;; (define-key ac-mode-map  [(control tab)] 'auto-complete)

(define-key ac-mode-map  [(control tab)] 'auto-complete)

(defun my-ac-config ()

  (setq ac-clang-flags

        (mapcar(lambda (item)(concat "-I" item))

               (split-string

                "

 /usr/lib/gcc/armv6l-unknown-linux-gnueabihf/4.7.2/../../../../include/c++/4.7.2

 /usr/lib/gcc/armv6l-unknown-linux-gnueabihf/4.7.2/../../../../include/c++/4.7.2/armv6l-unknown-linux-gnueabihf

 /usr/lib/gcc/armv6l-unknown-linux-gnueabihf/4.7.2/../../../../include/c++/4.7.2/backward

 /usr/lib/gcc/armv6l-unknown-linux-gnueabihf/4.7.2/include

 /usr/local/include

 /usr/lib/gcc/armv6l-unknown-linux-gnueabihf/4.7.2/include-fixed

 /usr/include

")))

  (setq-default ac-sources '(ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers))

  (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup)

  ;; (add-hook 'c-mode-common-hook 'ac-cc-mode-setup)

  (add-hook 'ruby-mode-hook 'ac-ruby-mode-setup)

  (add-hook 'css-mode-hook 'ac-css-mode-setup)

  (add-hook 'auto-complete-mode-hook 'ac-common-setup)

  (global-auto-complete-mode t))

(defun my-ac-cc-mode-setup ()

  (setq ac-sources (append '(ac-source-clang ac-source-yasnippet) ac-sources)))

(add-hook 'c-mode-common-hook 'my-ac-cc-mode-setup)

;; ac-source-gtags

(my-ac-config)

echo "" | g++ -v -x c++ -E -

文章来源：http://www.codelast.com/
【7】设置终端文字颜色 / Setup the terminal text color
Arch Linux ARM默认情况下终端文字是黑白的，对于文件和目录类型不方便区分，为提高工作效率，需要其显示不同颜色。
By default the Arch Linux ARM terminal text colors are just black and white and it's not convenient to identify directories & files. So in order to improve the work efficiency we should setup the text color.
修改 /etc/profile，在最后添加一行：
Edit /etc/profile and add the following line:

alias ls="ls --color=auto"

这样，ls命令显示出来的文字就有不同颜色了。
Then the "ls" command will display the colorful text.

【8】Arch Linux ARM的rontab文件在哪里 / Where the crontab file is
使用 crontab -e 命令可以编辑当前用户的crontab配置文件，但这个文件是位于何处？我更喜欢直接编辑它，因为我可以用我习惯的Emacs来操作。它是在 /var/spool/cron/ 目录下，用户名即为文件名，例如，root用户的 crontab -e 命令编辑的就是 /var/spool/cron/root 文件。
We can use command crontab -e to edit the crontab configuration file of current user, so where the corresponding file is? I like more to edit the file directly, because I can use my favourite editor Emacs to edit it. The crontab file is under the directory /var/spool/cron/ , and with the same name as the Linux user, for example, the command crontab -e ran by root user will edit the file /var/spool/cron/root .

【9】安装dig，nslookup程序 / Install command dig & nslookup
dig和nslookup程序包含在dnsutils包中，所以这样安装：
dig & nslookup are contained in package dnsutils, so you can install them by:

pacman -S dnsutils

如果你用 pacman -S dig 或 pacman -S nslookup 来找，是找死也找不到的。
If you use pacman -S dig or pacmsn -S nslookup to install them, you'll never get what you want.
文章来源：http://www.codelast.com/
【10】备份SD卡上的系统 / Backup the OS on SD card
万一SD卡损坏，你辛辛苦苦配置了很久的系统就没了，所以必须要备份。直接拷贝SD卡里的数据到另一张SD卡上是行不通的，可以通过Linux的dd命令来复制SD卡，非常方便。
If the SD card broken, you'll lose the OS that you've spent weeks on it, so it's very necessary to backup it. It's impossible to backup the OS by simply copying the SD card files to another card, you can do this by Linux command dd.
（A）查看SD卡的设备名 / Check the device name of the SD card

[codelast@ ~]$ dmesg | tail
[487324.668042] sd 7:0:0:0: [sdb] Mode Sense: 03 00 00 00
[487324.668916] sd 7:0:0:0: [sdb] No Caching mode page present
[487324.668922] sd 7:0:0:0: [sdb] Assuming drive cache: write through
[487324.672481] sd 7:0:0:0: [sdb] No Caching mode page present
[487324.672487] sd 7:0:0:0: [sdb] Assuming drive cache: write through
[487324.674866]  sdb: sdb1 sdb2 sdb3
[487324.679206] sd 7:0:0:0: [sdb] No Caching mode page present
[487324.679213] sd 7:0:0:0: [sdb] Assuming drive cache: write through
[487324.679218] sd 7:0:0:0: [sdb] Attached SCSI removable disk
[487325.617680] pool[9188]: segfault at 0 ip 000000000042e62d sp 00007f88ff2c4520 error 4 in udisksd[400000+45000]

可见我的SD卡设备名是sdb。
You can see that my SD card device name is sdb.
（B）备份SD卡上的OS到一个磁盘文件里 / Backup the OS on SD card to a disk file

[codelast@ ~]$ sudo dd if=/dev/sdb of=~/raspberry_pi_os_backup
31537152+0 records in
31537152+0 records out
16147021824 bytes (16 GB) copied, 942.766 s, 17.1 MB/s

在这里，/dev/sdb是我的SD卡，OS被备份到了~/raspberry_pi_os_backup文件中。整个过程花了约15分钟完成（16G的SD卡）。
So /dev/sdb is my SD card and the OS was backuped to file ~/raspberry_pi_os_backup. The whole process took me about 15 minutes(16GB SD card).
文章来源：http://www.codelast.com/
（C）将格式化新的SD卡为ext4 / Format the new SD card to ext4
由于我原来的SD卡是ext4格式，所以我利用Ubuntu的磁盘管理工具将新的SD卡也格式化成了ext4格式。至于这一步是否有必要，我没有试验，但是可以肯定的是：这样做一定能成功。
Because my old SD card has a format of ext4, so I used the Ubuntu disk management tool to format the new SD card to ext4, too. I'm not sure whether this step is a must, but I'm sure that it's no problem to do this and can lead you to success.
（D）将备份的磁盘文件恢复到新的SD卡上 / Restore the disk file to the new SD card
拔下旧的SD卡，插上新的SD卡，用 dmesg | tail 命令查看一下，新的SD卡的设备名仍然是sdb，因此恢复OS的命令为：
Unplug the old SD card, plug the new SD card into your computer, and use dmesg | tail command to check the device name(it's still sdb), so the command to restore the OS is:

[codelast@ ~]$ sudo dd if=~/raspberry_pi_os_backup of=/dev/sdb
31537152+0 records in
31537152+0 records out
16147021824 bytes (16 GB) copied, 5459.12 s, 3.0 MB/s

这个操作时间更长，耐心等待完成即可。
This process takes even more time, just be patient and wait it to finish.
文章来源：http://www.codelast.com/
【11】用pacman -Syu升级系统时提示“error: failed to commit transaction (conflicting files)”的解决办法 / How to fix the "error: failed to commit transaction (conflicting files)" problem when using [pacman -Syu] to upgrade your OS
我在用pacman -Syu升级系统时，提示如下错误：
When I used "pacman -Syu" to upgrade my OS, I got these error messages:

error: failed to commit transaction (conflicting files)

filesystem: /bin exists in filesystem

filesystem: /sbin exists in filesystem

filesystem: /usr/sbin exists in filesystem

Errors occurred, no packages were upgraded.

这个问题可以通过依次执行以下几条命令来解决，经测试可用：
To solve the problem, you can execute following commands one by one and they worked for me:

pacman -R localepurge
pacman -Syu --ignore filesystem,bash
pacman -S bash
pacman -Su

文章来源：http://www.codelast.com/
【12】清空pacman安装包缓存
某天我用 pacman -Syu 升级OS的时候，提示空间不足，我当时觉得不可思议，因为我在SD卡上存储的东西并不多，于是我用 du -sh 把系统目录挨个看了一下，发现占用空间最大的是 /var/cache/pacman/pkg 这个目录，足足占了我3.5GB！从名字上看，它应该是用 pacman 安装软件时留下的缓存，应该是可以清掉的，于是Google了一下，找到答案：可以用下面的命令清除掉一些旧的缓存：

pacman -Sc

如果要清除全部缓存，则可以用下面的命令：

pacman -Scc

我使用的是前者，执行完后释放了2.8GB的空间，又可以愉快地玩耍了。
文章来源：http://www.codelast.com/
【13】创建用户 & 免密码切换到root
新装好的系统创建用户：

useradd -m codelast

这就创建了一个codelast用户。-m表示在 /home/ 目录下创建一个 codelast 目录，如果不加此参加则不创建。
之后紧接着就修改codelast用户的密码：

passwd codelast

再之后，为这个用户设置免密码切换到root的权限：

visudo

这会自动用一个编辑器打开 /etc/sudoers 文件（注意不能用其他的编辑器来编辑此文件，但这个默认的编辑器太难用了）。
在文件中加上这一句：

codelast ALL=(ALL) NOPASSWD: ALL

codelast ALL=(ALL) NOPASSWD: ALL

表示允许codelast用户免密码执行任何命令。无需重启，保存文件之后用 codelast 用户试一下：

sudo su -

应该就能免密码切换到root了

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

要使用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 
感谢关注我的微信公众号（微信扫一扫）：

注：这是本人的翻译，可能不准确，可能有错误，但是基本上可以理解，希望能对大家有所帮助！（转载须注明出处：本文来自learnhard的博客：http://www.codelast.com/& http://blog.csdn.net/learnhard/）

·         Streaming Multiple Messages

·         Large Data Sets

·         Union Types

·         Self-describing Messages

This page describes some commonly-used design patterns for dealing with Protocol Buffers. You can also send design and usage questions to the Protocol Buffers discussion group.
文章来源：http://www.codelast.com/

l  将多个消息转化为流

l  大数据集

l  联合类型

l  自描述的消息

本文描述了处理Protocol Buffers的时候一些常用的设计模式。你也可以向Protocol Buffers讨论组（Protocol Buffers discussion group）发送设计和使用方面的问题寻求解答。

If you want to write multiple messages to a single file or stream, it is up to you to keep track of where one message ends and the next begins. The Protocol Buffer wire format is not self-delimiting, so protocol buffer parsers cannot determine where a message ends on their own. The easiest way to solve this problem is to write the size of each message before you write the message itself. When you read the messages back in, you read the size, then read the bytes into a separate buffer, then parse from that buffer. (If you want to avoid copying bytes to a separate buffer, check out the CodedInputStream class (in both C++ and Java) which can be told to limit reads to a certain number of bytes.)

如果你想将多个消息写入一个文件或流（stream）中，那么是由你来记录一个消息的终点以及另一个消息的起点的。Protocol Buffer数据传输格式不是自我限定的（self-delimiting），所以protocol buffer解析器无法自己决定一个消息结束于何处。解决这个问题的最简单的方法就是：在写入每一个消息之前，先写入消息的大小。当你读取消息的时候，先读取消息大小，然后将指定的字节数读入一个独立的缓冲区中，然后再解析缓冲区里的东西。如果你不想将数据拷贝到一个独立的缓冲区中，请查看CodedInputStream类（C++和Java都可用）的使用方法——你可以用它来限制只读取指定字节的数据。

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

Protocol Buffers are not designed to handle large messages. As a general rule of thumb, if you are dealing in messages larger than a megabyte each, it may be time to consider an alternate strategy.

Protocol Buffers不是设计来处理大消息的。根据一般经验，如果你要处理的单条消息大于1M，那就是采取其他策略的时候了。

That said, Protocol Buffers are great for handling individual messages within a large data set. Usually, large data sets are really just a collection of small pieces, where each small piece may be a structured piece of data. Even though Protocol Buffers cannot handle the entire set at once, using Protocol Buffers to encode each piece greatly simplifies your problem: now all you need is to handle a set of byte strings rather than a set of structures.

也就是说，Protocol Buffers非常适合于处理一个大数据集内有多个单独的消息。通常，大数据集只是许多小块数据的集合，每一小块都是一块结构化的数据。即使是这样，Protocol Buffers也不能马上处理整个数据集，使用Protocol Buffers来编码每一块数据可以极大地简化你的问题：现在你所需要的只是处理一组字符串，而不是一组结构体了。

Protocol Buffers do not include any built-in support for large data sets because different situations call for different solutions. Sometimes a simple list of records will do while other times you may want something more like a database. Each solution should be developed as a separate library, so that only those who need it need to pay the costs.

Protocol Buffers没有内置任何对大数据集的支持，因为不同的情况需要不同的解决方案。

有时，一个简单的记录列表就解决问题了，而在某些情况下，你可能更想要的是类似于数据库的东西。每个解决方案都应该作为一个独立的库来开发，所以只有需要它的人才需要付出代价。

You may sometimes want to send a message that could be one of several different types. However, protocol buffer parsers cannot necessarily determine the type of a message based on the contents alone. So how do you make sure that the recipient application knows how to decode your message? One solution is to create a wrapper message that has one optional field for each possible message type.

有时，你可能想发送一个消息，它的类型可以是几种不同的类型之一。然而，protocol buffer解析器无法仅凭消息内容来决定消息的类型。所以，你如何确保接收方应用程序能知道怎么解析消息呢？有一个解决方案是：创建一个封装的消息，其含有N个optional的字段，每一个字段对应一种可能的消息类型。

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

For example, if you have message types Foo, Bar, and Baz, you can combine them with a type like:

例如，如果你有消息类型Foo，Bar和Baz，那么你可以将它们与类型结合起来，像这样：

You may also want to have an enum field that identifies which message is filled in, so that you can switch on it:

你也可能想这样做：添加一个枚举字段来标识是哪个消息被填充了，这样的话你就可以对它使用switch（来进行不同的处理）：

If you have a very large number of possible types, listing every one of them in your container type may be unwieldy. Instead, you should consider using extensions:

如果你有大量“可能的类型”，那么在你的容器类型中将它们一一列举出来可能非常困难。在这种情况下，你应该考虑使用扩展（extensions）：

Note that you can use the ListFields reflection method (in C++, Java, and Python) to get a list of all fields present in the message, including extensions. You might use this as part of a scheme for registering handlers for diverse message types.

注意：你可以使用反射函数ListFields（C++，Java和Python都可用）来获取一个消息中的所有字段的列表（包括扩展）。在实现一个为不同消息类型分别注册句柄的技术方案的时候，你可能用得上这个功能。

Protocol Buffers do not contain descriptions of their own types. Thus, given only a raw message without the corresponding .proto file defining its type, it is difficult to extract any useful data.

However, note that the contents of a .proto file can itself be represented using protocol buffers. The file src/google/protobuf/descriptor.protoin the source code package defines the message types involved. protoc can output a FileDescriptorSet – which represents a set of .proto files – using the --descriptor_set_out option. With this, you could define a self-describing protocol message like so:

Protocol Buffers不包含自我类型描述的信息。因此，如果只提供原始消息，而不提供对应的.proto文件，你将很难从中提取出任何有用的数据。

然而，请注意：一个.proto文件的内容可以使用protocol buffers来描述。通过使用--descriptor_set_out选项，源代码包中的src/google/protobuf/descriptor.proto文件定义了相关的消息类型。protoc编译器可以输出一个FileDescriptorSet——这个集合表示一系列的.proto文件。利用它，你可以像这样定义一个自描述的协议消息：

By using classes like DynamicMessage (available in C++ and Java), you can then write tools which can manipulate SelfDescribingMessages.

All that said, the reason that this functionality is not included in the Protocol Buffer library is because we have never had a use for it inside Google.

通过使用像DynamicMessage这样的类（C++和Java都可用），你可以编写出操作SelfDescribingMessage的工具。

总之，Protocol Buffer库之所以没有包含这个特性，是因为我们在Google还从没有需要用它的机会。

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

注：这是本人的翻译，可能不准确，可能有错误，但是基本上可以理解，希望能对大家有所帮助！（转载须注明出处：本文来自learnhard的博客：http://www.codelast.com/ & http://blog.csdn.net/learnhard/）

·         Defining A Message Type

·         Scalar Value Types

·         Optional And Default Values

·         Enumerations

·         Using Other Message Types

·         Nested Types

·         Updating A Message Type

·         Extensions

·         Packages

·         Defining Services

·         Options

·         Generating Your Classes

This guide describes how to use the protocol buffer language to structure your protocol buffer data, including .proto file syntax and how to generate data access classes from your .proto files.

This is a reference guide – for a step by step example that uses many of the features described in this document, see the tutorial for your chosen language.

 l  定义一个消息（message）类型

l  标量值类型

l  可选的（optional）字段以及默认值

l  枚举

l  使用其他消息类型

l  嵌套类型

l  更新一个消息类型

l  扩展

l  包（package）

l  定义服务（service）

l  选项（option）

l  生成访问类

本指南描述了怎样使用protocol buffer语言来构造你的protocol buffer数据，包括.proto文件语法以及怎样生成.proto文件的数据访问类。

本文是一个参考指南——如果要查看如何使用本文中描述的多个特性的循序渐进的例子，请在tutorial中查找你需要的语言的教程。

First let's look at a very simple example. Let's say you want to define a search request message format, where each search request has a query string, the particular page of results you are interested in, and a number of results per page. Here's the .proto file you use to define the message type.

首先看一个非常简单的例子。假设你想定义一个“搜索请求”（search request）的消息格式，每一个搜索请求含有一个查询字符串、你感兴趣的查询结果所在的页数，以及每一页多少条查询结果。那么下面这个就是用来定义消息类型的.proto文件了：

The SearchRequest message definition specifies three fields (name/value pairs), one for each piece of data that you want to include in this type of message. Each field has a name and a type.

SearchRequest消息类型指定了3个字段（名/值 对），你想在消息中承载的数据分别对应于每一个字段。每个字段都有一个名字（name）和一个类型（type）。

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

Specifying Field Types 指定字段类型

In the above example, all the fields are scalar types: two integers (page_number and result_per_page) and a string (query). However, you can also specify composite types for your fields, including enumerations and other message types.

在上面的例子中，所有字段都是标量类型（scalar types）:两个整型（page_number和result_per_page），一个string（query）。然而，你也可以为字段指定合成的类型，包括枚举（enumerations）以及其他消息类型。

Assigning Tags 分配标识号

As you can see, each field in the message definition has a unique numbered tag. These tags are used to identify your fields in the message binary format, and should not be changed once your message type is in use. Note that tags with values in the range 1 through 15 take one byte to encode. Tags in the range 16 through 2047 take two bytes. So you should reserve the tags 1 through 15 for very frequently occurring message elements. Remember to leave some room for frequently occurring elements that might be added in the future.

The smallest tag number you can specify is 1, and the largest is 2²⁹ - 1, or 536,870,911. You also cannot use the numbers 19000 though 19999 (FieldDescriptor::kFirstReservedNumber through FieldDescriptor::kLastReservedNumber), as they are reserved for the Protocol Buffers implementation - the protocol buffer compiler will complain if you use one of these reserved numbers in your .proto.

如你所见，在消息定义中，每一个字段都有一个独一无二的标识号（unique numbered tag）。这些标识号是用来在消息二进制格式（message binary format）中识别你的字段的。注意：[1,15]之内的标识号在编码的时候会占用一个字节。[16,2047]之内的标识号则占用2个字节。所以你应该为那些频繁出现的消息元素保留[1,15]之内的标识号。切记：要为将来有可能添加的、频繁出现的标识号预留一些标识号。

Specifying Field Rules 指定字段规则

You specify that message fields are one of the following:

·         required: a well-formed message must have exactly one of this field.

·         optional: a well-formed message can have zero or one of this field (but not more than one).

·         repeated: this field can be repeated any number of times (including zero) in a well-formed message. The order of the repeated values will be preserved.

你所指定的消息字段必须是如下之一：

l  required：一个格式良好的消息一定要含有1个这种字段。

l  optional：一个格式良好的消息可以有0个或1个这种字段（但不超过1个）。

l  repeated：在一个格式良好的消息中，这种字段可以重复任意多次（包括0次）。重复的值的顺序会被保留。

（译者注：这一段内容我不太理解，因为Google提供的.proto示例文件并没有按这个说法来编写…）

 For historical reasons, repeated fields of basic numeric types aren't encoded as efficiently as they could be. New code should use the special option [packed=true] to get a more efficient encoding. For example:

由于历史原因，基本数值类型的repeated的字段并没有被尽可能地高效编码。在新的代码（译者注：这里是指.proto文件的内容）中，用户应该使用特殊选项[packed=true]来保证更高效的编码。例如：

required是永久性的：在把一个字段标识为required的时候，你应该特别小心。如果在某些情况下你不想写入或者发送一个required的字段，那么将该字段更改为optional可能会遇到问题——旧版本的读者（译者注：即读取、解析消息的一方）会认为不含该字段的消息（message）是不完整的，从而有可能会拒绝解析。在这种情况下，你应该考虑编写特别针对于应用程序的、自定义的消息校验函数。Google的一些工程师得出了一个结论：使用required弊多于利；他们更愿意使用optional和repeated而不是required。当然，这个观点并不具有普遍性。

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

 Adding More Message Types 添加更多消息类型

Multiple message types can be defined in a single .proto file. This is useful if you are defining multiple related messages – so, for example, if you wanted to define the reply message format that corresponds to your SearchResponse message type, you could add it to the same .proto:

在一个.proto文件中可以定义多个消息类型。在定义多个相关的消息的时候，这一点特别有用——例如，如果你想定义与你的SearchResponse消息类型对应的回复消息格式的话，你可以将它添加到相同的.proto文件中：

Adding Comments 添加注释

To add comments to your .proto files, use C/C++-style // syntax.

向.proto文件添加注释，可以使用C/C++风格的双斜杠（//） 语法格式。

What's Generated From Your .proto? 从你的.proto文件生成了什么？

When you run the protocol buffer compiler on a .proto, the compiler generates the code in your chosen language you'll need to work with the message types you've described in the file, including getting and setting field values, serializing your messages to an output stream, and parsing your messages from an input stream.

当你对.proto文件运行protocol buffer编译器（protocol buffer compiler）的时候，编译器生成你所选择的语言的代码，这些代码可以操作你在.proto文件中定义的消息类型，包括获取、设置字段值，将你的消息序列化到一个输出流中，以及从一个输入流中解析你的消息。

For C++, the compiler generates a .h and .cc file from each .proto, with a class for each message type described in your file.

For Java, the compiler generates a .java file with a class for each message type, as well as a special Builder classes for creating message class instances.

对C++来说，编译器为每一个.proto文件生成了一个.h文件和一个.cc文件，.proto文件中的每一个消息有一个对应的类。

对Java来说，编译器为每一个消息类型生成了一个.java文件，以及一个特殊的Builder类（这个类是用来创建消息类接口的）。

Python is a little different – the Python compiler generates a module with a static descriptor of each message type in your .proto, which is then used with a metaclass to create the necessary Python data access class at runtime.

You can find out more about using the APIs for each language by following the tutorial for your chosen language. For even more API details, see the relevant API reference.

对Python来说，有点不一样——Python编译器为.proto文件中的每个消息类型生成一个模型，其含有一个静态描述符（static descriptor，译者注：没用过Python，不清楚这样翻译正确与否），该模型与一个元类（metaclass）在运行时（runtime）被用来创建必需的Python数据访问类。

你可以从每种语言的教程中找到更多使用使用API的方法。如欲查看更详细的API信息，请阅相关的文章API reference。 

A scalar message field can have one of the following types – the table shows the type specified in the .proto file, and the corresponding type in the automatically generated class:

一个标量消息字段可以含有一个如下的类型——该表格展示了定义于.proto文件中的类型，以及与之对应的、在自动生成的访问类中定义的类型：

You can find out more about how these types are encoded when you serialize your message in Protocol Buffer Encoding.

^[1] In Java, unsigned 32-bit and 64-bit integers are represented using their signed counterparts, with the top bit simply being stored in the sign bit.

你可以在文章Protocol Buffer Encoding中，找到更多“序列化消息时各种类型如何编码”的信息。

^[1]在Java中，无符号32位和64位整型以它们对应的有符号类型来表示。

As mentioned above, elements in a message description can be labeled optional. A well-formed message may or may not contain an optional element. When a message is parsed, if it does not contain an optional element, the corresponding field in the parsed object is set to the default value for that field. The default value can be specified as part of the message description. For example, let's say you want to provide a default value of 10 for a SearchRequest's result_per_page value.

如上所述，消息描述中的一个元素可以被标记为“可选的”（optional）。一个格式良好的消息可以包含一个optional的元素，也可以不包含。当解析一个消息的时候，如果它不包含optional的元素，那么解析出来的对象中的对应字段就被置为默认值。默认值可以在消息描述文件中指定。例如，要为SearchRequest消息的result_per_page字段指定默认值10，可以这样做：

If the default value is not specified for an optional element, a type-specific default value is used instead: for strings, the default value is the empty string. For bools, the default value is false. For numeric types, the default value is zero. For enums, the default value is the first value listed in the enum's type definition.

如果没有为optional的元素指定默认值，那么就会使用与特定类型相关的默认值：对string来说，默认值是空字符串。对bool来说，默认值是false。对数值类型来说，默认值是0。对枚举来说，默认值是枚举类型定义中的第一个值。

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

When you're defining a message type, you might want one of its fields to only have one of a pre-defined list of values. For example, let's say you want to add a corpus field for each SearchRequest, where the corpus can be UNIVERSAL, WEB, IMAGES, LOCAL, NEWS, PRODUCTS or VIDEO. You can do this very simply by adding an enum to your message definition - a field with an enum type can only have one of a specified set of constants as its value (if you try to provide a different value, the parser will treat it like an unknown field). In the following example we've added an enum called Corpuswith all the possible values, and a field of type Corpus:

当你定义一个消息类型的时候，你可能想为一个字段指定某“预定义值序列”（pre-defined list of values）中的一个值。例如，假设你想为每一个SearchRequest消息添加一个corpus字段，而corpus的值可能是UNIVERSAL，WEB，IMAGES，LOCAL，NEWS，PRODUCTS或VIDEO中的一个。你可以很容易地实现这一点：通过向你的消息定义中添加一个枚举（enum）就可以了。一个enum类型的字段只能用指定的常量集（specified set of constants）中的一个值作为其值（如果你尝试指定不同的值，解析器就会把它当作一个未知的字段来对待）。在下面的例子中，我们已经添加了一个叫做Corpus的枚举（enum）——它含有所有可能的值——以及一个类型为Corpus的字段：

Enumerator constants must be in the range of a 32-bit integer. Since enum values use varint encoding on the wire, negative values are inefficient and thus not recommended. You can define enums within a message definition, as in the above example, or outside – these enums can be reused in any message definition in your .proto file. You can also use an enum type declared in one message as the type of a field in a different message, using the syntax MessageType.EnumType.

When you run the protocol buffer compiler on a .proto that uses an enum, the generated code will have a corresponding enum for Java or C++, or a special EnumDescriptor class for Python that's used to create a set of symbolic constants with integer values in the runtime-generated class.

For more information about how to work with message enums in your applications, see the generated code guide for your chosen language.

枚举常量必须在32位整型值的范围内。因为enum值是使用可变编码方式的，对负数不够高效，因此不推荐在enum中使用负数。如上例所示，你可以在一个消息定义的内部或外部定义枚举——这些枚举可以在你的.proto文件中的任何消息定义里重用。你也可以在一个消息中声明一个枚举类型，而在另一个不同的消息中使用它——采用MessageType.EnumType的语法格式。

当你对一个使用了枚举的.proto文件运行protocol buffer编译器的时候，生成的代码中将有一个对应的enum（对Java或C++来说），或者一个特殊的EnumDescriptor类（对Python来说），它被用来在运行时生成的类中创建一系列的整型值符号常量（symbolic constants）。

关于如何在你的应用程序的消息中使用枚举的更多信息，请查看你所选择的语言的generated code guide。

You can use other message types as field types. For example, let's say you wanted to include Result messages in each SearchResponsemessage – to do this, you can define a Result message type in the same .proto and then specify a field of type Result in SearchResponse:

你可以将其他消息类型用作字段类型。例如，假设你想在每一个SearchResponse消息中包含Result消息，你可以这样做——在相同的.proto文件中定义一个Result消息类型，然后在SearchResponse消息中指定一个Result类型的字段：

Importing Definitions 导入定义

In the above example, the Result message type is defined in the same file as SearchResponse – what if the message type you want to use as a field type is already defined in another .proto file?

在上面的例子中，Result消息类型与SearchResponse是定义在同一文件中的——如果你要使用的消息类型已经在其他.proto文件中已经定义过了呢？

You can use definitions from other .proto files by importing them. To import another .proto's definitions, you add an import statement to the top of your file:

你可以通过导入（importing）其他.proto文件中的定义来使用它们。要导入其他.proto文件的定义，你需要在你的文件中添加一个导入声明：

The protocol compiler searches for imported files in a set of directories specified on the protocol compiler command line using the -I/--import_path flag. If no flag was given, it looks in the directory in which the compiler was invoked.

然后，protocol编译器就会在一系列目录中查找需要被导入的文件，这些目录通过protocol编译器的命令行参数-I/--import_path指定。如果不提供参数，编译器就在其调用目录下查找。

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

You can define and use message types inside other message types, as in the following example – here the Result message is defined inside the SearchResponse message:

你可以在其他消息类型中定义、使用消息类型，在下面的例子中，Result消息就定义在SearchResponse消息内：

If you want to reuse this message type outside its parent message type, you refer to it as Parent.Type:

如果你想在它的父消息类型的外部重用这个消息类型，你需要以Parent.Type的形式使用它：

You can nest messages as deeply as you like:

你可以将消息嵌套任意多层：

Groups 组

Note that this feature is deprecated and should not be used when creating new message types – use nested message types instead.

注意：这个特性已经被弃用了，在创建新的消息类型的时候，不应该再使用它——你应该使用嵌套消息类型来代替它。

Groups are another way to nest information in your message definitions. For example, another way to specify a SearchResponse containing a number of Results is as follows:

“组”是在你的消息定义中嵌套信息的另一种方法。例如，在SearchResponse中包含若干Result的另一种方法是 ：

A group simply combines a nested message type and a field into a single declaration. In your code, you can treat this message just as if it had aResult type field called result (the latter name is converted to lower-case so that it does not conflict with the former). Therefore, this example is exactly equivalent to the SearchResponse above, except that the message has a different wire format.

一个“组”只是简单地将一个嵌套消息类型和一个字段捆绑到一个单独的声明中。在你的代码中，你可以把它看成是含有一个Result类型、名叫result的字段的消息（后面的名字被转换成了小写，所以它不会与前面的冲突）。

因此，除了数据传输格式（wire format）不同之外，这个例子与上面的SearchResponse例子是完全等价的。 

If an existing message type no longer meets all your needs – for example, you'd like the message format to have an extra field – but you'd still like to use code created with the old format, don't worry! It's very simple to update message types without breaking any of your existing code. Just remember the following rules:

如果一个已有的消息无法再满足你的需求——例如，你想在消息中添加一个额外的字段——但是你同时还想让为旧版本写的代码仍然可用，不用怕！更新消息而不破坏已有代码是非常简单的。只要你记住下面的规则：

·         Don't change the numeric tags for any existing fields.

·         Any new fields that you add should be optional or repeated. This means that any messages serialized by code using your "old" message format can be parsed by your new generated code, as they won't be missing any required elements. You should set up sensible default values for these elements so that new code can properly interact with messages generated by old code. Similarly, messages created by your new code can be parsed by your old code: old binaries simply ignore the new field when parsing. However, the unknown fields are not discarded, and if the message is later serialized, the unknown fields are serialized along with it – so if the message is passed on to new code, the new fields are still available. Note that preservation of unknown fields is currently not available for Python.

·         Non-required fields can be removed, as long as the tag number is not used again in your updated message type (it may be better to rename the field instead, perhaps adding the prefix "OBSOLETE_", so that future users of your .proto can't accidentally reuse the number).

·         A non-required field can be converted to an extension and vice versa, as long as the type and number stay the same.

·         int32, uint32, int64, uint64, and bool are all compatible – this means you can change a field from one of these types to another without breaking forwards- or backwards-compatibility. If a number is parsed from the wire which doesn't fit in the corresponding type, you will get the same effect as if you had cast the number to that type in C++ (e.g. if a 64-bit number is read as an int32, it will be truncated to 32 bits).

·         sint32 and sint64 are compatible with each other but are not compatible with the other integer types.

·         string and bytes are compatible as long as the bytes are valid UTF-8.

·         Embedded messages are compatible with bytes if the bytes contain an encoded version of the message.

·         fixed32 is compatible with sfixed32, and fixed64 with sfixed64.

l   不要更改任何已有的字段的数值标识（tag）。

l   你添加的任何字段都必须是optional或repeated的。这就意味着任何使用你的“旧”消息格式的代码序列化的消息可以被你的新代码所解析，因为它们不会丢掉任何required的元素。你应该为这些元素设置合理的默认值（default values），这样新的代码就能够正确地与老代码生成的消息交互了。类似地，你的新代码创建的消息也能被你的老代码解析：老的二进制程序在解析的时候只是简单地将新字段忽略。然而，未知的字段是没有被抛弃的，此后，如果消息被序列化，未知的字段会随之一起被序列化——所以，如果消息传到了新代码那里，则新的字段仍然可用。注意：对Python来说，对未知字段的保留策略是无效的。

l   非required的字段可以移除——只要它们的标识号（tag number）在你的新消息类型中不再使用（更好的做法可能是重命名那个字段，例如在字段前添加“OBSOLETE_”前缀，那样的话，你的.proto文件的用户将来就不会无意中重新使用了那些不该使用的标识号）。

l   一个非required的字段可以转换为一个扩展（extension），反之亦然——只要它的类型和标识号保持不变。

l   int32, uint32, int64, uint64,和bool是全部兼容的，这意味着你可以将这些类型中的一个转换为另外一个，而不会破坏前向、后向的兼容性。如果解析出来的数字与对应的类型不相符，那么结果就像在C++中对它进行了强制类型转换一样（例如，如果把一个64位数字当作int32来读取，那么它就会被截断为32位的数字）。

l   sint32和sint64是互相兼容的，但是它们与其他整数类型不兼容。

l   string和bytes是兼容的——只要bytes是有效的UTF-8编码。

l   嵌套消息与bytes是兼容的——只要bytes包含该消息的一个编码过的版本。

l   fixed32与sfixed32是兼容的，fixed64与sfixed64是兼容的。

Extensions let you declare that a range of field numbers in a message are available for third-party extensions. Other people can then declare new fields for your message type with those numeric tags in their own .proto files without having to edit the original file. Let's look at an example:

通过扩展，你可以将一个范围内的字段标识号声明为可被第三方扩展所用。然后，其他人就可以在他们自己的.proto文件中为你的消息类型声明新的字段，而不必去编辑原始文件了。让我们看个例子：

This says that the range of field numbers [100, 199] in Foo is reserved for extensions. Other users can now add new fields to Foo in their own.proto files that import your .proto, using tags within your specified range – for example:

这个例子表明：在消息Foo中，范围[100,199]之内的字段标识号被保留为扩展用。现在，其他人就可以在他们自己的.proto文件中添加新字段到Foo里了，但是添加的字段标识号要在指定的范围内——例如：

This says that Foo now has an optional int32 field called bar.

When your user's Foo messages are encoded, the wire format is exactly the same as if the user defined the new field inside Foo. However, the way you access extension fields in your application code is slightly different to accessing regular fields – your generated data access code has special accessors for working with extensions. So, for example, here's how you set the value of bar in C++:

这个例子表明：消息Foo现在有一个名为bar的optional int32字段。

当用户的Foo消息被编码的时候，数据的传输格式与用户在Foo里定义新字段的效果是完全一样的。

然而，你在程序代码中访问扩展字段的方法与访问普通的字段稍有不同——你生成的数据访问代码为扩展准备了特殊的访问函数来访问它。例如，下面是你如何在C++中设置bar的值：

Similarly, the Foo class defines templated accessors HasExtension(), ClearExtension(), GetExtension(), MutableExtension(), andAddExtension(). All have semantics matching the corresponding generated accessors for a normal field. For more information about working with extensions, see the generated code reference for your chosen language.

Note that extensions can be of any field type, including message types.

类似地，Foo类也定义了模板函数HasExtension()，ClearExtension()，GetExtension()，MutableExtension()，以及AddExtension()。这些函数的语义都与对应的普通字段的访问函数相符。要查看更多使用扩展的信息，请参考相应语言的代码生成指南。

注意：扩展可以是任何字段类型，包括消息类型。

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

Nested Extensions 嵌套的扩展

You can declare extensions in the scope of another type:

你可以在另一个类型的范围内声明扩展：

In this case, the C++ code to access this extension is:

在此例中，访问此扩展的C++代码是：

In other words, the only effect is that bar is defined within the scope of Baz.

换句话说，唯一的效果就是bar被定义在Baz的范围内。

A common pattern is to define extensions inside the scope of the extension's field type – for example, here's an extension to Foo of type Baz, where the extension is defined as part of Baz:

一个通常的设计模式就是：在扩展的字段类型的范围内定义该扩展——例如，下面是一个Foo的扩展（该扩展是Baz类型的），其中，扩展被定义为了Baz的一部分：

（译者注：这样的定义形式确很容易引起混淆，请继续往下看，以帮助你消除这种混淆）

However, there is no requirement that an extension with a message type be defined inside that type. You can also do this:

然而，并没有强制要求一个消息类型的扩展一定要定义在那个消息中。你也可以这样做：

In fact, this syntax may be preferred to avoid confusion. As mentioned above, the nested syntax is often mistaken for subclassing by users who are not already familiar with extensions.

事实上，这种语法格式更能防止引起混淆。正如上面所提到的，嵌套的语法通常被错误地认为有子类化的关系——尤其是对那些还不熟悉扩展的用户来说。

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