如何用golang访问hbase

        hbase没有提供golang的原生API, 不过可以通过hbase提供的thrift服务间接进行hbase的操作, 所以我们编写的其实是一个thrift客户端. 本文主要分为3个部分: 1, 编译thrift工具; 2, 安装hbase; 3, 代码测试;

 

1) 编译thrift工具:

        我的编译环境是centos7, gcc版本是5.3.0;

        我用的thrift工具版本是0.13.0, 下载地址如下:

   https://mirrors.tuna.tsinghua.edu.cn/apache/thrift/0.13.0/thrift-0.13.0.tar.gz

        解压后进入目录, 编译命令如下:

   ./configure --prefix=/home/{$USER}/out --with-python=no
   make -j2
   make install

        现在可以看到目录 $HOME/out/bin 下已经有了可执行文件 thrift(类似于protoc)

        现在需要下载可以生成package的thrift文件(类似于proto文件, hbase的源码文件里已经提供了该文件), 下载hbase的源码文件既可, 地址如下: 

   https://mirrors.bfsu.edu.cn/apache/hbase/2.3.3/hbase-2.3.3-src.tar.gz

        假设解压后目录是: $HOME/hbase-2.3.3

        那么thrift文件的目录是: $HOME/hbase-2.3.3/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift

        现在把Hbase.thrift文件拷贝到 $HOME/out/bin 下, 再在 $HOME/out/bin 目录下执行如下命令:

   ./thrift --gen go ./Hbase.thrift

        可以看到 $HOME/out/bin目录下多了一个包: gen-go, 这个包就是我们间接操作hbase的包(实际直接连接的是hbase提供的thrift服务).

 

2) 安装hbase:

        第一步我们下载了hbase的源码文件, 这次安装的是hbase的可执行文件, 可以直接启动(需要java环境), 地址如下: 

   https://mirrors.bfsu.edu.cn/apache/hbase/2.3.3/hbase-2.3.3-bin.tar.gz

        下载后解压到 /usr/local/hbase目录, 分别启动hbase和thrift, 命令如下:

   cd /usr/local/hbase/bin/

   sh start-hbase.sh

   sh hbase-daemon.sh start thrift

 

3) 代码测试:

        整个目录结构如下图:

        

        其中, 包名为: mhbase

        文件hbae1.go 是我封装的hbase客户端, 代码如下:

package mhbase

import (
	"bytes"
	"log"

	"mhbase/gen-go/hbase"

	"github.com/apache/thrift/lib/go/thrift"
)

// Hbase1 Hbase1
type Hbase1 struct {
	Handler *hbase.HbaseClient
	Trans   thrift.TTransport
}

// NewMineHbase1 NewMineHbase1
func NewMineHbase1() (interface{}, error) {
	trans, err := thrift.NewTSocket(*addr)
	if err != nil {
		return nil, err
	}

	protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
	iprot := protocolFactory.GetProtocol(trans)
	oprot := protocolFactory.GetProtocol(trans)
	client := hbase.NewHbaseClient(thrift.NewTStandardClient(iprot, oprot))
	if err := trans.Open(); err != nil {
		return nil, err
	}

	return &Hbase1{Handler: client, Trans: trans}, nil
}

// Insert Insert
func (h1 *Hbase1) Insert(table, row hbase.Text, groupAndColumns map[string]map[string][]byte) error {
	var mutations []*hbase.Mutation
	for groupName, columnsMap := range groupAndColumns {
		for columnName := range columnsMap {
			name := groupName + ":" + columnName
			value := columnsMap[columnName]
			m := &hbase.Mutation{
				IsDelete:   false,
				Column:     []byte(name),
				Value:      value,
				WriteToWAL: false,
			}
			mutations = append(mutations, m)
		}
	}
	return h1.Handler.MutateRow(ctx, table, row, mutations, nil)
}

// Select Select
func (h1 *Hbase1) Select(table hbase.Text, rowsNums int32) (map[string]map[string]*hbase.TCell, error) {
	id, err := h1.Handler.ScannerOpenWithScan(ctx, table, nil, nil)
	if err != nil {
		return nil, err
	}

	results, err := h1.Handler.ScannerGetList(ctx, id, rowsNums)
	if err != nil {
		return nil, err
	}

	rows2ColumnsMap := make(map[string]map[string]*hbase.TCell)
	for _, val := range results {
		rows2ColumnsMap[string(val.GetRow())] = val.GetColumns()
	}

	h1.Handler.ScannerClose(ctx, id)
	return rows2ColumnsMap, nil
}

// CreateTable CreateTable
func (h1 *Hbase1) CreateTable(table hbase.Text) error {
	column1 := &hbase.ColumnDescriptor{
		Name:                  []byte("basic_info"),
		MaxVersions:           3,
		Compression:           "NONE",
		InMemory:              false,
		BloomFilterType:       "ROW",
		BloomFilterVectorSize: 0,
		BloomFilterNbHashes:   0,
		BlockCacheEnabled:     true,
		TimeToLive:            2147483647,
	}
	column2 := &hbase.ColumnDescriptor{
		Name:                  []byte("details"),
		MaxVersions:           3,
		Compression:           "NONE",
		InMemory:              false,
		BloomFilterType:       "ROW",
		BloomFilterVectorSize: 0,
		BloomFilterNbHashes:   0,
		BlockCacheEnabled:     true,
		TimeToLive:            2147483647,
	}

	var families []*hbase.ColumnDescriptor
	families = append(families, column1)
	families = append(families, column2)

	if err := h1.Handler.CreateTable(ctx, table, families); err != nil {
		return err
	}
	return nil
}

// IsTableExists IsTableExists
func (h1 *Hbase1) IsTableExists(table hbase.Text) bool {
	r, err := h1.Handler.GetTableNames(ctx)
	if err != nil {
		log.Fatal(err.Error())
	}

	for i := range r {
		if bytes.Compare(r[i], table) == 0 {
			return true
		}
	}
	return false
}

// Destroy Destroy
func Destroy(v interface{}) error {
	return v.(*Hbase1).Trans.Close()
}

// Ping Ping
func Ping(v interface{}) error {
	_, err := v.(*Hbase1).Handler.GetThriftServerType(ctx)
	return err
}

        文件start.go的功能主要是: 初始化, 创建表, 插入表, 搜索表, 代码如下:

package mhbase

import (
	"context"
	"flag"
	"fmt"
	"log"
	"time"

	"github.com/silenceper/pool"
)

var (
	addr           *string         = flag.String("addr", "127.0.0.1:9090", "IP:PORT")
	ctx            context.Context = nil
	userHbase1Pool pool.Pool       = nil // 短连接, 用连接池
)

func init() {
	flag.Parse()

	ctx = context.Background()

	poolConfig := &pool.Config{
		InitialCap:  int(1),
		MaxIdle:     int(1),
		MaxCap:      int(1),
		Factory:     NewMineHbase1,
		Close:       Destroy,
		Ping:        Ping,
		IdleTimeout: 30 * time.Second,
	}
	var err error = nil
	if userHbase1Pool, err = pool.NewChannelPool(poolConfig); err != nil {
		log.Fatal(err.Error())
	}
}

// Start Start
func Start() {
	// 获取句柄
	v, err := userHbase1Pool.Get()
	if err != nil {
		log.Fatal(err.Error())
	}

	// 如果不存在就创建
	handle := v.(*Hbase1)
	if isExist := handle.IsTableExists([]byte("mytable")); !isExist {
		fmt.Println("Table is not exist, create table.")
		if err = handle.CreateTable([]byte("mytable")); err != nil {
			log.Fatal(err.Error())
		}
	} else {
		fmt.Println("Table is exist")
	}
	// 放入池子
	userHbase1Pool.Put(v)

	Write2Hbase()
	ReadFromHbase()
}

func Write2Hbase() {
	for i := 0; i < 10; i++ {
		v, err := userHbase1Pool.Get()
		if err != nil {
			log.Fatal(err.Error())
		}
		handle := v.(*Hbase1)

		values := map[string](map[string][]byte){
			"basic_info": map[string][]byte{
				"device_id": []byte("deviceID0000001"),
			},
			"details": map[string][]byte{
				"message": []byte("{\"deviceID\":\"deviceID0000001\",\"deviceType\":\"android\"}"),
			},
		}
		if err = handle.Insert([]byte("mytable"), []byte(fmt.Sprint(time.Now().UnixNano())), values); err != nil {
			fmt.Println(err.Error())
		} else {
			fmt.Println("Insert into hbase success.")
		}

		userHbase1Pool.Put(v)
		time.Sleep(time.Second)
	}
}

func ReadFromHbase() {
	v, err := userHbase1Pool.Get()
	if err != nil {
		fmt.Println(err.Error())
		time.Sleep(time.Second)
		return
	}
	handle := v.(*Hbase1)

	rows2ColumnsMap, err := handle.Select([]byte("mytable"), 64)
	if err != nil {
		fmt.Println(err.Error())
		userHbase1Pool.Put(v)
		time.Sleep(time.Second)
		return

	}

	for rowKey, columns := range rows2ColumnsMap {
		for columnName, column := range columns {
			fmt.Println("rowKey is", rowKey, "columnName is", columnName, "value is", string(column.GetValue()))
		}
	}
	userHbase1Pool.Put(v)
}

        main.go就是函数入口, 只有一行代码, 用来调用 mhbase.Start()函数, 这里不再展示. 

        编译运行, 假如说报了这样的错: ..\gen-go\hbase\Hbase.go:1924:10: cannot use temp (type Text) as type string in assignment, 主要原因是把[]byte赋值给了string, 把相应的地方用string(temp)赋值即可.

        结果如下:

        

        同时, 我们可以用hbase的命令行看一下, 是否有表以及数据, 到目录 /usr/local/hbase/bin 执行如下命令:

   ./hbase shell

        上面的命令是进入hbase命令行, 进入命令行后接着执行如下命令, 看下是否有 mytable 这个表:

   list

        再执行scan命令搜索数据, 命令如下:

   scan 'mytable'

        整个流程结果如下:

 

结束:

        本文主要是编写了一个thrift客户端, 连接hbase提供的thrift服务, 以达到操作hbase的目的. 本人对hbase了解不深, 如果有同学发现了代码里的问题, 请多多指教. 同时, 如果有什么问题, 大家可以一起讨论.