Hbase——javaAPI

最新推荐文章于 2024-11-06 16:57:12 发布
最新推荐文章于 2024-11-06 16:57:12 发布
阅读量404 收藏 1
点赞数 2
文章标签： hbase hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51960163/article/details/120691943
版权

上一篇文章Hbase主要讲解了Hbase的核心架构基础理论知识，本篇文章是相关Hbase——JavaAPI的使用

DDL

package com.tommy.test;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;

import java.io.IOException;

/**
 * DDL
 * 1.判断表是否存在
 * 2.创建表
 * 3.创建命名空间
 * 4.删除表
 * <p>
 * DML：
 * 1.插入数据
 * 2.查找数据（get，scan）两种方式
 * 3.删除数据
 */

public class TestAPI {

    private static Connection connection = null;
    private static Admin admin = null;
//------------------------------------------------------------------------------------
    static {    

        try {
            //1. get configuration information
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "Hadoop104");

            //2. create connection
            connection = ConnectionFactory.createConnection(configuration);

            //3. create admin
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
//------------------------------------------------------------------------------------
    // 1. 判断表是否存在
    public static boolean isTableExist(String tableName) throws IOException {

        boolean exists = admin.tableExists(TableName.valueOf(tableName));

        return exists;
    }
//------------------------------------------------------------------------------------
    // 2. create table
    public static void createTable(String tableName, String... cfs) throws IOException {

        //1. 判断是否存在列族信息
        if (cfs.length <= 0) {
            System.out.println("column is not exists!!");
            return;
        }

        // 2. table if exists
        if (isTableExist(tableName)) {
            System.out.println(tableName + " is already exists!");
        }

        // 3.create table's description
        HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));

        // 4.循环添加列族信息
        for (String cf : cfs) {

            //5.创建列族描述器
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cf);

            // 6.添加具体的列族信息
            hTableDescriptor.addFamily(hColumnDescriptor);
        }

        // 7.create table
        admin.createTable(hTableDescriptor);
    }
//------------------------------------------------------------------------------------
    // 3. 删除表
    public static void drop(String tableName) throws IOException {

        if (!isTableExist(tableName)) {
            System.out.println(tableName + " is not exists!");
            return;
        }

        // disable table
        admin.disableTable(TableName.valueOf(tableName));

        // drop table
        admin.deleteTable(TableName.valueOf(tableName));

        System.out.println("drop table successful!!");
    }
//------------------------------------------------------------------------------------
    // 4. 创建命名空间
    public static void createNameSpace(String ns) {

        // 1. create namespace inspector
        // 私有化的构造方法中都有Builder类
        NamespaceDescriptor build = NamespaceDescriptor.create(ns).build();

        // 2、创建命名空间
        try {
            admin.createNamespace(build);
        } catch (NamespaceExistException e) {
            System.out.println(ns + "命名空间已经存在");
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Hello");
    }
//------------------------------------------------------------------------------------
// 关闭资源
    public static void close() {

        if (admin != null) {
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
//------------------------------------------------------------------------------------
    public static void main(String[] args) throws IOException {

        createTable("0408:stu5", "info1", "info2");
        close();
    }
}

DML

	public static void putData(String tableName, String rowKey, String cf, String cn, String value)
            throws IOException {

        // 1. 获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));

        // 2. create put
        Put put = new Put(Bytes.toBytes(rowKey));

        // 3.给Put对象赋值
        put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
        // List<Put> puts
		
        // 4. insert value
        table.put(put);   // table.put(puts)

        // 5. close
        table.close();
    }
//---------------------------------------------------------------------------------------------
// 测试：
    public static void main(String[] args) throws IOException {

        putData("stu4", "1001", "info", "name", "zhangsan");
        close();
    }

DML

get
  • 方式一：指定到rowkey：
    public static void getData(String tableName, String rowKey, String cf, String cn)
            throws IOException {

        Table table = connection.getTable(TableName.valueOf(tableName));

        // 2. get "GET" object
        Get get = new Get(Bytes.toBytes(rowKey));

        Result result = table.get(get);

        for (Cell cell : result.rawCells()) {
            System.out.println("CF->" + Bytes.toString(CellUtil.cloneFamily(cell)) +
                    "CN->" + Bytes.toString(CellUtil.cloneQualifier(cell)) +
                    "Value->" + Bytes.toString(CellUtil.cloneValue(cell)));
        }
    }
  • 方式二：指定到ColumnFamily
    public static void getData(String tableName, String rowKey, String cf, String cn)
            throws IOException {

        Table table = connection.getTable(TableName.valueOf(tableName));

        // 2. get "Get" Object
        Get get = new Get(Bytes.toBytes(rowKey));

        // 3. 指定到列族
        Get get1 = get.addFamily(Bytes.toBytes(cf));

        Result result = table.get(get1);

        for (Cell cell : result.rawCells()) {
            System.out.println("RowKey--> " + Bytes.toString(CellUtil.cloneRow(cell))
             + "Column Family--> " + Bytes.toString(CellUtil.cloneFamily(cell))
             + "CN--> " + Bytes.toString(CellUtil.cloneFamily(cell))
             + "Value--> " + Bytes.toString(CellUtil.cloneValue(cell)));
        }

        table.close();
    }
  • 方式三：指定到列：
    public static void getData(String tableName, String rowKey, String cf, String cn)
            throws IOException {

        Table table = connection.getTable(TableName.valueOf(tableName));

        Get get = new Get(Bytes.toBytes(rowKey));

        Get get1 = get.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));

        Result result = table.get(get1);

        for (Cell cell : result.rawCells()) {
            System.out.println("RK--> " + Bytes.toString(CellUtil.cloneRow(cell))
             + "CF--> " + Bytes.toString(CellUtil.cloneFamily(cell))
             + "CN--> " + Bytes.toString(CellUtil.cloneQualifier(cell))
             + "Value--> " + Bytes.toString(CellUtil.cloneValue(cell)));
        }
        
        table.close();
    }
scan:

仅需传一个参数即可TableName
删除操作：

限定保存两个版本的数据，即使两条数据在同一个内存中，在flush后也不会被删除，两个版本的数据均存在。
在命令行中无法做到删除单个版本，即使该列族指定了多个版本，在命令行中只能全删除。
删除操作

  • 指定rowkey删除：
    public static void delete(String tableName, String rowKey, String cf, String cn) throws IOException {

        // 1. 获取到表对象
        Table table = connection.getTable(TableName.valueOf(tableName));

        // 2. get delete object
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        // 3. 执行删除操作
        table.delete(delete);

        table.close();

    }

该操作能杀出指定rowkey的数据。

addColumns and addColumn问题：
删除操作使用指定到列名：

    public static void delete(String tableName, String rowKey, String cf, String cn) throws IOException {

        // 1. 获取到表对象
        Table table = connection.getTable(TableName.valueOf(tableName));

        // 2. get delete object
        Delete delete = new Delete(Bytes.toBytes(rowKey));

		delete.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));  ///

        // 3. 执行删除操作
        table.delete(delete);

        table.close();

    }

利用delete.addColumns(Bytes.toBytes(cf), Bytes.toBytes(cn));将会删除所有的版本数据，并不会保留任何，删除数据时建议使用这种，对于默认一个版本的列族删除数据不会出现任何问题；
利用delete.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn))删除数据，假设在同一cell下put了两个不同的数据，版本数为1，将会进行覆盖，假设还没达到刷写的条件，所以两个数据都在内存中，指定删除后，只会删除最新版本的数据，查看数据时将会出现老版本的数据，从而出现了错误，正是因为Hbase使用时间戳作为数据的标识导致的错误，所以在删除单个版本的数据建议使用addColumns

指定列族删除
添加：delete.addFamily(Bytes.toBytes(cf));
注：在命令行中无法实现列族的删除。

删除操作总结：

  • 指定到rowkey：删除标记：deleteFamily，删除所有版本
  • 指定到rowkey + ColumnFamily：只能在API中实现，删除标记：deleteFamily，删除所有的版本，可以指定时间戳，指定后删除时间戳小于等于指定时间戳的所有数据。
  • 指定到rowkey + columnFamily + cn：指定到列：
    • addColumns()：删除指定列的所有版本，传时间戳后删除小于等于该时间戳的所有数据，删除标记：DeleteColumn
    • addColumn()：删除的是单个版本，不传时间戳删除最新版的数据，指定时间戳后删除指定时间戳的数据，删除标记：delete，问题比较大，覆盖数据删除最新版，不应该出现的数据会出来，尽量少用，或者建表的时候尽量用一个版本，或者使用多个版本不能和该删除操作结合用。

与Mapreduce进行整合

作为Hbase 的分析引擎。
MapReduce读取Hbase的数据，所以为Hadoop应该有Hbase的jar包。

环境变量的配置：

/etc/profile：添加
export HBASE_HOME=/home/moudel/hbase-1.3.1
export HADOOP_HOME=/home/moudel/hadoop-2.7.3

/home/moudel/hadoop-2.7.3/etc/hadoop/hadoop-env.sh:
export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/home/moudel/hbase-1.3.1/lib/*

官方案例一：
统计表中数据行数：rowcounter

{$HADOOP_HOME}/bin/hadoop jar {$HBASE_HOME}/lib/hbase-server-1.3.1.jar rowcounter stu3

官方案例二：
将本地文件上传到hdfs中，将hdfs中的文件保存到hbase的表格中。

{$HADOOP_HOME}/bin/yarn jar{$HBASE_HOME}/lib/hbase-server-1.3.1.jar importtsv -Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:color fruit hdfs://Hadoop104:9000/fruit.tsv

自定义样例：利用MR向Hbase中写入数据
代码：

// Driver
package com.tommy.mapred1;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.io.LongWritable;
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 org.apache.hadoop.util.ToolRunner;

public class FruitDriver implements Tool {

    // 定义一个Configuration
    private Configuration configuration = null;

    @Override
    public int run(String[] args) throws Exception {

        // get job
        Job job = Job.getInstance(configuration);

        // set jar path
        job.setJarByClass(FruitDriver.class);

        // set mapper's K V
        job.setMapperClass(FruitMapper.class);
        job.setMapOutputKeyClass(LongWritable.class);
        job.setMapOutputValueClass(Text.class);

        // set reducer class
        TableMapReduceUtil.initTableReducerJob(args[1], FruitReducer.class, job);

        // set input params
        FileInputFormat.setInputPaths(job, new Path(args[0]));


        // commit job
        boolean b = job.waitForCompletion(true);

        return b ? 0 : 1;
    }

    @Override
    public void setConf(Configuration conf) {
        configuration = conf;
    }

    @Override
    public Configuration getConf() {
        return configuration;
    }

    public static void main(String[] args) {

        try {
            Configuration configuration = new Configuration();
            int run = ToolRunner.run(configuration, new FruitDriver(), args);

            System.exit(run);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


// Mapper
package com.tommy.mapred1;

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

import java.io.IOException;

public class FruitMapper extends Mapper<LongWritable, Text, LongWritable, Text> {

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        context.write(key, value);
    }
}


// Reducer
package com.tommy.mapred1;

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 FruitReducer extends TableReducer<LongWritable, Text, NullWritable> {

    @Override
    protected void reduce(LongWritable key, Iterable<Text> values, Context context) throws IOException, InterruptedException {

        // 遍历values: 1001 apple red
        for (Text value : values) {

            // 获取每一行的数据
            String[] split = value.toString().split("\t");

            // create Put 没有空参构造
            Put put = new Put(Bytes.toBytes(split[0]));

            // set value to put obj
            put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes(split[1]));
            put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("color"), Bytes.toBytes(split[2]));

            // write
            context.write(NullWritable.get(), put);
        }
    }
}

自定义样例：从Hbase中读取数据写入Hbase的另一张表中：

// Driver
package com.tommy.mapred2;

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.mapreduce.Job;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class Fruit2Driver implements Tool {

    private Configuration conf = null;

    @Override
    public int run(String[] args) throws Exception {

        Configuration conf = new Configuration();

        // 1.get job
        Job job = Job.getInstance(conf);

        // set main Loc
        job.setJarByClass(Fruit2Driver.class);

        // set Mapper && output KV
        // params:  table_name, new Scan(), mapper.class, K_type.class, V_type.class, job
        TableMapReduceUtil.initTableMapperJob(
                "fruit1",
                new Scan(),
                Fruit2Mapper.class,
                ImmutableBytesWritable.class,
                Put.class,
                job
        );

        // set reducer && output table  利用工具类
        // params:  outputTableName, reducer.class, job
        TableMapReduceUtil.initTableReducerJob(
                "fruit2",
                Fruit2Reducer.class,
                job
        );

        // submit job
        boolean result = job.waitForCompletion(true);

        return result ? 0 : 1;
    }

    @Override
    public void setConf(Configuration configuration) {
        conf = configuration;
    }

    @Override
    public Configuration getConf() {
        return conf;
    }

    public static void main(String[] args) {

        try {
//            Configuration conf = new Configuration();
            Configuration configuration = HBaseConfiguration.create();
            ToolRunner.run(configuration, new Fruit2Driver(), args);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// Reducer
package com.tommy.mapred2;

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 Fruit2Reducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {

    @Override
    protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context) throws IOException, InterruptedException {

        for (Put value : values) {   // MR对Java迭代器的优化：每次的对象存储于同一个地址，
            // BeanUtil提供相关的迭代器拷贝当前Reducer对象
            context.write(NullWritable.get(), value);
        }
    }
}

/mapper的注解：
mapper是从Hbase中读取数据，故要继承自TableMapper而并非Mapper，此时输入的泛型已经指定，输出的泛型需要自定义，输出的泛型：ImmutableBytesWritable代表的是RowKey，Put指的是封装好的结果类型，提前在Mapper中封装好，防止在Reducer中负载过大。Put中需要指定行键Put put = new Put(key.get());

Reducer中指定的三个泛型：
三个指定的泛型：

public abstract class TableReducer<KEYIN, VALUEIN, KEYOUT> extends Reducer<KEYIN, VALUEIN, KEYOUT, Mutation> {
    public TableReducer() {
    }
}

其中最后一个泛型是指定好的：Mutation，代表的是抽象类，其实现方法为：
在这里插入图片描述
因为最终输出的位置时Hbase所以在这利用Reducer的子类TableReducer进行定义。
由于最终的输出位置是指定的，所以就不需要用户自定义输出的value类型了。
同理可理解Mapper中的泛型机制，如果对于Mapper而言的输入数据来自于Hbase表格，需要继承Mapper的子类而并非TableMapper，从而输入数据的泛型也是同样给指定好的。

// Mapper

package com.tommy.mapred2;

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 Fruit2Mapper extends TableMapper<ImmutableBytesWritable, Put> {

    // read from hbase---> ImmutableBytesWritable, Put

    @Override
    protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {

        Put put = new Put(key.get());

        // 对象的封装在mapper完成
        for (Cell cell : value.rawCells()) {
            if ("name".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))) {
                put.add(cell);
            }
        }
        context.write(key, put);
    }
}

注解：
在本地运行时，使用Hbase的Configuration：HBaseConfiguration，加载本地的配置文件，从而在本地访问到集群。
将配置文件hbase-site.xml放到resources目录下，本地运行会利用此配置文件实现连接。
要想在集群中运行jar包，首先要把hbase导入到hadoop的环境变量中，在本地模式下则不需要进行此步骤，因为在本地模式下用maven导入hbase的client和server依赖jar中已经包含了运行MR的所有配置，既hbase的这两个依赖jar中包含hadoop相关配置信息。

devtommy
关注
HBase的Java API操作
qq_40078490的博客
07-31 2492
HBase的Java API操作代码，实现增删改查，过滤功能
（简单易懂）hbase——JavaApi
weixin_58184269的博客
04-10 2792
批量导入本机数据student.txt。
Hbase Java API
11-20
HBase是Hadoop的数据库，能够对大数据提供随机、实时读写访问。他是开源的，分布式的，多版本的，面向列的，存储模型。
HBase java API实践
m0_37549390的博客
01-19 2260
HBase java API实践依赖动手实践 依赖 hbase选择0.94.10版本，hadoop-common选择0.22.0版本，两个依赖包版本要适配，其他版本可能存在兼容问题 <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase</artifactId> <version
HBase Java Api
qq_42933029的博客
11-29 946
任务目标 1.了解HBase语言的基本语法 2.了解HBase开发的原理 3.了解HBase Java API的使用 相关知识 HBase与Hadoop一样，都是用Java编写的，所以HBase对Java支持是必须的，HBase Java API核心类介绍如下： 1.HBaseConfiguration类 HBaseConfiguration是每一个HBase Client都会使用到的对象，它代表...
【HBase】——Java API
qq_42000631的博客
01-03 395
HBase Java API
HBase——java API操作
zhuzi51的专栏
10-28 171
楔子 hbase java操作 import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; import org.apache.ha...
HBase Java API编程实践
actionbean的博客
11-27 2617
在弹出的“JAR Selection”界面中（如下图所示），进入到“/usr/local/hbase/lib”目录，选中该目录下的所有jar文件，一共有111个jar文件（注意，不要选中ruby目录），然后，点击界面底部的“确定”按钮。然后，如下图所示，点击界面中的运行图标右侧的“倒三角”，在弹出的菜单中选择“Run As”，再在弹出的菜单中点击“1 Java Application”，开始运行程序。然后可以看到jar包都添加进去了，再点击界面（如下图所示）底部的“Finish”按钮。
HBase——常用的Java API
Devin
04-24 2482
与HBase数据存储管理相关的java API主要包括：HBaseConfiguration、HTableDescriptor、HColumnDescriptor、Put、Get、ResultScanner、Result、Scan。以下讲解这些类的功能与常用方法。（1）   Adminpublic interface Admin，是一个接口，必须通过调用Connection.getAdmin()方...
Hbase笔记 —— 利用JavaAPI的方式操作Hbase数据库（往hbase的表中批量插入数据）.pdf
12-16
在本文档中，我们将深入探讨如何使用Java API与HBase数据库进行交互，特别是关于如何创建表、修改表结构以及批量插入数据。HBase是Apache的一个分布式、可扩展的大数据存储系统，它基于谷歌的Bigtable设计，适用于...
初学Hadoop——HBase Java API的使用
qq_45154565的博客
10-20 1236
使用Eclipse编写java程序，来对HBase数据库进行增删改查等操作，Eclipse可以在Ubuntu软件中心搜索下载并安装。 一、 启动hadoop和hbase start-dfs.sh start-hbase.sh 二、新建Java工程和项目（文件） 在eclipse中新建Java工程和项目（文件） （1）新建java工程 （2） 新建java class文件 右击工程->new->class 三、 在工程中导入外部jar包 这里只需要导入hbase安装目录中的lib文
HBase 系列（六）——HBase Java API 的基本使用
黑白影的博客
06-07 760
一、简述 截至到目前(2019.04)，HBase 有两个主要的版本，分别是1.x 和 2.x ，两个版本的Java API有所不同，1.x 中某些方法在2.x中被标识为@deprecated过时。所以下面关于API的样例，我会分别给出1.x和2.x两个版本。完整的代码见本仓库： Java API 1.x Examples Java API 2.x Examples 同时你使用的客户端的版...
Hbase与JAVA API实验报告
weixin_44919491的博客
10-11 1391
一、安装HBase 在start-hbase.Sh中添加一行export JAVA_HOME=/usr。。。。。。 配置环境变量 使用vi命令进入~/.bashrc 更改配置 经检查hbase安装成功 配置Java环境变量 用vi编辑hbase-env.sh 二、编程实践 create Describe Put Get delete deleteall 三、JAVA实例 import org.apache.hadoop.conf.Configuration;import org.a
FlinkSql读取外部Mysql和HBase数据库的方法(scala)
inori1256的博客
11-04 497
在flinkSQL中，我建立一张虚拟表person，然后在字段列表中，每一个字段名的数据类型都必须和MySQL中源数据的数据类型相匹配，否则会报错。指定登录MySQL用户的账号和密码，我这边为了方便使用的是root用户，实际使用时不能使用root。要保证该用户有读取你指定的那张表的权限。指定 HBase 使用的 ZooKeeper 集群的地址和端口。指定使用的连接器类型，这里是 HBase 的版本 2.2。指定所要连接的MySQL服务器地址以及库名。指定在 HBase 中要访问的表的名称。
【大数据学习 | HBASE】habse的表结构
2301_80912559的博客
11-05 497
首先我们先要知道，hbase的表的数据操作分为两个类型，一个是put一个是delete，put是更新或者插入新的数据都使用这个命令它会自己覆盖数据，delete是删除数据，hbase的底层数据存储是hdfs，hdfs中的数据是不允许我们随意的进行操作和修改的，那么我们的所有操作都必须要先放入到自己的内存中然后在将数据写出到hdfs中，和hdfs中的数据进行合并处理，所以我们在hbase中真正存储的数据并不是按照表的样子进行存储的，底层是按照k-v类型存储到hbase中的，并且写出到hdfs中。
【大数据学习 | HBASE】hbase的整体架构
最新发布
2301_80912559的博客
11-06 596
​ 当memstore写数据达到设定的阈值之后，会将数据溢写到hdfs，即storefile，内部存储hfile。，一个Region里包含一个或者多个Store，由此在设计cf时，尽量将同一系列的数据存在一个列族中，便于同一系列的数据都存在同一个region中。，其中一个表会由一个regionserver进行管理，这样压力都会集中在一个regionserver中，并且查询速度会比较慢，那么。，它是表的一部分数据，可以分散到不同的regionserver中进行管理，hbase的region存储原理图。
Hadoop：单节点配置YARN
m0_37559973的博客
11-06 298
Hadoop YARN（Yet Another Resource Negotiator）是Hadoop的资源管理层，负责管理和分配集群中应用程序的资源。
WPF使用prism框架发布订阅实现消息提示
xll的博客
11-03 307
我们在使用wpf中自带的消息提示弹出框MessageBox.Show()十分笨拙，那么怎么去使用prism框架的发布订阅去实现消息提示呢？
HBase Java API实战：1.x vs 2.x
在HBase的Java API中，我们首先需要理解的是HBase的两个主要版本——1.x和2.x，它们的API存在一些不同。1.x版本的一些方法在2.x中已被标记为过时。因此，在使用Java API时，我们需要根据实际部署的HBase版本来选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值