go-hbase的Scan模型源码分析

git地址在这里：
https://github.com/Lazyshot/go-hbase

这是一个使用go操作hbase的行为。

分析scan行为

如何使用scan看下面这个例子，伪代码如下：

func scan(phone string, start time.Time, end time.Time) ([]Loc, error) {     ...     client := hbase.NewClient(zks, "/hbase")     client.SetLogLevel("DEBUG")     scan := client.Scan(table)     scan.StartRow = []byte(phone + strconv.Itoa(int(end.Unix())))     scan.StopRow = []byte(phone + strconv.Itoa(int(start.Unix())))     var locs []Loc     scan.Map(func(ret *hbase.ResultRow) {          var loc Loc          for _, v := range ret.Columns {               switch v.ColumnName {               case "lbs:phone":                    loc.Phone = v.Value.String()               case "lbs:lat":                    loc.Lat = v.Value.String()               ...               }          }          locs = append(locs, loc)     })     return locs, nil}

首先是NewClient， 返回的结构是hbase.Client, 这个结构代表的是与hbase服务端交互的客户端实体。

这里没有什么好看的，倒是有一点要注意，在NewClient的时候，里面的zkRootReginPath是写死的，就是说hbase在zk中的地址是固定的。当然这个也是默认的。

func NewClient(zkHosts []string, zkRoot string) *Client {     cl := &Client{          zkHosts:          zkHosts,          zkRoot:           zkRoot,          zkRootRegionPath: "/meta-region-server",          servers:               make(map[string]*connection),          cachedRegionLocations: make(map[string]map[string]*regionInfo),          prefetched:            make(map[string]bool),          maxRetries:            max_action_retries,     }     cl.initZk()     return cl}

下面是client.Scan

client.Scan

返回的是

func newScan(table []byte, client *Client) *Scan {     return &Scan{          client:       client,          table:        table,          nextStartRow: nil,          families:   make([][]byte, 0),          qualifiers: make([][][]byte, 0),          numCached: 100,          closed:    false,          timeRange: nil,     }}

scan结构：

type Scan struct {     client *Client     id    uint64     table []byte     StartRow []byte     StopRow  []byte     families   [][]byte     qualifiers [][][]byte     nextStartRow []byte     numCached int     closed    bool     //for filters     timeRange *TimeRange     location *regionInfo     server   *connection}

设置了开始位置，结束位置，就可以进行Map操作了。

func (s *Scan) Map(f func(*ResultRow)) {     for {          results := s.next()          if results == nil {               break          }          for _, v := range results {               f(v)               if s.closed {                    return               }          }     }}

这个map的参数是一个函数f，没有返回值。框架的行为就是一个大循环，不断调用s.next()，注意，这里s.next返回回来的result可能是由多条，然后把这个多条数据每条进行一次实际的函数调用。结束循环有两个方法，一个是next中再也取不到数据（数据已经取完了）。还有一个是s.closed呗设置为true。

s.next()

func (s *Scan) next() []*ResultRow {     startRow := s.nextStartRow     if startRow == nil {          startRow = s.StartRow     }     return s.getData(startRow)}

这里其实是把startRow不断往前推进，但是每次从startRow获取多少数据呢？需要看getData

getData

最核心的流程如下：

func (s *Scan) getData(nextStart []byte) []*ResultRow {     ...     server, location := s.getServerAndLocation(s.table, nextStart)     req := &proto.ScanRequest{          Region: &proto.RegionSpecifier{               Type:  proto.RegionSpecifier_REGION_NAME.Enum(),               Value: []byte(location.name),          },          NumberOfRows: pb.Uint32(uint32(s.numCached)),          Scan:         &proto.Scan{},     }    ...     cl := newCall(req)     server.call(cl)    ...     select {     case msg := <-cl.responseCh:          return s.processResponse(msg)     }}

这里看到有一个s.numCached， 我们猜测这个是用来指定一次call请求调用回多少条数据的。

看call函数

func newCall(request pb.Message) *call {     var responseBuffer pb.Message     var methodName string     switch request.(type) {     ...     case *proto.ScanRequest:          responseBuffer = &proto.ScanResponse{}          methodName = "Scan"     ...     }     return &call{          methodName:     methodName,          request:        request,          responseBuffer: responseBuffer,          responseCh:     make(chan pb.Message, 1),     }}

type call struct {     id             uint32     methodName     string     request        pb.Message     responseBuffer pb.Message     responseCh     chan pb.Message}

可以看出，这个call是一个有responseBuffer的实际调用者。

下面看server.Call

至于这里的server， 我们不看代码流程了，只需要知道最后他返回的是connection这么个结构

type connection struct {     connstr string     id   int     name string     socket net.Conn     in     *inputStream     calls  map[int]*call     callId *atomicCounter     isMaster bool}

创建是使用函数newConnection调用

func newConnection(connstr string, isMaster bool) (*connection, error) {     id := connectionIds.IncrAndGet()     log.Debug("Connecting to server[id=%d] [%s]", id, connstr)     socket, err := net.Dial("tcp", connstr)     if err != nil {          return nil, err     }     c := &connection{          connstr: connstr,          id:   id,          name: fmt.Sprintf("connection(%s) id: %d", connstr, id),          socket: socket,          in:     newInputStream(socket),          calls:  make(map[int]*call),          callId: newAtomicCounter(),          isMaster: isMaster,     }     err = c.init()     if err != nil {          return nil, err     }     log.Debug("Initiated connection [id=%d] [%s]", id, connstr)     return c, nil}

好，那么实际上就是调用connection.call(request *call)

func (c *connection) call(request *call) error {     id := c.callId.IncrAndGet()     rh := &proto.RequestHeader{          CallId:       pb.Uint32(uint32(id)),          MethodName:   pb.String(request.methodName),          RequestParam: pb.Bool(true),     }     request.setid(uint32(id))     bfrh := newOutputBuffer()     err := bfrh.WritePBMessage(rh)     ...     bfr := newOutputBuffer()     err = bfr.WritePBMessage(request.request)    ...     buf := newOutputBuffer()     buf.writeDelimitedBuffers(bfrh, bfr)     c.calls[id] = request     n, err := c.socket.Write(buf.Bytes())    ...}

逻辑就是先把requestHeader压入，再压入request.request

call只是完成了请求转换成byte传输到hbase服务端，在什么地方进行消息回收呢？

回到NewConnection的方法，里面有个connection.init()

func (c *connection) init() error {     err := c.writeHead()     if err != nil {          return err     }     err = c.writeConnectionHeader()     if err != nil {          return err     }     go c.processMessages()     return nil}

这里go c.processMessage()

func (c *connection) processMessages() {     for {          msgs := c.in.processData()          if msgs == nil || len(msgs) == 0 || len(msgs[0]) == 0 {               continue          }          var rh proto.ResponseHeader          err := pb.Unmarshal(msgs[0], &rh)          if err != nil {               panic(err)          }          callId := rh.GetCallId()          call, ok := c.calls[int(callId)]          delete(c.calls, int(callId))          exception := rh.GetException()          if exception != nil {               call.complete(fmt.Errorf("Exception returned: %s\n%s", exception.GetExceptionClassName(), exception.GetStackTrace()), nil)          } else if len(msgs) == 2 {               call.complete(nil, msgs[1])          }     }}

这里将它简化下：

func (c *connection) processMessages() {     for {          msgs := c.in.processData()        call.complete(nil, msgs[1])     }}

c.in.processData

是在input_stream.go中

func (in *inputStream) processData() [][]byte {    nBytesExpecting, err := in.readInt32()        ...     if nBytesExpecting > 0 {          buf, err := in.readN(nBytesExpecting)          if err != nil && err == io.EOF {               panic("Unexpected closed socket")          }          payloads := in.processMessage(buf)          if len(payloads) > 0 {               return payloads          }     }     return nil}

先读取出一个int值，这个int值判断后面还有多少个bytes，再将后面的bytes读取进入到buf中，进行input_stream的processMessage处理。

我们这里还看到并没有执行我们map中定义的匿名方法。只是把消息解析出来了而已。

call.complete

func (c *call) complete(err error, response []byte) {     ...     err2 := pb.Unmarshal(response, c.responseBuffer)     ...     c.responseCh <- c.responseBuffer}

这个函数有用的也就这两句话把responseBuffer里面的内容通过管道传递给responseCh

这里就看到getData的时候，被堵塞的地方

     select {     case msg := <-cl.responseCh:          return s.processResponse(msg)     }

那么这里就有把获取到的responseCh的消息进行processResponse处理。

func (s *Scan) processResponse(response pb.Message) []*ResultRow {     ...     results := res.GetResults()     n := len(results)    ...     s.closeScan(s.server, s.location, s.id)    ...     tbr := make([]*ResultRow, n)     for i, v := range results {          tbr[i] = newResultRow(v)     }     return tbr}

这个函数并没有什么特别的行为，只是进行ResultRow的组装。

好吧，这个包有个地方可以优化，这个go-hbase的scan的时候，numCached默认是100，这个对于hbase来说太小了，完全可以调整大点，到2000～10000之间，你会发现scan的性能提升杠杠的。