HBase之数据操作及自定义元数据存储

已于 2023-12-27 15:04:03 修改
阅读量438 收藏 8
点赞数 10
文章标签： java 服务器 hbase
于 2023-12-27 15:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57190466/article/details/135216536
版权

一、配置

1、HBase版本

2.5.6

2、springboot依赖
<!-- jpa 依赖-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
   <version>2.7.4</version>
</dependency>
<!-- lombok 依赖-->
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <version>1.18.24</version>
   <optional>true</optional>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.30</version>
</dependency>
<dependency>
   <groupId>org.apache.hbase</groupId>
   <artifactId>hbase-client</artifactId>
   <version>2.5.6</version> <!-- 替换为你使用的 HBase 版本 -->
</dependency>
3、yml配置 
spring:
  datasource:
    mysql-main:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://XXXXXX:3306/metadate?useUnicode=true&characterEncoding=utf-8
      username: root
      password: XXXXXX

请根据自身需要替换XXXXXX

4、HBase配置类Config 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Configuration;

@org.springframework.context.annotation.Configuration
public class HBaseConfig {

    @Bean
    public Connection hbaseConnection() throws Exception {
        Configuration config = HBaseConfiguration.create();
        // 配置 HBase 连接信息，例如 ZooKeeper 地址等
        config.set("hbase.zookeeper.quorum", "node1");

        return ConnectionFactory.createConnection(config);
    }
}

二、实体类

1、实体类
 （1）namespace
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "namespace")
public class HbaseNamespaceEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="id")
    private Long id;

    @Column(name="namespace",unique = true)
    private String namespace;

    @Column(name="owner")
    private String owner;
}
（2） table
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "hbasetable")
public class HbaseTableEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="id")
    private Long id;

    @Column(name="name")
    private String name;

    @Column(name="owner")
    private String owner;

    @Column(name="nid")
    private Long nid;

}
 （3） columnfamilies
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "columnfamilies")
public class HbaseColumnfamiliesEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="id")
    private Long id;

    @Column(name="family")
    private String family;

    @Column(name="tid")
    private Long tid;
}
（4）column
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "hbasecolumn")
public class HbaseColumnEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="id")
    private Long id;

    @Column(name="rowkey")
    private String rowkey;

    @Column(name="name")
    private String name;

    @Column(name="fid")
    private Long fid;
}
2、 Repository接口
（1）namespace
import com.example.hivestart.entity.Hbase.HbaseNamespaceEntity;
import com.example.hivestart.entity.Hbase.HbaseTableEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface HbaseNamespaceEntityRepository extends JpaRepository<HbaseNamespaceEntity,Integer> {
    HbaseNamespaceEntity findByNamespace(String namespace);
}
（2）table 
import com.example.hivestart.entity.Hbase.HbaseTableEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface HbaseTableEntityRepository extends JpaRepository<HbaseTableEntity,Integer> {
    HbaseTableEntity findByName(String name);
    boolean deleteById(long id);
}
 （3）columnfamilies
import com.example.hivestart.entity.Hbase.HbaseColumnfamiliesEntity;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface HbaseColumnfamiliesEntityRepository extends JpaRepository<HbaseColumnfamiliesEntity,Integer> {
    HbaseColumnfamiliesEntity findByFamily(String family);
    List<HbaseColumnfamiliesEntity> findByTid(long tid);
    boolean deleteById(long id);
}
（4）column 
import com.example.hivestart.entity.Hbase.HbaseColumnEntity;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface HbaseColumnEntityRepository extends JpaRepository<HbaseColumnEntity,Integer> {
    HbaseColumnEntity findByNameAndFidAndRowkey(String name,long fid,String rowkey);
    boolean deleteById(long id);
    List<HbaseColumnEntity> findByFid(long familiyId);
}

三、操作

1、Namespace
 （1）创建
//创建命名空间
@PostMapping("/createNamespace")
public String createNamespace(@RequestParam String namespace) throws IOException {
    //TODO:需要登录获取用户
    String owner="root";
    boolean serviceNamespace = hbaseService.createNamespace(namespace,owner);
    if (serviceNamespace){
        HbaseNamespaceEntity namespaceEntity=new HbaseNamespaceEntity();
        namespaceEntity.setNamespace(namespace);
        namespaceEntity.setOwner(owner);
        namespaceEntityRepository.save(namespaceEntity);
        return "创建成功";
    }else {
        return "创建失败";
    }
}

Service方法

/**
 * 创建命名空间
 *
 * @param namespace 命名空间名称
 */
public boolean createNamespace(String namespace,String owner) throws IOException {
    // 1. 获取 admin
    // 此处的异常先不要抛出 等待方法写完 再统一进行处理
    // admin 的连接是轻量级的 不是线程安全的 不推荐池化或者缓存这个连接
    Admin admin = hbaseConnection.getAdmin();
    // 2. 调用方法创建命名空间
    // 代码相对 shell 更加底层 所以 shell 能够实现的功能 代码一定能实现
    // 所以需要填写完整的命名空间描述
    // 2.1 创建命令空间描述建造者 => 设计师
    NamespaceDescriptor.Builder builder = NamespaceDescriptor.create(namespace);
    // 2.2 给命令空间添加需求
    builder.addConfiguration("owner", owner);
    // 2.3 使用 builder 构造出对应的添加完参数的对象 完成创建
    // 创建命名空间出现的问题 都属于本方法自身的问题 不应该抛出
    try {
        admin.createNamespace(builder.build());
        // 3. 关闭 admin
        admin.close();
        return true;
    } catch (IOException e) {
        System.out.println("命令空间已经存在");
        admin.close();
        e.printStackTrace();
        return false;
    }

}
2、数据表
 （1）创建
//创建数据表
    @PostMapping("/createTable")
    public String initializeHBaseTable(@Valid @RequestBody CreateHbaseTableModel createHbaseTableModel) {
        //TODO:需要登录获取用户
        String owner="root";
        try{
            String namespace = createHbaseTableModel.getNamespace();
            String tableName = createHbaseTableModel.getTableName();
            String[] columnFamilies = createHbaseTableModel.getColumnFamilies();
            boolean table = hbaseService.createTable(namespace, tableName, columnFamilies);
            if (table){
                //TODO:判断该namespace是否有表存在
                boolean exists = hbaseService.tableExists(tableName);
                if (!exists) {
                    //保存数据表
                    HbaseTableEntity tableEntity = new HbaseTableEntity();
                    tableEntity.setName(tableName);
                    tableEntity.setOwner(owner);
                    tableEntity.setNid(namespaceEntityRepository.findByNamespace(namespace).getId());
                    tableEntityRepository.save(tableEntity);
                    //保存列族
                    for (int i = 0; i < columnFamilies.length; i++) {
                        HbaseColumnfamiliesEntity hbaseColumnfamiliesEntity = new HbaseColumnfamiliesEntity();
                        hbaseColumnfamiliesEntity.setFamily(columnFamilies[i]);
                        hbaseColumnfamiliesEntity.setTid(tableEntityRepository.findByName(tableName).getId());
                        columnfamiliesEntityRepository.save(hbaseColumnfamiliesEntity);
                    }

                    return "Table create to HBase successfully!";
                }
                else{
                    return "Error checking table existence.";
                }
            }else {
                return "Error create Table to HBase.";
            }
        } catch (IOException e) {
            e.printStackTrace();
            return "Error create Table to HBase.";
        }
    }

 Service方法

    //创建数据表
    public boolean createTable(String namespace, String tableName, String[] columnFamilies) throws IOException {
        // 1.获取 admin
        Admin admin = hbaseConnection.getAdmin();
        TableName hTableName = TableName.valueOf(namespace, tableName);
        HTableDescriptor tableDesc = new HTableDescriptor(hTableName);
        // 判断是否有至少一个列族
        if (columnFamilies.length == 0) {
            System.out.println("创建表格至少有一个列族");
            return false;
        }
        // 判断表格是否存在
        if (admin.tableExists(hTableName)) {
            System.out.println("表格已经存在");
            return false;
        }
        for (String CF : columnFamilies) {
            HColumnDescriptor columnFamily = new HColumnDescriptor(CF);
            tableDesc.addFamily(columnFamily);
        }
        admin.createTable(tableDesc);
        admin.close();
        return true;
    }
（2）删除
//删除数据表
    @DeleteMapping("/deleteTable")
    public String deleteTable(@RequestParam String namespace,@RequestParam String tableName) throws IOException {
        hbaseService.deleteTable(namespace,tableName);
        Long tableId = tableEntityRepository.findByName(tableName).getId();
        List<HbaseColumnfamiliesEntity> columnfamilies = columnfamiliesEntityRepository.findByTid(tableId);
        for (int i=0;i<columnfamilies.size();i++){
            List<HbaseColumnEntity> column = columnEntityRepository.findByFid(columnfamilies.get(i).getId());
            for(int j=0;j<column.size();j++){
                columnEntityRepository.deleteById(column.get(j).getId());
            }
            columnfamiliesEntityRepository.deleteById(columnfamilies.get(i).getId());
        }
        boolean deletetableById = tableEntityRepository.deleteById(tableId);
        if (deletetableById){
            return "删除成功";
        }else {
            return "删除失败";
        }
    }

Service方法 

//删除数据表
    public void deleteTable(String namespace, String tableName) throws IOException {
        try (Admin admin = hbaseConnection.getAdmin()) {
            TableName table = TableName.valueOf(namespace,tableName);

            if (admin.tableExists(table)) {
                // Disable and delete the table
                admin.disableTable(table);
                admin.deleteTable(table);

                System.out.println("Table " + tableName + " deleted successfully.");
            } else {
                System.out.println("Table " + tableName + " does not exist.");
            }
        }
    }
（3） 判断数据表是否存在
    //数据表是否存在
    @GetMapping("/tableExists")
    public String tableExists(@RequestParam String tableName) {
        try {
            boolean exists = hbaseService.tableExists(tableName);
            return "Table " + tableName + " exists: " + exists;
        } catch (IOException e) {
            e.printStackTrace();
            return "Error checking table existence.";
        }
    }

Service方法 

    // 获取表的元数据
    public void getTableMetadata(String tableName) throws IOException {
        Admin admin = hbaseConnection.getAdmin();
        TableName table = TableName.valueOf(tableName);

        if (admin.tableExists(table)) {
            HTableDescriptor tableDescriptor = admin.getTableDescriptor(table);

            // 获取表名
            System.out.println("Table Name: " + tableDescriptor.getTableName());

            // 获取列族信息
            for (HColumnDescriptor columnDescriptor : tableDescriptor.getColumnFamilies()) {
                System.out.println("Column Family: " + columnDescriptor.getNameAsString());
            }
        } else {
            System.out.println("Table does not exist: " + tableName);
        }
    }
 （4）获取数据表元数据
    //获取数据表元数据
    @GetMapping("/getTableMetadata")
    public void getTableMetadata(@RequestParam String tableName) throws IOException {
        hbaseService.getTableMetadata(tableName);
    }

 Service方法

    // 获取表的元数据
    public void getTableMetadata(String tableName) throws IOException {
        Admin admin = hbaseConnection.getAdmin();
        TableName table = TableName.valueOf(tableName);

        if (admin.tableExists(table)) {
            HTableDescriptor tableDescriptor = admin.getTableDescriptor(table);

            // 获取表名
            System.out.println("Table Name: " + tableDescriptor.getTableName());

            // 获取列族信息
            for (HColumnDescriptor columnDescriptor : tableDescriptor.getColumnFamilies()) {
                System.out.println("Column Family: " + columnDescriptor.getNameAsString());
            }
        } else {
            System.out.println("Table does not exist: " + tableName);
        }
    }
3、数据
（1）插入数据
    //插入数据
    @PostMapping("/insertData")
    public String putCell(@Valid @RequestBody InsertHbaseDateModel insert){
        try{
            boolean putCell = hbaseService.putCell(insert.getNamespace(), insert.getTableName(), insert.getRowKey(), insert.getColumnFamily(), insert.getColumnName(), insert.getValue());
            if (putCell){
                HbaseColumnEntity hbaseColumnEntity=new HbaseColumnEntity();
                hbaseColumnEntity.setRowkey(insert.getRowKey());
                hbaseColumnEntity.setName(insert.getColumnName());
                hbaseColumnEntity.setFid(columnfamiliesEntityRepository.findByFamily(insert.getColumnFamily()).getId());
                columnEntityRepository.save(hbaseColumnEntity);
                return "Table Insert Data to Table successfully!";
            }else {
                return "Table Insert Data to Table successfully!";
            }
        } catch (IOException e) {
            e.printStackTrace();
            return "Error Insert Data to Table.";
        }

    }

Service方法


    /**
     * 插入数据
     *
     * @param namespace    命名空间名称
     * @param tableName    表格名称
     * @param rowKey       主键
     * @param columnFamily 列族名称
     * @param columnName   列名
     * @param value        值
     */
    public boolean putCell(String namespace, String tableName, String rowKey, String columnFamily, String columnName, String value) throws IOException {
        // 1. 获取 table
        Table table = hbaseConnection.getTable(TableName.valueOf(namespace, tableName));
        // 2. 调用相关方法插入数据
        // 2.1 创建 put 对象
        Put put = new Put(Bytes.toBytes(rowKey));
        // 2.2. 给 put 对象添加数据
        put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnName), Bytes.toBytes(value));
        // 2.3 将对象写入对应的方法
        try {
            table.put(put);
            // 3. 关闭 table
            table.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            // 3. 关闭 table
            table.close();
            return false;
        }

    }
（2）扫描数据
    // 扫描数据
    @GetMapping("/scanRows")
    public void scanRows(@Valid @RequestBody ScanRowsModel scan) throws IOException {
        hbaseService.scanRows(scan.getNamespace(),scan.getTableName(),scan.getStartRow(),scan.getStopRow());
    }

Service方法 

    /**
     * 扫描数据
     *
     * @param namespace 命名空间
     * @param tableName 表格名称
     * @param startRow  开始的 row 包含的
     * @param stopRow   结束的 row 不包含
     */
    public void scanRows(String namespace, String tableName, String startRow, String stopRow) throws IOException {
        // 1. 获取 table
        Table table = hbaseConnection.getTable(TableName.valueOf(namespace, tableName));
        // 2. 创建 scan 对象
        Scan scan = new Scan();
        // 如果此时直接调用 会直接扫描整张表
        // 添加参数 来控制扫描的数据
        // 默认包含
        scan.setStartRow(Bytes.toBytes(startRow));
        // 默认不包含
        scan.setStopRow(Bytes.toBytes(stopRow));
        try {
            // 读取多行数据 获得 scanner
            ResultScanner scanner = table.getScanner(scan);
            // result 来记录一行数据 cell 数组
            // ResultScanner 来记录多行数据 result 的数组
            for (Result result : scanner) {
                Cell[] cells = result.rawCells();
                for (Cell cell : cells) {
                    System.out.print(new String(CellUtil.cloneRow(cell)) + "-" + new String(CellUtil.cloneFamily(cell)) + "-" + new String(CellUtil.cloneQualifier(cell)) + "-" + new String(CellUtil.cloneValue(cell)) + "\t");
                }
                System.out.println();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 3. 关闭 table
        table.close();
    }
（3）读取数据
    //读取数据 读取对应的一行中的某一列
    @GetMapping("/getCells")
    public String getCells(@Valid @RequestBody GetCellHbaseModel getCell) throws IOException {
        String cells = hbaseService.getCells(getCell.getNamespace(), getCell.getTableName(), getCell.getRowKey(), getCell.getColumnFamily(), getCell.getColumnName());
        return cells;
    }

Service方法

  /**
     * 读取数据 读取对应的一行中的某一列
     *
     * @param namespace    命名空间名称
     * @param tableName    表格名称
     * @param rowKey       主键
     * @param columnFamily 列族名称
     * @param columnName   列名
     */
    public String getCells(String namespace, String tableName, String rowKey, String columnFamily, String columnName) throws IOException {
        String save = "";
        // 1. 获取 table
        Table table = hbaseConnection.getTable(TableName.valueOf(namespace, tableName));
        // 2. 创建 get 对象
        Get get = new Get(Bytes.toBytes(rowKey));
        // 如果直接调用 get 方法读取数据 此时读一整行数据
        // 如果想读取某一列的数据 需要添加对应的参数
        get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnName));
        // 设置读取数据的版本
        get.getMaxVersions();
        try {
            // 读取数据 得到 result 对象
            Result result = table.get(get);
            // 处理数据
            Cell[] cells = result.rawCells();
            // 测试方法: 直接把读取的数据打印到控制台
            // 如果是实际开发 需要再额外写方法 对应处理数据
            for (Cell cell : cells) {
                // cell 存储数据比较底层
                String value = new String(CellUtil.cloneValue(cell));
                System.out.println(value);
                save = value;
            }

            // 关闭 table
            table.close();
            return save;
        } catch (IOException e) {

            // 关闭 table
            table.close();
            e.printStackTrace();
            return save;
        }
    }
（4）删除数据
    //删除 column 数据
    @DeleteMapping("/deleteColumn")
    public  String deleteColumn(@Valid @RequestBody GetCellHbaseModel getCell) throws IOException {
        boolean b = hbaseService.deleteColumn(getCell.getNamespace(), getCell.getTableName(), getCell.getRowKey(), getCell.getColumnFamily(), getCell.getColumnName());
        if (b){
            boolean b1 = columnEntityRepository.deleteById(columnEntityRepository.findByNameAndFidAndRowkey(getCell.getColumnName(), columnfamiliesEntityRepository.findByFamily(getCell.getColumnFamily()).getId(), getCell.getRowKey()).getId());
            if (b1){
                return "删除成功";
            }else {
                return "删除失败";
            }
        }else {
            return "删除失败";
        }
    }

Service方法 

    /**
     * 删除 column 数据
     *
     * @param nameSpace
     * @param tableName
     * @param rowKey
     * @param family
     * @param column
     * @throws IOException
     */
    public boolean deleteColumn(String nameSpace, String tableName, String rowKey, String family, String column) throws IOException {
        // 1.获取 table
        Table table = hbaseConnection.getTable(TableName.valueOf(nameSpace, tableName));
        // 2.创建 Delete 对象
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        // 3.添加删除信息
        // 3.1 删除单个版本

        delete.addColumn(Bytes.toBytes(family), Bytes.toBytes(column));
        // 3.2 删除所有版本
        delete.addColumns(Bytes.toBytes(family), Bytes.toBytes(column));
        // 3.3 删除列族
        // delete.addFamily(Bytes.toBytes(family));
        // 3.删除数据
        table.delete(delete);
        // 5.关闭资源
        table.close();
        return true;
    }

 四、总结

代码还有很多不完善的地方，有些内容还存在问题，后续需继续完善

Good_Night!
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HBase数据存储
我们的征途是星辰大海
08-01 1909
HRegionServer HBase的数据文件都存储在HDFS上，格式主要有两种: - HFile:HBase中KeyValue数据的存储格式，HFile是Hadoop的二进制文件，实际上StoreFile就是对HFile做了轻量级的包装，即StoreFile底层就是HFile - HLog File:HBase中WAL(Write Ahead Log)的存储格式，物理上是Hadoop的S
获取元数据表hbase meta和用户表信息.png
09-01
该脑图是介绍获取元数据表hbase meta和用户表信息，请贡献给大家下载！
HBase运维基础——元数据逆向修复原理
weixin_40581617的博客
05-02 343
背景     鉴于上次一篇文章——“云HBase小组成功抢救某公司自建HBase集群，挽救30+T数据”的读者反馈，对HBase的逆向工程比较感兴趣，并咨询如何使用相应工具进行运维等等。总的来说，就是想更深层理解HBase运维原理，提高运维HBase生产环境的能力，应对各种常见异常现象。不同的读者对hbase的了解程度不同，本文不打算着重编写一个工具怎么使用，而是从HBase的运维基础知识介
Hbase存储及元数据meta
youngflyer的博客
01-19 5754
Hbase的列族式存储 列族就是多个数据列的组合，列族式可以说是表的schema的一部分，而列不是。Hbase可以说是列簇数据库，在创建表的时候要指定列族，而不需要指定具体的列。 Hbase Table组成：Table = rowkey + family + column + timestamp + value 数据存储模式：(Table, rowkey , family , column , timestamp) -> Value Hbase数据存储原型 HBase 是一个稀疏的、分布式、
HBase理解
zwyoozwz的博客
06-15 1114
关于HBase
HBase介绍、架构、特点、应用场景、生态圈
weixin_74292291的博客
03-07 1046
HBase介绍，架构介绍：NoSQL和关系型数据库对比、特点、应用场景、生态圈技术
基于Django+LayUI+HBase的文献数据挖掘系统的实现
最新发布
06-13
在这个文献数据挖掘系统中，HBase作为数据存储平台，用于存储和管理大量的文献数据。由于文献数据可能包含复杂的元数据和内容，HBase的列族和行键设计能够灵活地适应这种结构，而其分布式特性保证了系统的可扩展性和...
hbase 二进制数据写入_Hbase的存储
weixin_39609423的博客
12-21 541
HBase中的每张表都通过行键按照一定的范围被分割成多个子表(HRegion)，默认一个HRegion超过256M就要被分割成两个，由HRegionServer管理，管理哪些HRegion由HMaster分配。HRegionServer存取一个子表时，会创建一个HRegion对象，然后对表的每个列族(Column Family)创建一个Store实例，每个Store都会有0个或多个StoreFil...
元数据管理Atlas预研_v0.1.docx
06-21
这通常涉及修改相关配置，如Hive的metastore配置，使得元数据操作触发Atlas的事件处理器。 总结来说，Apache Atlas是大数据环境下实现高效元数据管理的关键工具，它不仅提供了元数据的存储和查询，还实现了元数据的...
大数据-数据迁移-hive、hbase、kudu迁移
03-29
本文档详细记录了一次从自建Hadoop集群到华为云MRS（Managed Service for Big Data）的大规模数据迁移项目，涉及到了Hive、Kudu和HBase这三种不同类型的数据存储系统。以下是针对这些系统的迁移策略、流程和解决方案...
Hbase基本原理剖析
热门推荐
weixin_43114209的博客
07-21 2万+
每个Region包含了表中一段RowKey区间范围内的数据，HBase的一张数据表开始只包含一个Region，随着表中数据的增多，当一个Region的大小达到容量上限后会分裂成两个Region。为了提升数据操作的效率，HBase Client会在内存中缓存“hbase:meta”和用户表Region的信息，当应用程序发起下一次数据操作时，HBase Client会首先从内存中获取这些信息；上图 RegionServer的数据存储结构中Region的各部分的说明如表 Region结构说明所示。
详细讲解Hadoop中的一个简单数据库HBase
08-03 84
【赛迪网－IT技术报道】HBase是Hadoop中的一个简单数据库。它与Google的Bigtable特别相似，但也存在许多的不同之处。 数据模型 HBase数据库使用了和Bigtable非常相似的数据模型。用户在表格里存储许多数据行。每个数据行都包括一个可排序的关键字，和任意数目的列。表格是稀疏的，所以同一个表格里的行可能有非常不同的列，只要用户喜欢这样做。 列名是“...
Hbase的学习笔记（3）
weixin_45866849的博客
02-26 788
Hbase的学习笔记（3） 本次主要学习Hbase与Java的配合使用，即通过Java语言完成对Hbase表的增删改查。 1. 所需依赖jar包 <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-client --> <dependency> <groupId>org.apache.hadoop</groupId> <artifactId>hadoop-
HBASE元数据及数据读取过程
Searcher_Recommeder的博客
07-17 8338
一，    基于hbase0.98版本的HBASE元数据信息 查看通过 zk查看HBASE的元数据信息，可以能过目录看出来无数据信息较以前的版本有较大的改动，现在已经没有了root-region-server的信息。  Get /hbase/meta-region-server  可以看出元数据表的region在172.16.73.68:60020的region server上      
HBase基本操作命令整理
学亮编程手记
07-30 455
1、HBase Shell操作 1、通用命令 //展示regionserver的task列表 hbase(main):000:0>processlist //展示集群的状态 hbase(main):000:0>status //table命令的帮助手册 hbase(main):000:0>table_help //显示hbase的版本 hbase(main):000:0>version //展示当前hbase的用户 hbase(main):000:0>whoami 2、DDL
HBase命令行操作
2301_77843163的博客
03-31 1732
更改Student表的列族baseInfo的存储版本的限制为3（默认情况下，列族只存储一个版本的数据，如果需要存储多个版本的数据，则需要修改列族的属性。HBase数据库的命令行操作也就是通过HBase的命令行终端并通过命令的形式来操作HBase数据库，即HBase数据库的表、数据等的增删改查等操作。如果是不存在的就添加，如果存在则后运行的列族信息覆盖前运行的列族信息，。：下面将以Student表的操作为例，并且有些命令只提供示例不提供说明（有时候一例胜千言，学习是需要一定的关联、联想、抽象能力的）
Java操作Hbase 增删改查，这一篇搞定！！
lele的博客
04-15 1226
HBase是一个分布式的、面向列的开源数据库，主要用于海量数据存储。在使用HBase进行数据操作时，首先需要建立一个与HBase集群通讯的连接，然后通过该连接进行相关数据操作。在本文中，我们将介绍如何封装JavaHBase Client的Connection，以实现代码复用和简化编程。
HBase基础 --- 增删查改
qq_57151931的博客
03-07 1128
HBase增删查改
HBase入门：shell 方式数据修改和删除
u011236069的博客
11-13 5740
目录 简介： 准备： 修改数据：Put要么向表增加新行 (如果key是新的) 或更新行 (如果key已经存在) 查看数据：hbase每次put因为没有指定版本，因此理论上时可以多版本并存的 为什么只有最新的版本数据呢？查看表结构信息 调整列簇的版本数量 删除数据 删除目标1： 删除数据ID = row3的列簇liecuA中age列的数据（删除操作最小单元） 删除目标2： 删除数据ID = row3的列簇liecuA 相关数据（如果test表中有多个列...
HBase的四维数据坐标系统与存储理解
HBase 是一个分布式、开源的NoSQL数据库，主要用于大规模数据存储和处理，特别适合于大规模的高吞吐量和实时数据访问场景。它的储存模式与传统的二维关系型数据库有着显著区别，采用了独特的四维坐标系统。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值