HBase使用教程

目录

1、Maven依赖

2、相关配置

3、编写工具类 

3.1、获取 hbase 参数

3.2、HBase操作

4、HBase常用的查看数据方式

4.1、基本介绍

4.2、Scan类常用方法

4.3、Filter 过滤操作

4.3.1、操作符(比较运算符)

4.3.2、比较器(Comparator)

4.3.3、常见的过滤器


HBase 是一个分布式的、面向列的开源的 NoSQL 数据库。如果需要操作 HBase 通常有如下几种客户端可以使用:

  • hbase-client:比较底层,需要自己进一步封装 api,而且版本号和安装的 hbase 也要匹配,否则会报错
  • spring-data-hadoop:2019 年 4 月 5 停止维护
  • Apache Phoenix:使用 SQL 的方式来操作 HBase。Phoenix 的性能很高(进行简单查询,其性能量级是毫秒),相对于 hbase 原生的 scan 并不会差多少,而对于类似的组件 hive、Impala 等,性能有着显著的提升

    本文演示如何使用 hbase-client 操作 HBase 数据库。

1、Maven依赖

 hbase-client 的Maven依赖:

<dependency>

    <groupId>org.apache.hbasegroupId>

    <artifactId>hbase-clientartifactId>

    <version>2.3.0version>

dependency>


2、相关配置

#hbase config
hbase.addresses=ip1,ip2,ip3
#hbase.addresses=hadoop
hbase.port=2181
hbase.zookeeper.parent=/hbase
hadoop.home.dir=E:/hadoop-common-2.2.0-bin-master

3、编写工具类 

3.1、获取 hbase 参数

编写HBaseConfigInit.java来读取hbase 的配置,获取 hbase 参数:

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

/**
 * @author summer.lin
 * @date 2023-03-23 14:34
 */
public class HBaseConfigInit {
    public static final Logger LOGGER  = LoggerFactory.getLogger(HBaseConfigInit.class);

    private String  quorum = new String();
    private Integer port = 0;
    private String  parent = new String();
    private String  homeDir = new String();

    public void setConfig(String quorum, Integer port,String  parent,String homeDir) {
        this.homeDir = homeDir;
        this.quorum = quorum;
        this.port = port;
        this.parent = parent;
    }

    public Configuration configuration() {
        System.setProperty("hadoop.home.dir", homeDir);
        LOGGER.info("Hadoop Home Dir: {}, quorum: {}, port: {}", homeDir, quorum, port);
        Configuration configuration = org.apache.hadoop.hbase.HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", quorum);// ip of hbase server(remote)
        configuration.setInt("hbase.zookeeper.property.clientPort", port);// port: 2181 default
        configuration.set("zookeeper.znode.parent", parent);
        return configuration;
    }

    public Admin admin() {
        Admin admin = null;
        try {
            Connection connection = ConnectionFactory.createConnection(configuration());
            admin = connection.getAdmin();
        } catch (IOException e) {
            LOGGER.error("Init HBase Client Error.", e);
        }
        return admin;
    }

    public String getQuorum() {
        return quorum;
    }

    public void setQuorum(String quorum) {
        this.quorum = quorum;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public String getParent() {
        return parent;
    }

    public void setParent(String parent) {
        this.parent = parent;
    }

    public String getHomeDir() {
        return homeDir;
    }

    public void setHomeDir(String homeDir) {
        this.homeDir = homeDir;
    }

}

3.2、HBase操作

封装 HBaseUtils.java 工具类,实现创建表、插入、读取、删除数据:
 

import com.alibaba.fastjson.JSONObject;
import com.jfinal.kit.PropKit;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.*;

public class HbaseUtils implements Serializable {
    public static final Logger LOGGER = LoggerFactory.getLogger(HbaseUtils.class);

    protected static final long serialVersionUID = 1L;
    private static Admin hbaseAdmin = null;

    static {
        try {
            Init();
        } catch (Exception e) {
            System.out.println(">----Hbase Init Failure ----");
            e.printStackTrace();
        }
    }

    public static void Init() {
        System.out.println(">----Hbase Init Start ----");
        PropKit.use("config.properties");
        HBaseConfigInit hBaseConfigInit = new HBaseConfigInit();
        hBaseConfigInit.setConfig(PropKit.get("hbase.addresses"), PropKit.getInt("hbase.port"),
                PropKit.get("hbase.zookeeper.parent"),
                PropKit.get("hadoop.home.dir"));
        hbaseAdmin = hBaseConfigInit.admin();
        System.out.println(">----Hbase Init Success----");
    }

    public static void main(String[] args) {
        HbaseUtils hData = new HbaseUtils();
        String tableName = "hbase_data";
        hData.dropTable(tableName);
        List columnFamily = new ArrayList<>();
        columnFamily.add("data");
        hData.createTable(tableName,columnFamily);
    }


    /**
     * 判断表是否存在
     *
     * @param tableName 表名
     * @return true/false
     */
    public static boolean isExists(String tableName) {
        boolean tableExists = false;
        try {
            TableName table = TableName.valueOf(tableName);
            tableExists = hbaseAdmin.tableExists(table);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tableExists;
    }

    /**
     * 创建表
     *
     * @param tableName    表名
     * @param columnFamily 列族
     * @return true/false
     */
    public boolean createTable(String tableName, List columnFamily) {
        if (!isExists(tableName)) {
            try {
                TableName table = TableName.valueOf(tableName);
                TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(table);
                for (String cf : columnFamily) {
                    builder.setColumnFamily(ColumnFamilyDescriptorBuilder.of(cf));
                }
                hbaseAdmin.createTable(builder.build());
                return true;
            } catch (IOException e) {
                LOGGER.warn("HBase Create Table Error.", e);
            }
        } else {
            LOGGER.warn("HBase Create Table Error. Table-{} already Exists", tableName);
        }
        return false;
    }

    /**
     * 预分区创建表
     *
     * @param tableName    表名
     * @param columnFamily 列族
     * @param keys         分区集合
     * @return true/false
     */
    public boolean createTable(String tableName, List columnFamily, List keys) {
        if (!isExists(tableName)) {
            try {
                TableName table = TableName.valueOf(tableName);
                HTableDescriptor desc = new HTableDescriptor(table);
                for (String cf : columnFamily) {
                    desc.addFamily(new HColumnDescriptor(cf));
                }
                if (keys == null) {
                    hbaseAdmin.createTable(desc);
                } else {
                    byte[][] splitKeys = getSplitKeys(keys);
                    hbaseAdmin.createTable(desc, splitKeys);
                }
                return true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(tableName + "is exists!!!");
            return false;
        }
        return false;
    }

    /**
     * 删除表
     *
     * @param tableName 表名
     */
    public static void dropTable(String tableName) {
        if (isExists(tableName)) {
            TableName table = TableName.valueOf(tableName);
            try {
                hbaseAdmin.disableTable(table);
                hbaseAdmin.deleteTable(table);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 插入(覆盖)数据
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param data         数据键值对
     * @return true/false 插入成功/失败
     */
    public static boolean putData(String tableName, String rowKey, String columnFamily, Map data) {
        TableName tableNameObj = TableName.valueOf(tableName);
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj)) {
            Put put = new Put(Bytes.toBytes(rowKey));
            byte[] cf = Bytes.toBytes(columnFamily);
            for (Map.Entry entry : data.entrySet()) {
                put.addColumn(cf, Bytes.toBytes(entry.getKey()), Bytes.toBytes(entry.getValue()));
            }
            table.put(put);
            return true;
        } catch (IOException e) {
            LOGGER.warn("HBase Put Data Error.", e);
            return false;
        }
    }

    /**
     * 插入数据(单条)
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param column       列
     * @param value        值
     * @return true/false
     */
    public boolean putData(String tableName, String rowKey, String columnFamily, String column,
                           String value) {
        return putData(tableName, rowKey, columnFamily, Arrays.asList(column),
                Arrays.asList(value));
    }

    /**
     * 插入数据(批量)
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param columns      列
     * @param values       值
     * @return true/false
     */
    public boolean putData(String tableName, String rowKey, String columnFamily,
                           List columns, List values) {
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            for (int i = 0; i < columns.size(); i++) {
                put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columns.get(i)),
                        Bytes.toBytes(values.get(i)));
            }
            table.put(put);
            table.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取数据(全表数据)
     *
     * @param tableName 表名
     * @return map
     */
    public List getData(String tableName) {
        List results = new ArrayList<>();
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Scan scan = new Scan();
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                JSONObject json = cellToJSON(result);
                results.add(json);
            }
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return results;
    }

    /**
     * 获取数据(根据传入的filter)
     *
     * @param tableName 表名
     * @param filter    过滤器
     * @return List
     */
    public static List getData(String tableName, Filter filter) {
        List results = new ArrayList<>();
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Scan scan = new Scan();
            // 添加过滤器
            scan.setFilter(filter);
            scan.setLimit(100);
            ResultScanner resultScanner = table.getScanner(scan);
            for (Result result : resultScanner) {
                JSONObject json = cellToJSON(result);
                results.add(json);
            }
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return results;
    }

    /**
     * 获取数据(根据rowkey,列族,列)
     *
     * @param tableName       表名
     * @param rowKey          rowKey
     * @param columnFamily    列族
     * @param columnQualifier 列
     * @return map
     */
    public String getData(String tableName, String rowKey, String columnFamily,
                          String columnQualifier) {
        String data = "";
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Get get = new Get(Bytes.toBytes(rowKey));
            get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnQualifier));
            Result result = table.get(get);
            if (result != null && !result.isEmpty()) {
                Cell cell = result.listCells().get(0);
                data = Bytes.toString(cell.getValueArray(), cell.getValueOffset(),
                        cell.getValueLength());
            }
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return data;
    }

    /**
     * 删除数据(根据rowkey)
     *
     * @param tableName 表名
     * @param rowKey    rowKey
     */
    public void deleteData(String tableName, String rowKey) throws IOException {
        Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        table.delete(delete);
        table.close();
    }

    /**
     * 删除数据(根据rowkey,列族)
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     */
    public void deleteData(String tableName, String rowKey, String columnFamily)
            throws IOException {
        Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        delete.addFamily(columnFamily.getBytes());
        table.delete(delete);
        table.close();
    }

    /**
     * 删除数据(根据rowkey,列族)
     *
     * @param tableName    表名
     * @param rowKey       rowKey
     * @param columnFamily 列族
     * @param column       列
     */
    public void deleteData(String tableName, String rowKey, String columnFamily, String column)
            throws IOException {
        Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        delete.addColumn(columnFamily.getBytes(), column.getBytes());
        table.delete(delete);
        table.close();
    }

    /**
     * 删除数据(多行)
     *
     * @param tableName 表名
     * @param rowKeys   rowKey集合
     */
    public void deleteData(String tableName, List rowKeys) throws IOException {
        Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
        List deleteList = new ArrayList<>();
        for (String row : rowKeys) {
            Delete delete = new Delete(Bytes.toBytes(row));
            deleteList.add(delete);
        }
        table.delete(deleteList);
        table.close();
    }

    /**
     * 分区【10, 20, 30】 -> ( ,10] (10,20] (20,30] (30, )
     *
     * @param keys 分区集合[10, 20, 30]
     * @return byte二维数组
     */
    private byte[][] getSplitKeys(List keys) {
        byte[][] splitKeys = new byte[keys.size()][];
        TreeSet rows = new TreeSet<>(Bytes.BYTES_COMPARATOR);
        for (String key : keys) {
            rows.add(Bytes.toBytes(key));
        }
        int i = 0;
        for (byte[] row : rows) {
            splitKeys[i] = row;
            i++;
        }
        return splitKeys;
    }

    private byte[] valueToBytes(Object val) {
        if (val == null) {
            return null;
        }
        Class type = val.getClass();
        if (type == Integer.class) {
            return Bytes.toBytes((Integer) val);
        } else if (type == BigDecimal.class) {
            return Bytes.toBytes((BigDecimal) val);
        } else if (type == Boolean.class) {
            return Bytes.toBytes((Boolean) val);
        } else if (type == Double.class) {
            return Bytes.toBytes((Double) val);
        } else if (type == Float.class) {
            return Bytes.toBytes((Float) val);
        } else if (type == Long.class) {
            return Bytes.toBytes((Long) val);
        } else if (type == Short.class) {
            return Bytes.toBytes((Short) val);
        } else if (type == String.class) {
            return Bytes.toBytes((String) val);
        } else {
            return Bytes.toBytes(val.toString());
        }
    }

    /**
     * 获取最新
     *
     * @param tableName 表名
     */
    public static List scanNewestOne(String tableName) {
        List results = new ArrayList<>();

        TableName tableNameObj = TableName.valueOf(tableName);
        Scan scan = new Scan();
        scan.setLimit(1);

        scan.setReversed(true);
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj);
             ResultScanner resultScanner = table.getScanner(scan)) {
            for (Result result : resultScanner) {
                if (result != null && !result.isEmpty()) {
                    JSONObject json = cellToJSON(result);
                    results.add(json);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 获取全表数据
     *
     * @param tableName 表名
     */
    public static List scanAll(String tableName) {
        List results = new ArrayList<>();

        TableName tableNameObj = TableName.valueOf(tableName);
        Scan scan = new Scan();
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj);
             ResultScanner resultScanner = table.getScanner(scan)) {
            for (Result result : resultScanner) {
                if (result != null && !result.isEmpty()) {
                    JSONObject json = cellToJSON(result);
                    results.add(json);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 获取全表数据
     *
     * @param tableName 表名
     */
    public static List scanByFilter(String tableName, Filter filter) {
        List results = new ArrayList<>();

        TableName tableNameObj = TableName.valueOf(tableName);
        Scan scan = new Scan();
        scan.setReversed(true);
        // 添加过滤器
        scan.setFilter(filter);
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj);
             ResultScanner resultScanner = table.getScanner(scan)) {
            for (Result result : resultScanner) {
                if (result != null && !result.isEmpty()) {
                    JSONObject json = cellToJSON(result);
                    results.add(json);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 获取全表数据
     *
     * @param tableName 表名
     */
    public static List scanByScan(String tableName, Scan scan) {
        List results = new ArrayList<>();

        TableName tableNameObj = TableName.valueOf(tableName);
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj);
             ResultScanner resultScanner = table.getScanner(scan)) {
            for (Result result : resultScanner) {
                if (result != null && !result.isEmpty()) {
                    JSONObject json = cellToJSON(result);
                    results.add(json);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 一页页获取全表数据
     *
     * @param tableName 表名
     */
    public static List scanByPage(String tableName, Scan scan, int limit) {
        List results = new ArrayList<>();
        scan.setLimit(limit);
        String startRowKey = "";
        try {
            TableName tableNameObj = TableName.valueOf(tableName);
            Connection connection = hbaseAdmin.getConnection();
            Table table = connection.getTable(tableNameObj);
            while (true) {
                System.out.println(scan.toJSON());
                ResultScanner resultScanner = table.getScanner(scan);
                List subResults = new ArrayList<>();
                for (Result result : resultScanner) {
                    if (result != null && !result.isEmpty()) {
                        JSONObject json = cellToJSON(result);
                        subResults.add(json);
                    }
                }
                LOGGER.info("HBase Get Data:" + subResults.size());
                results.addAll(subResults);
                if (subResults.size() < limit || subResults.size() == 0) {
                    break;
                } else {
                    if (subResults.size() > 0)
                        startRowKey = subResults.get(subResults.size() - 1).getString("rowKey");
                    scan.withStartRow(startRowKey.getBytes(), false);
                    scan.setLimit(limit);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 获取全表数据
     *
     * @param tableName 表名
     */
    public static List scanByRowKeyPrefix(String tableName, String rowKeyPrefix, Integer limit) {
        List results = new ArrayList<>();

        TableName tableNameObj = TableName.valueOf(tableName);
        Scan scan = new Scan();
        if (limit != null) {
            scan.setLimit(limit);
        }
        scan.setReversed(true);
        PrefixFilter prefixFilter = new PrefixFilter(rowKeyPrefix.getBytes());
        scan.setFilter(prefixFilter);
        Connection connection = hbaseAdmin.getConnection();
        try (Table table = connection.getTable(tableNameObj);
             ResultScanner resultScanner = table.getScanner(scan)) {
            for (Result result : resultScanner) {
                if (result != null && !result.isEmpty()) {
                    JSONObject json = cellToJSON(result);
                    results.add(json);
                }
            }
        } catch (IOException e) {
            LOGGER.warn("HBase Get Data Error. TableName: {}", tableName, e);
        }
        return results;
    }

    /**
     * 获取数据(根据rowkey)
     *
     * @param tableName 表名
     * @param rowKey    rowKey
     * @return map
     */
    public static JSONObject getDataByRowKey(String tableName, String rowKey) {
        JSONObject json = new JSONObject();
        try {
            Table table = hbaseAdmin.getConnection().getTable(TableName.valueOf(tableName));
            Get get = new Get(Bytes.toBytes(rowKey));
            Result result = table.get(get);
            if (result != null && !result.isEmpty()) {
                json.putAll(cellToJSON(result));
            }
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return json;
    }

    private static JSONObject cellToJSON(Result result) {
        JSONObject jsonObject = new JSONObject();
        for (Cell cell : result.listCells()) {
            if (!jsonObject.containsKey("rowKey")) {
                String rowKey = Bytes.toString(cell.getRowArray(),
                        cell.getRowOffset(), cell.getRowLength());
                jsonObject.put("rowKey", rowKey);
            }
            //列族
            String family = Bytes.toString(cell.getFamilyArray(),
                    cell.getFamilyOffset(), cell.getFamilyLength());
            //列
            String qualifier = Bytes.toString(cell.getQualifierArray(),
                    cell.getQualifierOffset(), cell.getQualifierLength());
            //值
            String data = Bytes.toString(cell.getValueArray(),
                    cell.getValueOffset(), cell.getValueLength());
            jsonObject.put(qualifier, data);

        }
        return jsonObject;
    }
}

4、HBase常用的查看数据方式

4.1、基本介绍

HBase常用的查看数据方式有scan和get,get是一种特殊的scan,get是scan的startRow和endRow等于同一个值的特殊情况。

HBase的RowKey 是按照B+树的形式存放的,所以查找一个具体的RowKey 速度是非常快的,所以查询数据的时候一般都会设置scan的startRow和endRow,这样可以缩小查找的范围,所以RowKey 的设计在HBase里面是极为重要的。

可以这样讲,HBase里面的查询数据只有scan一种形式,就是在B+树里面查找RowKey ,而scan就是对RowKey 的一种顺序”扫”。

查看一下scan里面对RowKey的条件筛选,只有startRow和endRow这一组,所以可以理解为sql条件里面的”>”和”<”。

HBase的RowKey 是按照顺序排列的,所以在设计RowKey 的时候尽量将业务查询需要的字段设计到RowKey 里面,这样在查询的时候对RowKey 加上一定范围的限制。

Filter 可以在 scan的结果集基础之上,对返回的记录设置更多条件值,这些条件可与 RowKey 有关,可以与列名有关,也可以与列值有关,还可以将多个 Filter 条件组合在一起等等。基于Hbase本身提供的三维有序(主键有序、列有序、版本有序),这些 Filter 可以高效的完成查询过滤的任务。

注意:Filter 可能会导致查询响应时延变的不可控制。因为我们无法预测,为了找到一条符合条件的记录,背后需要扫描多少数据量,如果在有效限制了 Scan 范围区间(通过设置startRow 与stopRow 限制)的前提下,该问题能够得到有效的控制。

4.2、Scan类常用方法

1. 指定需要的family或column ,如果没有调用任何addFamily或Column,会返回所有的columns
scan.addFamily();
scan.addColumn();
2. 指定最大的版本个数。如果不带任何参数调用setMaxVersions,表示取所有的版本。如果不掉用setMaxVersions,只会取到最新的版本
scan.setMaxVersions();
3. 指定最大的时间戳和最小的时间戳,只有在此范围内的cell才能被获取
scan.setTimeRange();
4. 指定时间戳
scan.setTimeStamp();
5. 指定Filter来过滤掉不需要的信息
scan.setFilter();
6. 指定开始的行。如果不调用,则从表头开始
//scan.setStartRow();

scan.withStartRow();
7. 指定结束的行(不含此行)
scan.setStopRow();

//scan.withStopRow();
8. 指定最多返回的Cell数目,用于防止一行中有过多的数据,导致OutofMemory错误
scan.setBatch();

9. 指定返回的family数目
scan.setLimit();

4.3、Filter 过滤操作

4.3.1、操作符(比较运算符)

要完成一个过滤的操作,至少需要两个参数。一个是如下抽象的操作符(比较运算符),Hbase 提供了枚举类型的变量来表示这些抽象的操作符:

  • LESS:小于(即 <)
  • LESS_OR_EQUAL:小于等于(即 <=)
  • EQUAL:等于(即 =)
  • NOT_EQUAL:不等于(即 <>)
  • GREATER_OR_EQUAL:大于等于(即 >=)
  • GREATER(即 >)
  • NO_OP:排除所有

4.3.2、比较器(Comparator)

代表具体的比较逻辑,如果可以提高字节级的比较、字符串级的比较等:

  • BinaryComparator 按字节索引顺序比较指定字节数组,采用 Bytes.compareTo(byte[])
  • BinaryPrefixComparator 跟前面相同,只是比较左端的数据是否相同
  • NullComparator 判断给定的是否为空
  • BitComparator 按位比较
  • RegexStringComparator 提供一个正则的比较器,仅支持 EQUAL 和非 EQUAL
  • SubstringComparator 判断提供的子串是否出现在 value 中

4.3.3、常见的过滤器

1.RowFilter
筛选出匹配的所有的行

Filter rf = new RowFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("row1"))); // OK 筛选出匹配的所有的行  

2. PrefixFilter
筛选出具有特定前缀的行键的数据

Filter pf = new PrefixFilter(Bytes.toBytes("row")); // OK  筛选匹配行键的前缀成功的行  

3. KeyOnlyFilter
只返回每行的行键,值全部为空

Filter kof = new KeyOnlyFilter(); // OK 返回所有的行,但值全是空  

4. RandomRowFilter
本过滤器的作用就是按照一定的几率(<=0会过滤掉所有的行,>=1会包含所有的行)来返回随机的结果集,对于同样的数据集,多次使用同一个RandomRowFilter会返回不通的结果集,对于需要随机抽取一部分数据的应用场景,可以使用此过滤器:

Filter rrf = new RandomRowFilter((float) 0.8); // OK 随机选出一部分的行

5. InclusiveStopFilter
扫描的时候,我们可以设置一个开始行键和一个终止行键,默认情况下,这个行键的返回是前闭后开区间,即包含起始行,但不包含终止行,如果我们想要同时包含起始行和终止行,那么我们可以使用此过滤器:

Filter isf = new InclusiveStopFilter(Bytes.toBytes("row1")); // OK 包含了扫描的上限在结果之内

 6. FirstKeyOnlyFilter
返回的结果集中只包含第一列的数据,它在找到每行的第一列之后会停止扫描,从而使扫描的性能也得到了一定的提升:

Filter fkof = new FirstKeyOnlyFilter(); // OK 筛选出第一个每个第一个单元格  

7. ColumnPrefixFilter
按照列名的前缀来筛选单元格的

Filter cpf = new ColumnPrefixFilter(Bytes.toBytes("qual1")); // OK 筛选出前缀匹配的列 

8. ValueFilter
按照具体的值来筛选单元格的过滤器,这会把一行中值不能满足的单元格过滤掉,如下面的构造器,对于每一行的一个列,如果其对应的值不包含ROW2_QUAL1,那么这个列就不会返回给客户端:

Filter vf = new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("ROW2_QUAL1")); // OK 筛选某个(值的条件满足的)特定的单元格  

9. ColumnCountGetFilter
这个过滤器来返回每行最多返回多少列,并在遇到一行的列数超过我们所设置的限制值的时候,结束扫描操作:

Filter ccf = new ColumnCountGetFilter(2); // OK 如果突然发现一行中的列数超过设定的最大值时,整个扫描操作会停止

10. SingleColumnValueFilter
用一列的值决定这一行的数据是否被过滤。在它的具体对象上,可以调用setFilterIfMissing(true)或者setFilterIfMissing(false),默认的值是false,其作用是:对于要使用作为条件的列,如果这一行不包含指定的列,那么如果为true,这样的行将会被过滤掉,如果为false,这样的行会包含在结果集中。

SingleColumnValueFilter scvf = new SingleColumnValueFilter(  
        Bytes.toBytes("colfam1"),   
        Bytes.toBytes("qual2"),   
        CompareOperator.NOT_EQUAL,   
        new SubstringComparator("BOGUS"));  
scvf.setFilterIfMissing(false);  
scvf.setLatestVersionOnly(true); // OK  

11. SingleColumnValueExcludeFilter
这个与SingleColumnValueFilter过滤器唯一的区别就是,作为筛选条件的列的不会包含在返回的结果中。

12. SkipFilter
这是一种附加过滤器,其与ValueFilter结合使用,如果发现一行中的某一列不符合条件,那么整行就会被过滤掉:

Filter skf = new SkipFilter(vf); // OK 发现某一行中的一列需要过滤时,整个行就会被过滤掉

13. WhileMatchFilter
这个过滤器的应用场景也很简单,如果你想要在遇到某种条件数据之前的数据时,就可以使用这个过滤器;当遇到不符合设定条件的数据的时候,整个扫描也就结束了:

Filter wmf = new WhileMatchFilter(rf); // OK 类似于Python itertools中的takewhile

14. FilterList
用于综合使用多个过滤器。其有两种关系:FilterList.Operator.MUST_PASS_ONE和FilterList.Operator.MUST_PASS_ALL,默认的是FilterList.Operator.MUST_PASS_ALL,顾名思义,它们分别是AND和OR的关系,并且FilterList可以嵌套使用FilterList,使我们能够表达更多的需求:

List filters = new ArrayList();  
filters.add(rf);  
filters.add(vf);  
FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters); // OK 综合使用多个过滤器, AND 和 OR 两种关系  


 

 

你可能感兴趣的:(hbase,数据库,hadoop)