HBase入門詳解（二）

個人博客原文鏈接

環境：centos7+hadoop3.0.3+hbase2.0.1+jdk8

HBase開發

測試代碼準備

    Configuration conf = null;
    ExecutorService pool = null;
    Connection conn = null;
    Admin admin = null;
    Table table = null;
    HTable t = null;

    //同步獲得hbase連接
    @Before
    public void before() throws IOException {
        // 設置HBase配置信息
        conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum","hadoop5:2181");
        conf.set("hbase.master.dns.interface","hadoop5");
        pool = Executors.newFixedThreadPool(10); // 創建線程池
        conn = ConnectionFactory.createConnection(conf,pool); // 創建連接池
        admin = conn.getAdmin(); // 創建表的管理類
        System.out.println("獲取同步連接成功");
    }

    @After
    public void after() throws IOException {
        // 關閉連接
        conn.close();
        System.out.println("連接已關閉");
    }

連接HBase

1. 同步連接

    // 設置HBase配置信息
    conf = HBaseConfiguration.create();
    conf.set("hbase.zookeeper.quorum","hadoop5:2181");
    conf.set("hbase.master.dns.interface","hadoop5");
    pool = Executors.newFixedThreadPool(10); // 創建線程池
    conn = ConnectionFactory.createConnection(conf,pool); // 創建連接池
    admin = conn.getAdmin(); // 創建表的管理類
    System.out.println("獲取同步連接成功");

2. 異步連接

    //異步獲取hbase連接方式
    @Test
    public void asynctest() throws Exception {
        // 設置HBase配置信息
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", "hadoop5:2181");
        conf.set("hbase.master.dns.interface", "hadoop5");
        System.out.println("開始獲取連接");
        // 獲取異步連接對象
        CompletableFuture<AsyncConnection> aconn = ConnectionFactory.createAsyncConnection(conf);
        System.out.println("請等待");
        // 設置超時時長，單位爲毫秒
        AsyncConnection conn = aconn.get(1000,TimeUnit.MILLISECONDS);
        System.out.println("獲取異步連接成功");
        ExecutorService pool = Executors.newFixedThreadPool(2);
        AsyncAdmin admin = conn.getAdmin(pool);
        conn.close();
    }

命名空間

1. 創建命名空間

    //創建命名空間
    @Test
    public void createNS() throws IOException {
        // 創建命名空間描述類的對象，並指定命名空間的名稱
        NamespaceDescriptor des = NamespaceDescriptor.create("IMUT").build();
        // 通過表的管理類的對象創建命名空間
        admin.createNamespace(des);
        System.out.println("命名空間創建成功");
    }

2. 刪除命名空間

    //刪除命名空間
    @Test
    public void deleteNS() throws IOException {
        // 通過表的管理類的對象刪除指定的命名空間
        // 需要先清空命名空間所有表
        admin.deleteNamespace("IMUT");
        System.out.println("命名空間刪除成功");
    }

創建表

1. 同步創建表

    //同步創建表
    @Test
    public void createTBSync() throws Exception{
        // 創建表的描述類的Builder，HTableDescriptorBuilder
        // 設置表名
        TableDescriptorBuilder tbbuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("IMUT:employee_sync"));
        // 創建列族的描述類的Builder，ColumnFamilyDescriptorBuilder
        // 設置列族名
        ColumnFamilyDescriptorBuilder cfbuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("baseinfo"));
        // 設置該列族的屬性=>最大版本數爲10
        cfbuilder.setMaxVersions(10);
        // 通過建造者模式獲取列族描述類的對象
        ColumnFamilyDescriptor cf = cfbuilder.build();
        // 將該列族組裝到表的Bulider對象上
        tbbuilder.setColumnFamily(cf);
        // 通過建造者模式獲取表的描述類的對象
        TableDescriptor td = tbbuilder.build();
        System.out.println("命令開始");
        // 通過表管理類的對象admin創建表並指定分區
        admin.createTable(td, new byte[][]{{10}, {20}});
        System.out.println("表創建完畢");
    }

2. 異步創建表

    //異步創建表
    @Test
    public void createTBAsync() throws Exception{
        // 創建表的描述類的Builder，HTableDescriptorBuilder
        // 設置表名
        TableDescriptorBuilder tbbuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf("IMUT:employee_async"));
        // 創建列族的描述類的Builder，ColumnFamilyDescriptorBuilder
        // 設置列族名
        ColumnFamilyDescriptorBuilder cfbuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("baseinfo"));
        // 設置該列族的屬性=>最大版本數爲10
        cfbuilder.setMaxVersions(10);
        // 通過建造者模式獲取列族描述類的對象
        ColumnFamilyDescriptor cf = cfbuilder.build();
        // 將該列族組裝到表的Bulider對象上
        tbbuilder.setColumnFamily(cf);
        // 通過建造者模式獲取表的描述類的對象
        TableDescriptor td = tbbuilder.build();
        System.out.println("命令發出");
        // 通過表管理類的對象admin異步創建表並指定分區
        Future<Void> future = admin.createTableAsync(td, new byte[][]{Bytes.toBytes("10"), Bytes.toBytes("20"),Bytes.toBytes("30")});
        System.out.println("等待結果");
        // 設置超時時長
        Void aVoid = future.get(5000, TimeUnit.MILLISECONDS);
        System.out.println("表創建成功");
    }

刪除表

1. 同步刪除表

    //同步刪除表
    @Test
    public void deleteTBSync() throws Exception {
        System.out.println("開始刪除表");
        // 第一步：通過表的管理類的對象禁用要刪除的表
        admin.disableTable(TableName.valueOf("IMUT:employee_sync"));
        System.out.println("禁用表成功");
        // 第二步：通過表的管理類的對象刪除被禁用的表
        admin.deleteTable(TableName.valueOf("IMUT:employee_sync"));
        System.out.println("刪除表成功");
    }

2. 異步刪除表

    //異步刪除表
    @Test
    public void deleteTBAsync() throws Exception {
        System.out.println("開始刪除表");
        // 第一步：通過表的管理類的對象異步禁用要刪除的表，並設置超時時長
        Future<Void> f1 = admin.disableTableAsync(TableName.valueOf("IMUT:employee_async"));
        Void v1 = f1.get(1000, TimeUnit.MILLISECONDS);
        System.out.println("禁用表成功");
        // 第二步：通過表的管理類的對象異步刪除被禁用的表，並設置超時時長
        Future<Void> f2 = admin.deleteTableAsync(TableName.valueOf("IMUT:employee_async"));
        Void v2 = f2.get(1000, TimeUnit.MILLISECONDS);
        System.out.println("刪除表成功");
    }

添加數據

    // 添加數據
    @Test
    public void putTest() throws IOException {
        // 通過表名獲取到指定表
        table = conn.getTable(TableName.valueOf("IMUT:employee_sync"));
        // 創建添加數據的類的對象，並指定行鍵
        Put put = new Put(Bytes.toBytes("15"));
        // 添加數據信息，列族，列名，值
        // 參數全部爲byte[]類型
        put.addColumn(Bytes.toBytes("baseinfo"), Bytes.toBytes("name"),Bytes.toBytes("kevin"));
        put.addColumn(Bytes.toBytes("baseinfo"), Bytes.toBytes("age"),Bytes.toBytes("43"));
        put.addColumn(Bytes.toBytes("baseinfo"), Bytes.toBytes("gender"),Bytes.toBytes("male"));
        put.addColumn(Bytes.toBytes("baseinfo"), Bytes.toBytes("position"),Bytes.toBytes("CTO"));
        // 將數據添加到該表中
        table.put(put);
        System.out.println("插入數據成功");
    }

獲取數據

    // 獲取數據
    @Test
    public void getTest() throws Exception {
        // 通過表名獲取到指定表
        table = conn.getTable(TableName.valueOf("IMUT:employee_sync"));
        // 創建獲取數據的類的對象，並指定行鍵
        Get get = new Get(Bytes.toBytes("15"));
        // 將從表中獲取到的數據返回到結果集中
        Result result = table.get(get);
        long t = table.getReadRpcTimeout(TimeUnit.MILLISECONDS);
        System.out.println("read超時時間:"+t);
        // 自定義方法，打印一行的結果
        showResult(result);
    }

    // 打印結果
    public void showResult(Result result){
        // 檢查該列族下的該列是否存在值，不論是否爲空
        System.out.println("是否存在值不論是否爲空:"+result.containsColumn(Bytes.toBytes("baseinfo"),Bytes.toBytes("age")));
        // 檢查該列族下的該列是否含有空值
        System.out.println("是否存在空值:"+result.containsEmptyColumn(Bytes.toBytes("baseinfo"),Bytes.toBytes("age")));
        // 檢查該列族下的該列是否存在非空值
        System.out.println("是否存在非空值:"+result.containsNonEmptyColumn(Bytes.toBytes("baseinfo"),Bytes.toBytes("age")));
        // 返回result中有幾個cell
        System.out.println("cell的個數:"+result.size());
        // 獲得某列族某列下的最新值
        System.out.println(Bytes.toString(result.getValue(Bytes.toBytes("baseinfo"),Bytes.toBytes("name"))));
        System.out.println(Bytes.toString(result.getValue(Bytes.toBytes("baseinfo"),Bytes.toBytes("age"))));
        System.out.println(Bytes.toString(result.getValue(Bytes.toBytes("baseinfo"),Bytes.toBytes("gender"))));
        // 返回第一個cell中的value值
        System.out.println("第一個cell中的value值:"+Bytes.toString(result.value()));
        System.out.println("-----------------");

        // 四層嵌套的Map
        NavigableMap<byte[], byte[]> qvmap = result.getFamilyMap(Bytes.toBytes("baseinfo"));
        // 遍歷列族
        for (Map.Entry<byte[], byte[]> entry : qvmap.entrySet()) {
            System.out.println("baseinfo"+" "+Bytes.toString(entry.getKey())+ " "+Bytes.toString(entry.getValue()));
        }
        System.out.println("-----------------");

        NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> fqtvs = result.getMap();
        // 遍歷列族，第一層Map的key爲列族
        for (Map.Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> fqtv : fqtvs.entrySet()) {
            byte[] f = fqtv.getKey();
            NavigableMap<byte[], NavigableMap<Long, byte[]>> qtvs = fqtv.getValue();
            // 遍歷列名，第二層Map的key爲列名
            for (Map.Entry<byte[], NavigableMap<Long, byte[]>> qtv : qtvs.entrySet()) {
                byte[] q = qtv.getKey();
                NavigableMap<Long, byte[]> tvs = qtv.getValue();
                // 遍歷時間戳，第三層Map的key爲時間戳，value爲值
                for (Map.Entry<Long, byte[]> tv : tvs.entrySet()) {
                    Long t = tv.getKey();
                    byte[] v = tv.getValue();
                    System.out.println("row:"+Bytes.toString(result.getRow())+" "
                            +"family:"+Bytes.toString(f)+" "
                            +"qualifier:"+Bytes.toString(q)+" "
                            +"timestamp:"+t+" "
                            +"value:"+Bytes.toString(v)+" ");
                }
            }
        }
        System.out.println("===========================================================");
    }

掃描（過濾器）

1. 掃描全表

    // 掃描
    @Test
    public void scanTest() throws IOException {
        // 通過表名獲取到指定表
        table = conn.getTable(TableName.valueOf("IMUT:employee_sync"));
        // 創建掃描的操作類的對象
        Scan scan = new Scan();
        // 將掃描得到的結果返回到結果集中
        ResultScanner scanner = table.getScanner(scan);
        // 遍歷打印所有符合條件的行
        for (Result result : scanner) {
            showResult(result);
        }
    }

2. 過濾器

    // 掃描
    @Test
    public void scanTest() throws IOException {
        // 通過表名獲取到指定表
        table = conn.getTable(TableName.valueOf("IMUT:employee_sync"));
        // 創建掃描的操作類的對象
        Scan scan = new Scan();
        // ---------有關行鍵的過濾器---------
        // 行鍵前綴過濾器
          Filter f = new PrefixFilter(Bytes.toBytes("15"));
        // 只掃描行鍵的過濾器，不獲取值
        // Filter f = new KeyOnlyFilter();
        // 隨機行過濾器，按比例獲取隨機行數
        // Filter f = new RandomRowFilter(0.5f);
        // 行範圍過濾器
        // List<MultiRowRangeFilter.RowRange> list = new ArrayList<>();
        // list.add(new MultiRowRangeFilter.RowRange("1001",true,"1004",true));
        // Filter f = new MultiRowRangeFilter(list);
        // 行鍵過濾器，可以通過提供不同比較器實現不同功能，如匹配行鍵前綴
        // Filter f = new RowFilter(CompareOperator.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("10")));
        // 列族相關過濾器，匹配正則表達式
        // Filter f = new FamilyFilter(CompareOperator.EQUAL, new RegexStringComparator(".*base.*"));
        // 列相關過濾器，獲得前n列過濾器
        // Filter f = new ColumnCountGetFilter(1);
        // 列分頁過濾器 基於ColumnPaginationFilter，參數1 獲得n列 參數2 從第n列開始獲取
        // Filter f = new ColumnPaginationFilter(3,1);
        // 列名前綴過濾器
        // Filter f = new ColumnPrefixFilter(Bytes.toBytes("na"));
        // 列名範圍過濾器
        // Filter f = new ColumnRangeFilter(Bytes.toBytes("aaa"),true,Bytes.toBytes("ccc"),true);
        // 匹配某列族某列某值的過濾器
        // Filter f = new ColumnValueFilter(Bytes.toBytes("info"),Bytes.toBytes("age"),CompareOperator.EQUAL,Bytes.toBytes("20"));
        // 根據值的比較過濾行
        // Filter f = new ValueFilter(CompareOperator.EQUAL, new RegexStringComparator(".*t.*"));
        // 設置掃描的過濾器
        scan.setFilter(f);
        // 將掃描得到的結果返回到結果集中
        ResultScanner scanner = table.getScanner(scan);
        // 遍歷打印所有符合條件的行
        for (Result result : scanner) {
            showResult(result);
        }
    }