HBase的java API 操作（DML和DQL）

本文是基于Apache版本的2.1.2的HBase开发。
本篇文章是HBase的DML和DQL开发，对HBase的table的增，删，查

---

基本规律：

1. 构建实例 ==> 2. 构建配置对象 ==> 3.指定服务端地址 ==> 4.构建连接对象 ==> 5.构建管理员（table对象）

新建maven工程，导入依赖
要想使用java操作HBase，需要引入下面依赖

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

代码实现

代码一：基本操作

package client;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

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

/**
 * @ClassName HbaseDMLTest
 * @Description TODO 用于实现JavaAPI开发DML操作
 *                  增改：put
 *                  删除:delete
 *                 查:get  scan
 * @Date 2021/3/24 21:23
 * @Create By     Frank
 */
public class HbaseDMLTest {
    public static void main(String[] args) throws IOException {
        //构建当前类的实例
        HbaseDMLTest dmlTest = new HbaseDMLTest();
        //todo:1-构建一个连接对象
        Configuration conf = HBaseConfiguration.create();
        //指定Hbase集群的服务端地址：给定ZK的地址
        conf.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181");
        Connection conn = ConnectionFactory.createConnection(conf);
        //todo:2-所有的DML必须构建一个Table表的对象
        //构建一个表的对象
        TableName tbname = TableName.valueOf("itcast:t1");
        Table table = conn.getTable(tbname);
        //todo:3-调用方法实现数据的增删改查
//        dmlTest.putData(table); //插入数据
//        dmlTest.getData(table); //Get查询数据
//        dmlTest.deleteData(table); //删除数据
//        dmlTest.scanData(table); //Scan全表扫描
        dmlTest.putListData(table);
        //todo:4-释放连接
        table.close();
        conn.close();
    }

    /**
     * 批量写入数据到Hbase
     * @param table
     */
    private void putListData(Table table) throws IOException {
        //step1：构建Put对象，一个Put对象用于表示一个Rowkey写入的数据
        Put put1 = new Put(Bytes.toBytes("20210101_001"));
        Put put2 = new Put(Bytes.toBytes("20210201_002"));
        Put put3 = new Put(Bytes.toBytes("20210301_003"));

        //step2：为Put添加这个Rowkey的每一列
        put1.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("name"),Bytes.toBytes("laoda"));
        put1.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("age"),Bytes.toBytes("18"));
        put1.addColumn(Bytes.toBytes("other"),Bytes.toBytes("phone"),Bytes.toBytes("110"));
        put1.addColumn(Bytes.toBytes("other"),Bytes.toBytes("addr"),Bytes.toBytes("shanghai"));

        put2.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("name"),Bytes.toBytes("laoer"));
        put2.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("age"),Bytes.toBytes("20"));
        put2.addColumn(Bytes.toBytes("other"),Bytes.toBytes("phone"),Bytes.toBytes("120"));

        put3.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("name"),Bytes.toBytes("laosan"));
        put3.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("age"),Bytes.toBytes("22"));
        put3.addColumn(Bytes.toBytes("other"),Bytes.toBytes("addr"),Bytes.toBytes("beijing"));

        //step3：将多个Put封装到List中
        List<Put> puts = new ArrayList<Put>();
        puts.add(put1);
        puts.add(put2);
        puts.add(put3);

        //step4：执行PutList
        table.put(puts);

    }

    /**
     * 通过Scan，进行Hbase表的数据查询:scan 表
     * @param table
     */
    private void scanData(Table table) throws IOException {
        //step1：构建Scan对象
        Scan scan = new Scan();
        //step2：执行scan：返回值是ResultScanner，包含了多个Rowkey的数据
        ResultScanner rsScan = table.getScanner(scan);
        /**
         *      ResultScanner：包含多个Rowkey的数据，包含了多个Result对象：Iterator<Result>
         *      Result：一个Rowkey的数据，包含了这个Rowkey多列的数据：Cell[]
         *      Cell ：一列的数据
         */
        //step3：打印数据
        //先获取每个rowkey
        for(Result rs:rsScan){
            //直接输出当前rowkey的值
            System.out.println(Bytes.toString(rs.getRow()));
            //再获取每个rowkey中的每一列
            for(Cell cell : rs.rawCells()){
                //输出每一列Cell对象中的数据：20201001_888  column=basic:age, timestamp=1616029665232, value=20
                System.out.println(
                        Bytes.toString(CellUtil.cloneRow(cell)) //获取这一列的rowkey，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneFamily(cell)) //获取这一列的列族，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneQualifier(cell)) //获取这一列的名称，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneValue(cell)) //获取这一列的值，转换为字符串类型
                                +"\t"+
                                cell.getTimestamp() //获取时间戳
                );
            }
            System.out.println("----------------------------------------------------------------------");
        }
    }

    /**
     * 删除某个Rowkey的某一列的数据：delete  表名     rowkey      列族：列
     * @param table
     */
    private void deleteData(Table table) throws IOException {
        //step1：构建删除对象
        Delete delete = new Delete(Bytes.toBytes("20201001_888"));
        //step2：添加删除配置
//        delete.addFamily()删除整个列族的数据
//        delete.addColumn(Bytes.toBytes("basic"),Bytes.toBytes("name")); //只删除最新版本
        delete.addColumns(Bytes.toBytes("basic"),Bytes.toBytes("name")); //删除所有版本
        //step3：执行删除
        table.delete(delete);
    }

    /**
     * 使用Get查询Hbase表中的数据：get 表名	rowkey	【列族，列】
     * @param table
     */
    private void getData(Table table) throws IOException {
        //step1：构建Get对象，必须指定Rowkey
        Get get = new Get(Bytes.toBytes("20201001_888"));
        //step2：可选的，配置Get需要的参数：列族、列
//        get.addColumn()//指定获取某一列的数据
//        get.addFamily()//指定获取某个列族的数据
        //step3：表执行get操作
        Result result = table.get(get);//Get操作的返回值为Result类型对象
        /**
         * 迭代输出Result对应的rowkey中的每一列的数据,一个Rowkey包含很多列，循环迭代输出每一列的数据
         *      Result：一个Result对象就是一个Rowkey的数据
         *      Cell：一个Cell代表一个rowkey中一列的数据
         *      一个Result对象中会包含多个Cell
         */
        for(Cell cell : result.rawCells()){
            //输出每一列Cell对象中的数据：20201001_888  column=basic:age, timestamp=1616029665232, value=20
            System.out.println(
                    Bytes.toString(CellUtil.cloneRow(cell)) //获取这一列的rowkey，转换为字符串类型
                    +"\t"+
                    Bytes.toString(CellUtil.cloneFamily(cell)) //获取这一列的列族，转换为字符串类型
                    +"\t"+
                    Bytes.toString(CellUtil.cloneQualifier(cell)) //获取这一列的名称，转换为字符串类型
                    +"\t"+
                    Bytes.toString(CellUtil.cloneValue(cell)) //获取这一列的值，转换为字符串类型
                    +"\t"+
                    cell.getTimestamp() //获取时间戳
            );
        }

    }

    /**
     * 用于实现使用Put插入数据到表中:put		表		rowkey		列族：列		值
     * @param table
     */
    private void putData(Table table) throws IOException {
        //step1：构建Put对象,必须指定插入的rowkey的数据
        Put put = new Put(Bytes.toBytes("20201001_888"));
        //step2：初始化put，添加列族、列、值
        put.addColumn(
                Bytes.toBytes("basic"),//指定列族
                Bytes.toBytes("name"),//指定列的名称
                Bytes.toBytes("laoqi")//指定列的值
        );
        //step3：让表执行put操作
        table.put(put);
    }
}

代码二：scan的过滤器操作

package client;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * @ClassName HbaseDMLTest
 * @Description TODO 用于实现JavaAPI开发Scan + Filter
 * @Date 2021/3/24 21:23
 * @Create By     Frank
 */
public class HbaseScanFilter {
    public static void main(String[] args) throws IOException {
        //构建当前类的实例
        HbaseScanFilter dmlTest = new HbaseScanFilter();
        //todo:1-构建一个连接对象
        Configuration conf = HBaseConfiguration.create();
        //指定Hbase集群的服务端地址：给定ZK的地址
        conf.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181");
        Connection conn = ConnectionFactory.createConnection(conf);
        //todo:2-所有的DML必须构建一个Table表的对象
        //构建一个表的对象
        TableName tbname = TableName.valueOf("itcast:t1");
        Table table = conn.getTable(tbname);
        //todo:3-调用方法实现数据的增删改查
        dmlTest.scanData(table); //Scan + Filter
        //todo:4-释放连接
        table.close();
        conn.close();
    }

    /**
     * 通过Scan，进行Hbase表的数据查询:scan 表
     * @param table
     */
    private void scanData(Table table) throws IOException {
        //step1：构建Scan对象
        Scan scan = new Scan();

        //step2：为Scan添加过滤器
        //需求一：查询2021年1月和2月的数据
//        scan.withStartRow(Bytes.toBytes("202101"));
//        scan.withStopRow(Bytes.toBytes("202103"));
        //需求2：查询2021年的所有数据
//        Filter prefixFiter = new PrefixFilter(Bytes.toBytes("2021"));
        //需求三：查询所有age = 20的数据
        /**
         *    * @param family name of column family
         *    * @param qualifier name of column qualifier
         *    * @param op operator
         *    * @param value value to compare column values against
         */
        Filter valueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("basic"),//指定列族
                Bytes.toBytes("age"),//指定列
                CompareOperator.EQUAL,//指定比较器类型
                Bytes.toBytes("20")  //比较的值
        );

        //需求4：查询所有数据的name和age这两列
        //构建所有需要过滤的列
        byte[][] prefixes = {
            Bytes.toBytes("name"),
            Bytes.toBytes("age")
        };
        Filter columnFilter = new MultipleColumnPrefixFilter(prefixes);
        //需求5：查询所有age = 20的人的name和age
        //构建FIlterList
        FilterList lists = new FilterList();//MUST_PASS_ALL：and,MUST_PASS_ONE：or
        //添加过滤器
        lists.addFilter(valueFilter);
        lists.addFilter(columnFilter);
        //将过滤器加载到scan中
        scan.setFilter(lists);

        //step3：执行scan：返回值是ResultScanner，包含了多个Rowkey的数据
        ResultScanner rsScan = table.getScanner(scan);
        /**
         *      ResultScanner：包含多个Rowkey的数据，包含了多个Result对象：Iterator<Result>
         *      Result：一个Rowkey的数据，包含了这个Rowkey多列的数据：Cell[]
         *      Cell ：一列的数据
         */
        //step4：打印数据
        //先获取每个rowkey
        for(Result rs:rsScan){
            //直接输出当前rowkey的值
            System.out.println(Bytes.toString(rs.getRow()));
            //再获取每个rowkey中的每一列
            for(Cell cell : rs.rawCells()){
                //输出每一列Cell对象中的数据：20201001_888  column=basic:age, timestamp=1616029665232, value=20
                System.out.println(
                        Bytes.toString(CellUtil.cloneRow(cell)) //获取这一列的rowkey，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneFamily(cell)) //获取这一列的列族，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneQualifier(cell)) //获取这一列的名称，转换为字符串类型
                                +"\t"+
                                Bytes.toString(CellUtil.cloneValue(cell)) //获取这一列的值，转换为字符串类型
                                +"\t"+
                                cell.getTimestamp() //获取时间戳
                );
            }
            System.out.println("----------------------------------------------------------------------");
        }
    }
}