hbase入门学习

hbase学习

1.安装，环境配置；
2.命令建表，插入和查询；
3.java操作；

一、安装和环境配置

1.apache官网上下载一个hbase的安装包，例如【hbase-2.6.2-bin.tar.gz】
解压，并修改文件夹名称为hbase-2.6.2
2.配置环境
例如：.zshrc

export HBASE_HOME=/Users/xxxx/tools/hbase-2.6.2
export PATH=$HBASE_HOME/bin:$PATH
export HBASE_MANAGES_ZK=true

并执行source .zshrc 立马生效。

在/hbase-2.6.2/conf目录中修改【hbase-site.xml】，目录可以先手动创建好

<property>
    <name>hbase.rootdir</name>
    <value>file:///Users/xxxx/tools/hbase-2.6.2/data</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/Users/xxxx/tools/hbase-2.6.2/zookeeper</value>
  </property>

在命令行执行以下命令，返回正确版本，就可以了。

hbase verison

二、命令操作

启动hbase

start-hbase.sh

启动命令行

hbase shell   

然后命令行里面创建表

create 'user_table', 'info', 'address'

插入数据

put 'user_table', 'user1', 'info:name', 'Tom'
put 'user_table', 'user1', 'info:age', '25'
put 'user_table', 'user1', 'address:city', 'Beijing'

查询数据

get 'user_table', 'user1'

三、基本概念

在 HBase 中，表（Table）、列族（Column Family）和列（Column）是数据模型的三个核心概念。它们之间的关系和区别如下：

1. 表（Table）
   定义：
   表是 HBase 中数据存储的顶层结构，类似于关系数据库中的表。
   每个表由多个行（Row）组成，每行由行键（Row Key）唯一标识。
   特点：
   表可以包含多个列族。
   表的结构是动态的，即在表创建后，可以随时添加新的列族或列。
2. 列族（Column Family）
   定义：
   列族是表中的一个逻辑分组，用于存储一组相关的列。
   每个列族可以包含多个列，列族内的列共享相同的存储和访问特性。
   特点：
   列族在表创建时必须预先定义，且每个表至少需要一个列族。
   列族内的列可以动态添加，不需要预先定义。
   列族的存储是物理上的分组，HBase 会将同一列族的数据存储在一起，以提高读写效率。
   列族的名称必须是字符串，且在表中是唯一的。
3. 列（Column）
   定义：
   列是列族中的一个具体字段，用于存储实际的数据。
   列由列族名称和列限定符（Column Qualifier）组成，格式为 列族:列限定符。
   特点：
   列是动态的，可以在运行时动态添加或删除。
   列的名称（列限定符）必须是字符串，且在列族中是唯一的。
   列可以存储不同类型的数据，如字符串、整数、二进制数据等。

关系和区别

表 是最高级别的结构，包含多个 列族。
列族 是表中的一个逻辑分组，包含多个 列。
列 是列族中的具体字段，用于存储实际的数据。

四、java操作

pom引入，注意hadoop-auth可能和项目中的其他hadoop版本冲突，可以排除掉。不然可能会报如下错误。

Exception in thread "main" java.lang.NoSuchMethodError: org.apache.hadoop.security.HadoopKerberosName.setRuleMechanism(Ljava/lang/String;)V

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.4.7</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.hadoop</groupId>
                    <artifactId>hadoop-auth</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

编写测试代码

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.client.TableDescriptor;
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBaseService {

    private static Connection connection;

    static {
        org.apache.hadoop.conf.Configuration config = HBaseConfiguration.create();
        config.set("hbase.zookeeper.quorum", "localhost");
        config.set("hbase.zookeeper.property.clientPort", "2181");
        try {
            connection = ConnectionFactory.createConnection(config);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        HBaseService hBaseService = new HBaseService();
        hBaseService.createTable("user_table1", "info", "address");
        hBaseService.putData("user_table1", "user1", "info", "name", "Tom");
        hBaseService.putData("user_table1", "user1", "info", "age", "25");
        hBaseService.putData("user_table1", "user1", "address", "city", "Beijing");

        String name = hBaseService.getData("user_table1", "user1", "info", "name");
        System.out.println("Name: " + name);
    }

    // 创建表
    public void createTable(String tableName, String... columnFamilies) throws IOException {
        Admin admin = connection.getAdmin();
        if (!admin.tableExists(TableName.valueOf(tableName))) {

            TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName))
                    .setColumnFamily(ColumnFamilyDescriptorBuilder.of(columnFamilies[0]))
                    .build();

            for (int i = 1; i < columnFamilies.length; i++) {
                tableDescriptor = TableDescriptorBuilder.newBuilder(tableDescriptor)
                        .setColumnFamily(ColumnFamilyDescriptorBuilder.of(columnFamilies[i]))
                        .build();
            }
            admin.createTable(tableDescriptor);
            System.out.println("Table created: " + tableName);
        } else {
            System.out.println("Table already exists: " + tableName);
        }
    }

    // 插入数据
    public void putData(String tableName, String rowKey, String family, String qualifier, String value) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Put put = new Put(Bytes.toBytes(rowKey));
        put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier), Bytes.toBytes(value));
        table.put(put);
        table.close();
    }

    // 获取数据
    public String getData(String tableName, String rowKey, String family, String qualifier) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Get get = new Get(Bytes.toBytes(rowKey));
        get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
        Result result = table.get(get);
        byte[] value = result.getValue(Bytes.toBytes(family), Bytes.toBytes(qualifier));
        table.close();
        return value != null ? new String(value) : null;
    }
}

运行main方法后，可以看到结果。