HBase的详细使用

最新推荐文章于 2024-05-15 07:28:37 发布
最新推荐文章于 2024-05-15 07:28:37 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： 大数据 文章标签： 大数据 hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44002865/article/details/119446717
版权

HBase

文章目录

1、安装

  • 第一步：将文件 hbase-1.3.1-bin.tar.gz 上传到服务器，并解压

  • 第二步：修改 hbase 目录下的 conf 目录下的 hbase-env.sh 文件

    export JAVA_HOME=/opt/software/jdk/jdk1.8.0_281
export HBASE_MANAGES_ZK=false

  • 第三步：修改 hbase 目录下的 conf 目录下的 hbase-site.xml 文件

        <property>
        <name>hbase.rootdir</name>
        <value>hdfs://hadoop151:8020/HBase</value>
    </property>
    <property>
        <name>hbase.cluster.distributed</name>
        <value>true</value>
    </property>
    <!-- 0.98 后的新变动，之前版本没有.port,默认端口为 60000 -->
    <property>
        <name>hbase.master.port</name>
        <value>16000</value>
    </property>
    <property> 
        <name>hbase.zookeeper.quorum</name>
        <value>hadoop151,hadoop152,hadoop153</value>
    </property>
    <property> 
        <name>hbase.zookeeper.property.dataDir</name>
        <value>/opt/software/zookeeper/zookeeper-3.4.10/zkData</value>
    </property>

  • 第四步：修改 hbase 目录下的 conf 目录下的 regionservers 文件

    hadoop151
hadoop152
hadoop153

  • 第五步：将Hadoop中 etc/hadoop 目录下的 core-site.xml、hdfs-site.xml 文件软连接到 HBase的 conf 目录中上

    ln -s /opt/software/hadoop/hadoop-3.1.4/etc/hadoop/core-site.xml \
/opt/software/hbase/hbase-1.3.1/conf/core-site.xml

ln -s /opt/software/hadoop/hadoop-3.1.4/etc/hadoop/hdfs-site.xml \
/opt/software/hbase/hbase-1.3.1/conf/hdfs-site.xml

  • 第六步：将整个 hbase 文件分发到其他服务器上

  • 第七步：启动 Zookeeper 集群 和 Hadoop

  • 第八步：启动 Hbase

    #方式一
bin/start-hbase.sh

#方式二
bin/hbase-daemon.sh start master
bin/hbase-daemon.sh start regionserver

  • 第九步：访问

    • http://hadoop151:16010




2、shell命令

基本操作

  • 进入 HBase 客户端命令行

    bin/hbase shell

  • 查看帮助命令（客户端命令行中执行）

    help

  • 查看当前数据库中有哪些表（客户端命令行中执行）

    list



表的操作

  • 创建表

    create '表名','列族名称'

#示例，单个列族
create 'fzk','info'
#示例，多个列族
create 'fzk','info1','info2'

  • 查看表结构

    describe '表名'

#示例
describe 'fzk'

  • 变更表信息

    alter '表名',{NAME=>'列族',VERSIONS=>版本数量}

#示例：将 info 列族中的数据存放 3 个版本
alter 'student',{NAME=>'info',VERSIONS=>3}

  • 删除表

    • 首先需要先让该表为 disable 状态，然后删除表

      disable '表名'
drop '表名'

# 示例
disable 'fzk'
drop 'fzk'



数据的操作

  • 插入和修改 数据到表

    put '表名','Row_Key值','列族:列字段名','值'

#示例
put 'fzk','1001','info:name','fff'

  • 删除数据

    delete '表名','Row_Key值','列族:列字段名'

#示例
delete 'fzk','1001','info:name'

  • 查看“指定行”或“指定列族:列”的数据

    #查看“指定行”
get 'fzk','1001'
#查看“指定行”的“指定列族:列”
get 'fzk','1001','info:name'

  • 扫描查看表数据

    #查看全表
scan 'fzk'
#查看 Row_Key值从1001 到 1003，左闭右开
scan 'fzk',{STARTROW=>'1001', STOPROW=>'1003'}




3、API

准备环境

  • 创建Maven工程，导入依赖（pom.xml）

    <dependencies>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>
</dependencies>



表操作API（DDL）

判断表是否存在

public boolean isTableExists(String tableName) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建HBase对象（Admin）
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    //通过 Connection 对象创建 Admin 对象
    Admin admin = connection.getAdmin();

    //判断表是否存在
    boolean tableExists = admin.tableExists(TableName.valueOf(tableName));

    //关闭连接
    if(admin != null){
        admin.close();
    }
    if(connection != null){
        connection.close();
    }

    //返回结果
    return tableExists;
}



创建表

public void createTable(String tableName, String... columns) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建HBase对象（Admin）
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    //通过 Connection 对象创建 Admin 对象
    Admin admin = connection.getAdmin();

    //创建表
    //校验列族
    if(columns.length <= 0){
        System.out.println("列族不能为空");
        return ;
    }
    //校验表名是否存在
    if(admin.tableExists(TableName.valueOf(tableName))){
        System.out.println("表名存在");
        return ;
    }
    //创建表描述器
    HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
    //循环添加列族信息
    for (String column : columns) {
        //创建列族描述器
        HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(column);
        //添加列族信息
        hTableDescriptor.addFamily(hColumnDescriptor);
    }
    //创建表
    admin.createTable(hTableDescriptor);


    //关闭连接
    if(admin != null){
        admin.close();
    }
    if(connection != null){
        connection.close();
    }
}



删除表

public void dropTable(String tableName) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建HBase对象（Admin）
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    //通过 Connection 对象创建 Admin 对象
    Admin admin = connection.getAdmin();

    //删除表
    //校验表名是否存在
    if(!admin.tableExists(TableName.valueOf(tableName))){
        System.out.println(tableName + " -- 表名不存在");
        return ;
    }
    //使表不可用
    admin.disableTable(TableName.valueOf(tableName));
    //删除表
    admin.deleteTable(TableName.valueOf(tableName));

    //关闭连接
    if(admin != null){
        admin.close();
    }
    if(connection != null){
        connection.close();
    }
}



创建命名空间

public void createNameSpace(String nameSpace) {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建HBase对象（Admin）
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(configuration);
    } catch (IOException e) {
        e.printStackTrace();
    }
    //通过 Connection 对象创建 Admin 对象
    Admin admin = null;
    try {
        admin = connection.getAdmin();
    } catch (IOException e) {
        e.printStackTrace();
    }

    //创建命名空间
    //创建命名空间描述器
    NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create(nameSpace).build();
    //创建命名空间
    try {
        admin.createNamespace(namespaceDescriptor);
    } catch (NamespaceExistException e) {
        System.out.println(namespaceDescriptor + " -- 命名空间已存在");
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    //关闭连接
    if(admin != null){
        admin.close();
    }
    if(connection != null){
        connection.close();
    }
}



数据操作API（DML）

插入数据

public void putData(String tableName, String rowKey, String cf, String cn, String value) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建Table对象
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    Table table = connection.getTable(TableName.valueOf(tableName));

    //插入数据
    //创建Put对象
    Put put = new Put(Bytes.toBytes(rowKey));
    //给put对象赋值
    put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
    //插入数据
    table.put(put);

    //关闭连接
    if (table != null) {
        table.close();
    }
    if (connection != null) {
        connection.close();
    }
}



获取数据（get）

public void getData(String tableName, String rowKey, String cf, String cn) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建Table对象
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    Table table = connection.getTable(TableName.valueOf(tableName));

    //获取数据
    //创建Get对象
    Get get = new Get(Bytes.toBytes(rowKey));
    //给Get对象赋值
    if (cf != null && !"".equals(cf)) {
        if (cn != null && !"".equals(cn)) {
            get.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));
        } else {
            get.addFamily(Bytes.toBytes(cf));
        }
    }
    //获取数据
    Result result = table.get(get);
    //解析Result，并打印数据
    for (Cell cell : result.rawCells()) {
        byte[] columeFamily = CellUtil.cloneFamily(cell);
        byte[] columnName = CellUtil.cloneQualifier(cell);
        byte[] value = CellUtil.cloneValue(cell);
        System.out.println("CF:" + Bytes.toString(columeFamily) + " -- " +
                           "CN:" + Bytes.toString(columnName) + " -- " +
                           "Value:" + Bytes.toString(value));
    }

    //关闭连接
    if (table != null) {
        table.close();
    }
    if (connection != null) {
        connection.close();
    }
}



获取数据（scan）

public void scanData(String tableName, String startRow, String stopRow) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建Table对象
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    Table table = connection.getTable(TableName.valueOf(tableName));

    //获取数据
    //创建Scan对象
    Scan scan = null;
    if (stopRow != null && !"".equals(stopRow)) {
        scan = new Scan(Bytes.toBytes(startRow), Bytes.toBytes(stopRow));
    } else {
        scan = new Scan(Bytes.toBytes(startRow));
    }
    //获取数据
    ResultScanner resultScanner = table.getScanner(scan);
    //解析ResultScanner
    for (Result result : resultScanner) {
        //解析Result
        Cell[] cells = result.rawCells();
        //打印数据
        for (Cell cell : cells) {
            byte[] row = CellUtil.cloneRow(cell);
            byte[] columeFamily = CellUtil.cloneFamily(cell);
            byte[] columnName = CellUtil.cloneQualifier(cell);
            byte[] value = CellUtil.cloneValue(cell);
            System.out.println("Row:" + Bytes.toString(row) + " -- " +
                               "CF:" + Bytes.toString(columeFamily) + " -- " +
                               "CN:" + Bytes.toString(columnName) + " -- " +
                               "Value:" + Bytes.toString(value));
        }
    }

    //关闭连接
    if (table != null) {
        table.close();
    }
    if (connection != null) {
        connection.close();
    }
}



删除数据

public void deleteData(String tableName, String rowKey, String cf, String cn) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建Table对象
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    Table table = connection.getTable(TableName.valueOf(tableName));

    //获取数据
    //创建Delete对象
    Delete delete = new Delete(Bytes.toBytes(rowKey));
    if (cf != null && !"".equals(cf)) {
        if (cn != null && !"".equals(cn)) {
            delete.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));
        } else {
            delete.addFamily(Bytes.toBytes(cf));
        }
    }
    //删除数据
    table.delete(delete);

    //关闭连接
    if (table != null) {
        table.close();
    }
    if (connection != null) {
        connection.close();
    }
}



MapReduce

环境准备

  • 第一步：将HBase的lib中的文件添加到Hadoop中

    • 在hadoop目录下的 etc/hadoop/ 目录下的 hadoop-env.sh 文件添加配置
    export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/$HBASE_HOME/lib/*

  • 第二步：将 hadoop-env.sh 文件分发到其他服务器上



官方案例

  • 案例一：统计 fzk 表中有多少行数据

    /hadoop目录/bin/yarn jar \
/hbase目录/lib/hbase-server-1.3.1.jar rowcounter fzk

#事例
/opt/software/hadoop/hadoop-3.1.4/bin/yarn jar \ 
/opt/software/hbase/hbase-1.3.1/lib/hbase-server-1.3.1.jar rowcounter fzk

  • 案例二：使用 MapReduce 将本地数据导入到 HBase

    • 第一步：在本地创建一个 tsv 格式的文件：my.tsv

      1001	fff	111
1002	zzz	222
1003	kkk	333

    • 第二步：在hdfs上创建 user 目录，并将 my.tsv 文件上传到 user 目录中

      hadoop fs -mkdir /user
hadoop fs -put my.tsv /user

    • 第三步：创建 Hbase 表

      create 'user', 'info'

    • 第四步：执行 MapReduce 到 HBase 的 user 表中

      /hadoop目录/bin/yarn jar \
/hbase目录/lib/hbase-server-1.3.1.jar importtsv \ 
-Dimporttsv.columns=HBASE_ROW_KEY,列族:字段,列族:字段 表名 \
文件的hdfs地址

/opt/software/hadoop/hadoop-3.1.4/bin/yarn jar \
/opt/software/hbase/hbase-1.3.1/lib/hbase-server-1.3.1.jar importtsv \ 
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:password user \
hdfs://hadoop151:8020/user



自定义Hbase-MapReduce

将 HDFS 中的数据写入到 Hbase 表中（打成jar包上传到服务器运行）

  • 第一步：导入依赖（pom.xml）

    <dependencies>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>
</dependencies>

  • 第二步：编写Mapper类

    import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;

public class MRMapper extends Mapper<LongWritable, Text, LongWritable, Text> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //写出到reduce中
        context.write(key, value);
    }
}

  • 第三步：编写Reducer类

    import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import java.io.IOException;

public class MRReducer extends TableReducer<LongWritable, Text, NullWritable> {
    @Override
    protected void reduce(LongWritable key, Iterable<Text> values, Context context) throws IOException, InterruptedException {

        for (Text value : values) {
            //切割数据
            String[] datas = value.toString().split("\t");
            
            //创建Put对象
            Put put = new Put(Bytes.toBytes(datas[0]));
            //给put对象赋值，三个参数分别是：列族、字段名、数据
            put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes(datas[1]));
            put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("password"), Bytes.toBytes(datas[2]));
            
            //写出到hbase的表中
            context.write(NullWritable.get(), put);
        }
    }
}

  • 第四步：编写Driver类

    import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.util.Tool;
import java.io.IOException;

public class MRDriver {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        //1、获取配置信息以及 job 对象
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        //2、关联 Driver 的 jar
        job.setJarByClass(MRDriver.class);

        //3、设置 Mapper 和 Reducer
        job.setMapperClass(MRMapper.class);
        TableMapReduceUtil.initTableReducerJob(args[1],  //表名
                MRReducer.class,   //reducer类
                job);  //job对象

        //4、设置 Mapper 输出的 key-value
        job.setMapOutputKeyClass(LongWritable.class);
        job.setMapOutputValueClass(Text.class);

        //5、设置 Reducer 输出的 key-value
        job.setOutputKeyClass(NullWritable.class);
        job.setOutputValueClass(Put.class);

        //6、设置 输入和输出 路径
        FileInputFormat.setInputPaths(job, new Path(args[0]));

        //7、提交 job
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

  • 第五步：将程序打包并上传到服务器（HBase目录的lib目录中）

  • 第六步：运行

    hadoop命令目录 jar jar包目录和名称 类的全限定名称 \
/hdfs上的数据目录 hbase的表名

# 事例
/opt/software/hadoop/hadoop-3.1.4/bin/hadoop jar /opt/software/hbase/hbase-1.3.1/lib/mr.jar \
com.itfzk.hbase.mr.MRDriver /users user



将一张表中的部分数据通过 MR 迁入到另一张表中（在本地运行）

需求：将 user 表中字段为‘name’的数据，通过 MR 迁入到 users 表中

  • 第一步：导入依赖（pom.xml）

    <dependencies>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>
</dependencies>

  • 第二步：将服务器上的HBase目录的conf目录的 hbase-site.xml 文件拷贝到项目的 resources 目录下

  • 第三步：Mapper类

    import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;

public class MRMapper extends TableMapper<ImmutableBytesWritable, Put> {
    @Override
    protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {
        //创建Put对象
        Put put = new Put(key.get());

        //遍历rowKey数据并将 类字段为‘name’ 的数据赋值给put对象
        for (Cell cell : value.rawCells()) {
            if ("name".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))){
                //将数据赋值给put对象
                put.add(cell);
                break;
            }
        }

        //写出到reduce中
        context.write(key, put);
    }
}

  • 第四步：Reducer类

    import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.NullWritable;
import java.io.IOException;

public class MRReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {
    @Override
    protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context) throws IOException, InterruptedException {
        //将数据写出到hbase的表中
        for (Put put : values) {
            context.write(NullWritable.get(), put);
        }
    }
}

  • 第五步：Driver类

    import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import java.io.IOException;

public class MRDriver2 {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        //1、获取配置信息以及 job 对象
        Configuration configuration = HBaseConfiguration.create();
        Job job = Job.getInstance(configuration);

        //2、关联 Driver 的 jar
        job.setJarByClass(MRDriver2.class);

        //3、设置 Mapper 和 输出的 key-value 类型
        TableMapReduceUtil.initTableMapperJob("user",  //表名
                new Scan(),  //Scan查询对象
                MRMapper.class,  //mapper对象
                ImmutableBytesWritable.class,  //mapper的key的输出类型
                Put.class,  //mapper的value的输出类型
                job);  //job

        //4、设置Reducer
        TableMapReduceUtil.initTableReducerJob("users",  //表名
                MRReducer.class,   //reducer类
                job);  //job对象


        //5、设置 Reducer 输出的 key-value 类型
        job.setOutputKeyClass(NullWritable.class);
        job.setOutputValueClass(Put.class);


        //6、提交 job
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}




4、优化

高可用

  • 在hbase目录下创建并编辑 conf/backup-masters 文件

    # 另外两台服务器的 host 名称（作用：启动hbase时，这两台也启动master成Backup Master，当master挂掉后，Backup Master会又一个成为master）
hadoop152
hadoop153



预分区（四种方式）

每一个 region 维护着 StartRow 与 EndRow，如果加入的数据符合某个 Region 维护的 RowKey 范围，则该数据交给这个 Region 维护。那么依照这个原则，我们可以将数据所要投放的分区提前大致的规划好，以提高 HBase 性能。

  • 第一种：手动设定预分区

    # 五个分区：(负无穷,1000),(1000,2000),(2000,3000),(3000,4000),(4000,正无穷)
create 'table1001','info',SPLITS=>['1000','2000','3000','4000']

  • 第二种：生成 16 进制序列预分区（不推荐）

    #生成15个分区，按 16 进行分区
create 'table1002','info',{NUMREGIONS => 15, SPLITALGO =>'HexStringSplit'}

  • 第三种：按照文件中设置的规则预分区

    #按 splits.txt 文件进行分区
create 'table1003',SPLITS_FILE =>'splits.txt'

  • 第四种：使用 JavaAPI 创建预分区

    public void createTable(String tableName, String... columns) throws IOException {
    //获取配置文件信息
    Configuration configuration = HBaseConfiguration.create();
    configuration.set("hbase.zookeeper.quorum", "hadoop151,hadoop152,hadoop153");

    //创建HBase对象（Admin）
    //使用 ConnectionFactory 类创建 Connection 对象
    Connection connection = ConnectionFactory.createConnection(configuration);
    //通过 Connection 对象创建 Admin 对象
    Admin admin = connection.getAdmin();

    //创建表描述器
    HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
    //循环添加列族信息
    for (String column : columns) {
        //创建列族描述器
        HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(column);
        //添加列族信息
        hTableDescriptor.addFamily(hColumnDescriptor);
    }

    / JavaAPI 创建预分区
    //自定义算法，产生一系列 hash 散列值存储在二维数组中
    byte[][] splitKeys = 某个散列值函数;
    //创建表（通过 HTableDescriptor 实例和散列值二维数组创建带有预分区的 Hbase 表）
    admin.createTable(hTableDescriptor, splitKeys);

    //关闭连接
    if(admin != null){
        admin.close();
    }
    if(connection != null){
        connection.close();
    }
}



基础优化

  • 允许在 HDFS 的文件中追加内容（hdfs-site.xml、hbase-site.xml）

    属性：dfs.support.append
解释：开启 HDFS 追加同步，可以优秀的配合 HBase 的数据同步和持久化。默认值为 true

  • 优化 DataNode 允许的最大文件打开数（hdfs-site.xml ）

    属性：dfs.datanode.max.transfer.threads
解释：HBase 一般都会同一时间操作大量的文件，根据集群的数量和规模以及数据动作，设置为 4096 或者更高。默认值：4096

  • 优化延迟高的数据操作的等待时间（hdfs-site.xml）

    属性：dfs.image.transfer.timeout
解释：如果对于某一次数据操作来讲，延迟非常高，socket 需要等待更长的时间，建议把该值设置为更大的值（默认 60000 毫秒），以确保 socket 不会被 timeout 掉。

  • **优化数据的写入效率 **（mapred-site.xml）

    属性：	
    mapreduce.map.output.compress
    mapreduce.map.output.compress.codec
解释：开启这两个数据可以大大提高文件的写入效率，减少写入时间。第一个属性值修改为true，第二个属性值修改为：org.apache.hadoop.io.compress.GzipCodec 或者其他压缩方式。

  • 设置 RPC 监听数量（hbase-site.xml ）

    属性：Hbase.regionserver.handler.count
解释：默认值为 30，用于指定 RPC 监听的数量，可以根据客户端的请求数进行调整，读写请求较多时，增加此值。

  • 优化 HStore 文件大小（hbase-site.xml ）

    属性：hbase.hregion.max.filesize
解释：默认值 10737418240（10GB），如果需要运行 HBase 的 MR 任务，可以减小此值，因为一个 region 对应一个 map 任务，如果单个 region 过大，会导致 map 任务执行时间过长。该值的意思

  • 优化 HBase 客户端缓存（hbase-site.xml ）

    属性：hbase.client.write.buffer
解释：用于指定 Hbase 客户端缓存，增大该值可以减少 RPC 调用次数，但是会消耗更多内存，反之则反之。一般我们需要设定一定的缓存大小，以达到减少 RPC 次数的目的。

  • 指定 scan.next 扫描 HBase 所获取的行数（hbase-site.xml）

    属性：hbase.client.scanner.caching
解释：用于指定 scan.next 方法获取的默认行数，值越大，消耗内存越大。
code@fzk
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 代码操作hbase 问题,以及怎么找 pom 依赖
lb876864380的博客
03-12 2490
某日 ,某人 使用java操作 hbase 的时候 出现了问题, 报错如下: 18/03/12 20:03:54 DEBUG AbstractRpcClient: Connecting to master.r417.cs.scnu.edu.cn/192.168.69.204:6002018/03/12 20:03:54 DEBUG ConnectionManager$HConnectionImpl...
HBase进阶
sun_0128的博客
07-21 442
文章目录一.HBase REST API二.Phoenix概述三.Hive与HBase集成使用场景1.Hive与HBase集成原理三.Hbase常用命令1.名称空间（NameSpace）2.安全权限（Security with GRANT）3.权限管理命令（revoke & user_permission）四.Region管理五.HBase Compaction - LSM 一.HBase REST API 使用REST API操作HBase 1.start/stop rest service
Hadoop集群中Hbase的介绍、安装、使用_root@master001 hadoop]# start-hbase
最新发布
2401_83973943的博客
05-15 942
最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！
HBase使用教程
u012998680的博客
03-31 1182
HBase常用的查看数据方式有scan和get，get是一种特殊的scan，get是scan的startRow和endRow等于同一个值的特殊情况。HBase的RowKey 是按照B+树的形式存放的，所以查找一个具体的RowKey 速度是非常快的，所以查询数据的时候一般都会设置scan的startRow和endRow，这样可以缩小查找的范围，所以RowKey 的设计在HBase里面是极为重要的。
hbase使用
weixin_38312502的博客
09-01 3046
1. 简介 HBase是一种分布式、可扩展、支持海量数据存储的NoSQL数据库。Hbase面向列存储，，基于hadoop的数据库，提供一个十亿级行*百万级列级别的表存储，对表中的数据提供实时的随机读写操作！ 1.1 优点 海量存储：HBase适合存储PB级别的海量数据，在PB级别的数据以及采用廉价PC存储的情况下，能在几十到百毫秒内返回数据。这与HBase的极易扩展性息息相关。正式因为HBase良好的扩展性，才为海量数据的存储提供了便利。 列式存储：这里的列式存储其实说的是列族存储，HBase是根据
Hbase基本操作
qq_48391148的博客
04-18 1203
Hbase创建表的时候不需要创建所有列簇，对于空（null）的列，并不占用存储空间，因此表可以设计的非常稀疏。命令格式：put '表名'，‘行键','列簇名','列名','值',[时间戳]命令格式1：create ‘表名’,‘列簇名1’,‘列簇名2’…获取指定行，指定行中的列簇，列的信息。
Hbase详细安装步骤
05-07
HBase 详细安装步骤 HBase 是一个分布式、面向列的 NoSQL 数据库，它基于 Hadoop 的分布式文件系统（HDFS）和 MapReduce 编程模型。以下是在 Ubuntu 环境下安装 HBase 的详细步骤： 安装 HBase 1. 获取安装文件 ...
HBase超详细介绍
02-01
HBase是ApacheHadoop中的一个子项目，Hbase依托于Hadoop的HDFS作为最基本存储基础单元，通过使用hadoop的DFS工具就可以看到这些这些数据 存储文件夹的结构,还可以通过Map/Reduce的框架(算法)对HBase进行操作，如右侧...
HBase技术详细介绍
03-03
HBase–HadoopDatabase，是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PCServer上搭建起大规模结构化存储集群。HBase是GoogleBigtable的开源实现，类似GoogleBigtable利用GFS作为...
HBase入门教程
qq_54070501的博客
04-18 4571
1、什么是HBase？ HBase是建立在Hadoop文件系统之上的分布式面向列的数据库。它是一个开源项目，是横向扩展的。 HBase是一个数据模型，类似于谷歌的大表设计，可以提供快速随机访问海量结构化数据。它利用了Hadoop的文件系统（HDFS）提供的容错能力。 它是Hadoop的生态系统，提供对数据的随机实时读/写访问，是Hadoop文件系统的一部分。人们可以直接或通过HBase的存储HDFS数据。使用HBase在HDFS读取消费/随机访问数据。HBa...
HBase正确使用方法
qq_37480069的博客
04-27 682
本文介绍了HBase的安装和配置、HBase Shell的使用方法、Java API的使用方法以及HBase与Hadoop MapReduce的集成方法。HBase是一个强大的分布式NoSQL数据库，可以满足大规模数据存储和处理的需求。
HBase基础知识(个人总结)
hellosrc的博客
03-07 2086
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
Hbase基础(一)——安装与使用
weixin_63507910的博客
04-04 4151
Hbase是一个分布式的、面向列的开源数据库，有区别于传统的行式数据库(如Mysql等)，与Hive数据仓库相比，更适合实时存储数据场景，但是与传统的列式数据库相比，更适合键值对的数据存取或者有序的数据存取。Hbase的版本有很多，读者在下载Hbase的压缩包之前，先去Hbase官网查看不同版本的hadoop对哪些版本的Hbase支持。本系列文章是基于hadoop集群搭建后的入门学习，关于hadoop集群搭建，请自行查看笔者发布的hadoop系列文章。
HBase使用手册
qq_33661213的博客
09-18 1579
HBase使用手册 1.概述 使用须知 本文档适用于CRH产品中HBase组件应用开发。 HBase简介 HBase作为一个典型的NoSQL数据库，使用Hadoop的HDFS作为底层存储，可以通过行键（Rowkey）检索数据，仅支持单行事务，主要用于存储非结构化和半结构化的松散数据。与Hadoop相同，HBase的设计目标主要依靠横向扩展，通过不断的增加廉价商用服务器来增加和存储能力。 ...
Hbase2.0.5、zookeeper3.5.7安装（基于Flink电商项目实战）
日句灬的博客
07-21 447
1.介绍 本文中的Hbase和Zookeeper安装方法不仅适用于此版本，至少Hbase2.3之前的版本我装过好几个，都没问题，zookeeper3.6以上的版本也适用，文章介绍版本仅仅是为了契合项目所定。 Flink实时电商项目实战 默认已安装hadoop、java环境； hadoop3.1.3搭建 2、Hbase安装和Zookeeper安装 2.1、配置文件修改： 解压和基本安装后： 进入Hbase的conf目录下： 修改三个文件： hbase-env.sh: echo $JAVA_HOME查看当前ja
HBase常用命令使用
热门推荐
看图说话
03-08 3万+
1、Hbase shell客户端使用 a、进入客户端 hbase shell b、常用命令 list 列出Hbase中存在的所有表 alter 修改列簇(column family)模式 count 统计表中行的数量 create 创建表 ...
hbase获取所有版本的数据和时间戳
kuanglongyangyang1的博客
06-02 2万+
1.要保证hbase表本身有多个version2.get的时候，要保证读取的可以读到多个或者所有的version3.正常读取各个版本的数据Celluser_tag某些行的某些列有多个版本，可以获取全部版本。建表时user_tag表是有10个version的。hbase的cell取法，第二种更好。不用listCells，用rawCells：1.hbase的cell取法第一种，result.listC...
HBase新版本Java API编程实战及基本操作方法封装
至道
05-14 2万+
我的HBase版本是0.98 首先说明一下，如果用eclipse操作hbase时，如果报Unknown host错误，找不到主机，是因为你没有配IP地址的映射 方法是 找到你的系统盘里面的C:\Windows\System32\drivers\etc下的hosts文件，打开，增加一个映射 加一个映射 192.168.52.140 master话不多说，直接看代码，注释很详细 import
springboot连接hbase详细步骤示例
06-01
好的，下面是连接 HBase 的 Spring Boot 详细步骤示例： 1. 添加 HBase 依赖 在 pom.xml 中添加以下依赖： ``` <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>${hbase-version}</version> </dependency> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-server</artifactId> <version>${hbase-version}</version> </dependency> ``` 其中 ${hbase-version} 是 HBase 的版本号。 2. 配置 HBase 连接信息 在 application.properties 中添加以下配置信息： ``` hbase.zookeeper.quorum=zk_host1,zk_host2,zk_host3 hbase.zookeeper.property.clientPort=2181 ``` 其中，hbase.zookeeper.quorum 是 ZooKeeper 的地址列表，hbase.zookeeper.property.clientPort 是 ZooKeeper 的端口号。 3. 创建 HBase 连接 使用 HBaseConfiguration.create() 方法创建 HBase 连接： ``` Configuration config = HBaseConfiguration.create(); ``` 4. 创建 HBase 连接池 使用 HConnectionManager.createConnection(config) 方法创建 HBase 连接池： ``` Connection connection = ConnectionFactory.createConnection(config); ``` 5. 获取 HBase 表 使用 connection.getTable(TableName.valueOf("tableName")) 方法获取 HBase 表： ``` Table table = connection.getTable(TableName.valueOf("tableName")); ``` 其中，tableName 是 HBase 表的名称。 6. 操作 HBase 表 可以使用 Table 接口提供的方法操作 HBase 表，例如： ``` Put put = new Put(Bytes.toBytes("rowKey")); put.addColumn(Bytes.toBytes("columnFamily"), Bytes.toBytes("columnName"), Bytes.toBytes("columnValue")); table.put(put); ``` 其中，rowKey、columnFamily、columnName、columnValue 分别是 HBase 表中的行键、列族、列名和列值。 7. 关闭连接 使用 close() 方法关闭连接： ``` table.close(); connection.close(); ``` 以上就是连接 HBase 的 Spring Boot 详细步骤示例，希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值