Verwenden Sie HBase in der Go-Sprache, um effiziente NoSQL-Datenbankanwendungen zu implementieren

Mit dem Aufkommen des Big-Data-Zeitalters ist die Speicherung und Verarbeitung großer Datenmengen besonders wichtig. Im Hinblick auf NoSQL-Datenbanken ist HBase derzeit eine weit verbreitete Lösung. Als statisch stark typisierte Programmiersprache wird die Go-Sprache aufgrund ihrer einfachen Syntax und hervorragenden Leistung zunehmend in Bereichen wie Cloud Computing, Website-Entwicklung und Datenwissenschaft eingesetzt. In diesem Artikel wird erläutert, wie Sie HBase in der Go-Sprache verwenden, um effiziente NoSQL-Datenbankanwendungen zu implementieren.

1. Einführung in HBase

HBase ist ein hoch skalierbares, äußerst zuverlässiges, spaltenbasiertes verteiltes Datenspeichersystem. Es läuft auf einem Hadoop-Cluster und kann extrem umfangreiche Datenspeicher- und -verarbeitungsaufgaben bewältigen. Das Datenmodell von HBase ähnelt Googles Bigtable, einer spaltenbasierten NoSQL-Datenbank. HBase weist die folgenden Eigenschaften auf:

• Basierend auf der verteilten Hadoop-Computing-Plattform kann es Daten auf PB-Ebene auf Tausenden von Maschinen speichern.
• Unterstützt schnelles Lesen und Schreiben von Daten, Speicherung und Zugriff erfolgen sehr schnell.
• Unterstützt mehrere Datenzugriffsmethoden wie zufälliges Lesen, Scan-Lesen, vollständiger Tabellenscan usw.
• Unterstützt die Speicherung und Abfrage von Daten mit mehreren Versionen und kann Zeitreihendaten effektiv verarbeiten.
• Unterstützt die horizontale Erweiterung und kann die Speicher- und Verarbeitungskapazitäten problemlos erweitern.
• Bietet eine Reihe von Filtern und Encodern zur Unterstützung der Datenverarbeitung und -transformation.

2. Go-Sprache betreibt HBase.

Go-Sprache stellt die Thrift-Bibliothek zur Implementierung von Vorgängen auf HBase bereit. Thrift ist ein sprachübergreifendes Framework unter Apache, das Code in mehreren Sprachen generieren kann, einschließlich Java, Python, Ruby, C++ usw. Mit Thrift können Entwickler RPC-Dienste mithilfe einer einfachen Definitionssprache definieren und clientseitigen und serverseitigen Code generieren. In der Go-Sprache können Sie die Thriftgo-Bibliothek für die Entwicklung verwenden.

2.1 Thrift installieren

Bevor Sie Thrift verwenden, müssen Sie zunächst den Thrift-Compiler installieren. Sie können die entsprechende Version des Compilers von der offiziellen Thrift-Website herunterladen, entpacken und zu den Umgebungsvariablen hinzufügen.

2.2 Definieren Sie die Thrift-Schnittstelle von HBase

Die Thrift-Definitionsdatei heißt IDL (Interface Definition Language, Schnittstellendefinitionssprache). Die Thrift-Schnittstellendatei von HBase ist Hbase.thrift. Es kann aus der offiziellen Dokumentation oder von Github über den Befehl „git clone“ heruntergeladen werden.

$ git clone https://github.com/apache/hbase

Alle Thrift-Schnittstellendefinitionen von HBase finden Sie in der Datei Hbase.thrift, und wir können sie nach Bedarf verwenden. Das Folgende ist beispielsweise eine Schnittstellendefinition, die Tabellen auflistet:

struct TColumnDescriptor {

1: required binary name,
2: binary value,
3: bool __isset.value,
4: optional CompressionType compression,
5: optional int32 maxVersions,
6: optional int32 minVersions,
7: optional int32 ttl,
8: optional bool inMemory,
9: optional BloomType bloomFilterType,
10: optional int32 scope,
11: optional bool __isset.compression,
12: optional bool __isset.maxVersions,
13: optional bool __isset.minVersions,
14: optional bool __isset.ttl,
15: optional bool __isset.inMemory,
16: optional bool __isset.bloomFilterType,
17: optional bool __isset.scope

}

TColumnDescriptor kann als Definition einer Spaltenfamilie betrachtet werden, die den Namen der Spaltenfamilie, den Komprimierungstyp, die maximale Version und die Ablaufzeit umfasst sowie Speicher und andere Eigenschaften. In der Go-Sprache müssen Sie den Thrift-Compiler verwenden, um die Hbase.thrift-Datei in den Go-Sprachcode zu kompilieren. Die Thriftgo-Bibliothek muss vor der Kompilierung installiert werden.

$ go get -u github.com/apache/thrift/lib/go/thrift

Führen Sie dann den folgenden Befehl im HBase-Verzeichnis aus, um Go-Sprachcode zu generieren.

$ thrift --gen go src/main/resources/org/apache/hadoop/hbase/thrift/Hbase.thrift

Nachdem Sie den Befehl ausgeführt haben, sehen Sie den gesamten generierten Go-Sprachcode im generierten gen-go-Verzeichnis dokumentieren.

2.3 Verbindung zum HBase-Server herstellen

Um eine Verbindung zum HBase-Server herzustellen, müssen Sie eine Transportverbindung erstellen und einen Verbindungspool verwenden, um die Verbindung zu verwalten. Der Verbindungspool kann mehrere Transportverbindungen verwalten, und die Wiederverwendung dieser Verbindungen kann den Gesamtdurchsatz verbessern. Das Folgende ist ein Codebeispiel für die Verbindung mit HBase:

package main

import (

"context"
"fmt"
"sync"

"git.apache.org/thrift.git/lib/go/thrift"
"hbase"

)

type pool struct {

hosts    []string         // HBase服务器地址列表
timeout  thrift.TDuration // 连接超时时间
size     int              // 连接池大小
pool     chan *conn       // 连接池
curConns int              // 当前连接池中的连接数

lock sync.RWMutex

}

type conn struct {

trans hbase.THBaseServiceClient // HBase客户端
used  bool                      // 是否被使用

}

// NewPool initialisiert die Verbindungspool
func NewPool(hosts []string, timeout int, size int) *pool {

p := &pool{
    hosts:    hosts,
    timeout:  thrift.NewTDuration(timeout * int(thrift.MILLISECOND)),
    size:     size,
    pool:     make(chan *conn, size),
    curConns: 0,
}

p.lock.Lock()
defer p.lock.Unlock()

for i := 0; i < size; i++ {
    p.newConn()
}

return p

}

// AddConn Verbindung hinzufügen
func (p *pool) AddConn() {

p.lock.Lock()
defer p.lock.Unlock()

if p.curConns < p.size {
    p.newConn()
}

}

// Close Verbindungspool schließen
func (p *pool) Close() {

p.lock.Lock()
defer p.lock.Unlock()

for i := 0; i < p.curConns; i++ {
    c := <-p.pool
    _ = c.trans.Close()
}

}

// GetConn Verbindung abrufen
func (p pool) GetConn() (conn, Fehler) {

select {
case conn := <-p.pool:
    if conn.used {
        return nil, fmt.Errorf("Connection is already in use")
    }

    return conn, nil
default:
    if p.curConns >= p.size {
        return nil, fmt.Errorf("Connection pool is full")
    }

    p.lock.Lock()
    defer p.lock.Unlock()

    return p.newConn(), nil
}

}

// PutConn Return Connect
func (p pool) PutConn(conn conn) {

conn.used = false
p.pool <- conn

}

// newConn Verbindung erstellen
func (p pool) newConn() conn {

socket := thrift.NewTSocketTimeout(p.hosts[0], p.timeout)
transport := thrift.NewTFramedTransport(socket)
protocol := thrift.NewTBinaryProtocolTransport(transport, true, true)
client := hbase.NewTHBaseServiceClientFactory(transport, protocol)

if err := transport.Open(); err != nil {
    return nil
}

p.curConns++

return &conn{
    trans: client,
    used:  false,
}

}

Using Im obigen Codebeispiel ist es möglich, einen Verbindungspool für die Verbindung mit HBase zu erstellen. Nachdem Sie Parameter wie Hosts, Timeout und Größe festgelegt haben, können Sie mit der NewPool-Methode einen Verbindungspool erstellen. Verbindungen im Verbindungspool können mit der GetConn-Methode abgerufen und mit der PutConn-Methode zurückgegeben werden.

2.4 Daten bearbeiten

Nachdem Sie eine Verbindung zum HBase-Server hergestellt haben, können Sie die Verbindung im Verbindungspool verwenden, um die Daten zu bearbeiten. Hier sind einige Beispiele für Operationen mit Daten:

// Eine Liste von Tabellen abrufen
func GetTableNames(c *conn) ([]string, error) {

names, err := c.trans.GetTableNames(context.Background())
if err != nil {
    return nil, err
}

return names, nil

}

// Eine Datenzeile abrufen
func GetRow (c conn, tableName string, rowKey string) (hbase.TRowResult_, error) {

// 构造Get请求
get := hbase.NewTGet()
get.Row = []byte(rowKey)
get.TableName = []byte(tableName)

result, err := c.trans.Get(context.Background(), get)
if err != nil {
    return nil, err
}

if len(result.Row) == 0 {
    return nil, fmt.Errorf("Row %s in table %s not found", rowKey, tableName)
}

return result, nil

}

// Eine Datenzeile schreiben
func PutRow(c *conn, tableName string, rowKey string, columns map[ string]map [string][]byte,

         timestamp int64) error {
// 构造Put请求
put := hbase.NewTPut()
put.Row = []byte(rowKey)
put.TableName = []byte(tableName)

for cf, cols := range columns {
    family := hbase.NewTColumnValueMap()

    for col, val := range cols {
        family.Set(map[string][]byte{
            col: val,
        })
    }

    put.ColumnValues[[]byte(cf)] = family
}

put.Timestamp = timestamp

_, err := c.trans.Put(context.Background(), put)
if err != nil {
    return err
}

return nil

}

Die GetTableNames-Methode kann eine Liste von Tabellen abrufen, die GetRow-Methode kann eine Datenzeile abrufen und die PutRow-Methode kann eine Datenzeile schreiben. Das sollte so sein Beachten Sie, dass die TPut-Anfrage in der PutRow-Methode erstellt werden muss.

3. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie HBase in der Go-Sprache verwenden, um effiziente NoSQL-Datenbankanwendungen zu implementieren. Von der Definition der Thrift-Schnittstelle über die Verbindung zum HBase-Server bis hin zu Betriebsdaten wird Schritt für Schritt erklärt, wie man HBase mit der Go-Sprache betreibt. Mit der hohen Leistung der Go-Sprache und den sprachübergreifenden Funktionen des Thrift-Frameworks können effiziente NoSQL-Datenbankanwendungen erstellt werden.

Das obige ist der detaillierte Inhalt vonVerwenden Sie HBase in der Go-Sprache, um effiziente NoSQL-Datenbankanwendungen zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!