hadoop hbase 中应用 hadoop的hbase

转载

墨染青丝 2023-07-13 17:27:01

文章标签 hadoop hbase 中应用 hadoop System apache 文章分类 Hadoop 大数据

Hbase

基本概念
物理模型
javaApi

基本概念

hadoop是基于Google 公布的 BigTable 的论文的基础上实现
Hbase全称是hadoop database，是hadoop的数据库
Hbase是基于HDFS文件系统基础上的分布式数据库适合大数据使用
Hbase是弹性存储面向列的和关系型数据库面向行不同，字段可在不修改表结构的时候		 增加字段以及值
HDFS为hbase提供了良好的底层数据存储

物理模型

Hbase的数据存储结构，有行键（rowkey）时间戳（time）列族（column family），列(column)组成。

前文说过hadoop是一个面向列存储的

示例：

行键：tom(名称)

时间戳(版本)：插入数据时自动为数据听见

列族：包含所有列键的的空间

第一个列键：age 值为 20

下方实例中每次数据修改都是新建一个新的当前时间戳，新的age列键和新的值按照最新的排列，所有不会删除数据，只会将最新的数据展示在最上面

第二个列键：address:值为bejing

第三个列键依次类推

第二个行键：第一个列键是city 值为上海

依次类推

hadoop hbase 中应用 hadoop的hbase_hadoop

当一个table达到预值时将分区分为一个Region

按行键进行分割，如果预值为3个行键达到这值是将进行分割

而多个Region被RegionServer进行管理，同一时刻RegionServer只能管理一个Region，而Region按照行键字典序排序，

Region是分布式最小的单位，Region会被负载均衡分布到不同的服务器，被RegionServer管理，Region是分布式存储的最小单位不是一个存储的最小单位，

Region是一个Store组成，每个Store保存一个列族，每个Store又由一个MemStore和多个StoreFile组成，MemStore存储在内存中，如果达到一定的存储量，就会将内存中的存储成StoreFile存储到HDFS中

当用户访问时访问zookeeper获取调用的服务器，访问RegionServer获取对应的数据，

javaApi

导入maven资源

<dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-mapreduce-client-app</artifactId>
      <version>${hadoop.version}</version>
    </dependency>
    <!--hbase-->
    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>${zk.version}</version>
    </dependency>
    <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>
  </dependencies>

package com.kgc.hbase;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mortbay.util.IO;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HBaseDemo {
    //创建数据库连接
    private static Connection connection = null;
    private static Admin admin = null;
    @Before
    public void setUp()throws Exception{
        //读取hbase配置文件
        Configuration configuration = HBaseConfiguration.create();    
//hadoop0000是在本地设置的映射，实际为连接hbaseip地址        
configuration.set("hbase.zookeeper.quorum","hadoop000:2181");
        //创建数据库连接
        connection = ConnectionFactory.createConnection(configuration);
        //Admin用来管理HBase数据库信息
        admin = connection.getAdmin();
    }

    @After
    public void tearDown()throws Exception{
        //关闭数据库连接
        admin.close();
    }




    /**
     * 查看表：list
     */
    public static void listTables ()throws Exception{
        HTableDescriptor[] listTables = admin.listTables();
        if (listTables.length>0){
            for (HTableDescriptor table : listTables) {
                System.out.println(table.getTableName()+ "\t" + table.getFamilies());
            }
        }
    }

    /**
     * 查看表结构：describe
     */
    public static void describeTable(String tableName)throws Exception{
        //获取表
        TableName tb = TableName.valueOf(tableName);
        HTableDescriptor tableDescriptor = admin.getTableDescriptor(tb);
        //
        for (HColumnDescriptor columnFamily : tableDescriptor.getColumnFamilies()) {
            System.out.println(columnFamily.getNameAsString()
                    +"\t"+columnFamily.getMaxVersions()
                    +"\t"+columnFamily.getMinVersions()
                    +"\t"+columnFamily.getBlocksize());
        }
    }

    /**
     * 创建表：
     * create '表名'，'列族1'，['列族1','列族n']
     */
    public void createTable(String tableName,String... familyNames)throws Exception{
        TableName tb = TableName.valueOf(tableName);
        //如果表事先存在，需要先删除
        if (admin.tableExists(tb)){
            //禁用表
            admin.disableTable(tb);
            //删除表
            admin.deleteTable(tb);
        }
        //表结构
        HTableDescriptor hTableDescriptor = new HTableDescriptor(tb);
        for (String familyName : familyNames) {
            hTableDescriptor.addFamily(new HColumnDescriptor(familyName));
        }
        //创建表
        admin.createTable(hTableDescriptor);
        System.out.println(tableName+"======>>>创建成功");
    }

    /**
     * 新增多条数据：put 'rowkey','列族：列修饰符','值'
     */
    public void putList(String tableName,String rowKey)throws Exception{
        Table table = connection.getTable(TableName.valueOf(tableName));

// 增加参数：String... familyNames
//        for (int i = 0; i < familyName.length; i++) {
//            familyNames[i]
//        }

        Put put1 = new Put(Bytes.toBytes(rowKey));
        put1.addColumn(Bytes.toBytes("address"),Bytes.toBytes("city"),Bytes.toBytes("ShiJiaZhuang"));
        put1.addColumn(Bytes.toBytes("address"),Bytes.toBytes("province"),Bytes.toBytes("HeBei"));

        Put put2 = new Put(Bytes.toBytes(rowKey));
        put2.addColumn(Bytes.toBytes("info"),Bytes.toBytes("age"),Bytes.toBytes("38"));
        put2.addColumn(Bytes.toBytes("info"),Bytes.toBytes("age"),Bytes.toBytes("48"));

        List list = new ArrayList();
        list.add(put1);
        list.add(put2);

        table.put(list);
    }

    /**
     * 新增一条数据：put
     */
    public void put(String tableName,String rowKey)throws Exception{
        Table table = connection.getTable(TableName.valueOf(tableName));

        Put put = new Put(Bytes.toBytes(rowKey));

        put.addColumn(Bytes.toBytes("info"),Bytes.toBytes("age"),Bytes.toBytes("18"));
        put.addColumn(Bytes.toBytes("address"),Bytes.toBytes("city"),Bytes.toBytes("BeiJing"));

        table.put(put);
    }

    /**
     * 扫描全表：scan '表名'
     * @param tableName
     * @throws IOException
     */
    public void scan(String tableName)throws IOException{
        Table tb = connection.getTable(TableName.valueOf(tableName));
        //表的扫描结果：多行数据
        ResultScanner tableResults = tb.getScanner(new Scan());
        for (Result row : tableResults) {
            for (Cell cell : row.listCells()) {
                //行键：rowKey
                String rowKey = Bytes.toString(row.getRow());
                //String rowKey = Bytes.toString(CellUtil.cloneRow(cell));

                //列族：family
                String familyName = Bytes.toString(CellUtil.cloneFamily(cell));

                //列键（列修饰符）：qualifier
                String qualifier = Bytes.toString(CellUtil.cloneQualifier(cell));

                //值：value
                String value= Bytes.toString(CellUtil.cloneValue(cell));

                System.out.println("rowKey："+rowKey
                +" column="+familyName
                +"："+qualifier
                +" value："+value);

            }
        }
    }

    /**
     * 获取数据：get '表名','rowKey'
     */
    public void getByRowKey(String tableName,String rowKey)throws IOException{
        Table table = connection.getTable(TableName.valueOf(tableName));
        //设置行键
        Get g = new Get(Bytes.toBytes(rowKey));
        //获取数据
        Result result = table.get(g);
        System.out.println(result);
    }

    /**
     * 如果不存在，相当于添加。如果存在，相当与修改。
     * 添加新的列族：alter '表名',NAME=>'列族',VERSIONS=>4
     */
    public void addColumnFamily(String tableName,String... familyNames)throws IOException{
        TableName table = TableName.valueOf(tableName);
        HTableDescriptor htd = admin.getTableDescriptor(table);
        for (String familyName : familyNames) {
            //添加列族
            htd.addFamily(new HColumnDescriptor(familyName));
        }
        //修改表结构
        admin.modifyTable(table,htd);
        System.out.println("表"+tableName+"修改成功！");
    }

    /**
     * familyNames：列族。如：address，info
     * 删除指定的列族：
     */
    public void removeColumnFamily(String tableName,String... familyNames)throws IOException{
        TableName table = TableName.valueOf(tableName);
        HTableDescriptor htd = admin.getTableDescriptor(table);
        for (String familyName : familyNames) {
            //添加列族
            htd.removeFamily(Bytes.toBytes(familyName));
        }
        //修改表结构
        admin.modifyTable(table,htd);
        System.out.println("表"+tableName+"删除成功！");
    }

    /**
     * 删除行数据
     */
    public void deleteRow(String tableName,String rowKey) throws IOException{
        Table table = connection.getTable(TableName.valueOf(tableName));
        //根据行键删除
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        table.delete(delete);
    }

    /**
     * 删除列数据
     */
    public void deleteColumn(String tableName,String rowKey,String familyName,String qualifier) throws IOException{
        Table table = connection.getTable(TableName.valueOf(tableName));
        //根据行键删除
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        //删除最近的一个版本
//        delete.addColumn(Bytes.toBytes(familyName),Bytes.toBytes(qualifier));

        //删除所有版本
        delete.addColumns(Bytes.toBytes(familyName),Bytes.toBytes(qualifier));

        table.delete(delete);
    }

    /**
     * 清空表数据，保留表结构
     */
    public void truncateTable(String tableName)throws IOException{
        TableName tb = TableName.valueOf(tableName);
        //判断表是否存在
        if (admin.tableExists(tb)){
            //禁用表
            admin.disableTable(tb);
            //清空表
            admin.truncateTable(tb,true);
            System.out.println("表"+tableName+"已清空！");
        }else {
            System.out.println("表"+tableName+"不存在！");
            System.exit(1);
        }
    }

    /**
     * 删除表数据和表结构，彻底没了
     */
    public void deleteTable(String tableName)throws IOException{
        TableName tb = TableName.valueOf(tableName);
        //判断表是否存在
        if (admin.tableExists(tb)){
            //禁用表
            admin.disableTable(tb);
            //清空表
            admin.deleteTable(tb);
            System.out.println("表"+tableName+"已删除！");
        }else {
            System.out.println("表"+tableName+"不存在！");
            System.exit(1);
        }
    }


    @Test
    public void test()throws Exception{
//        listTables();

//        describeTable("scores");

//        createTable("test_hbase","info","address");
//        describeTable("test_hbase");

//        put("test_hbase","jason");

//        putList("test_hbase","tom");
//        describeTable("test_hbase");

//        scan("test_hbase");

//        getByRowKey("test_hbase","tom");

//        addColumnFamily("test_hbase","score");
//        describeTable("test_hbase");

//        removeColumnFamily("test_hbase","score");
//        describeTable("test_hbase");

//        deleteRow("test_hbase","tom");

//        deleteColumn("test_hbase","tom","info","age");

//        truncateTable("scores");

        deleteTable("test_hbase");
    }



}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。