HBaseAPI

最新推荐文章于 2023-03-08 16:42:38 发布

树深时见鹿_ic

最新推荐文章于 2023-03-08 16:42:38 发布

阅读量562

点赞数

分类专栏： BidData 数据库文章标签： Hbase

本文链接：https://blog.csdn.net/qq_18505209/article/details/102721782

版权

BidData 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

数据库

2 篇文章 0 订阅

订阅专栏

HBase的API：

HBaseUtils

public class HBaseUtils {
    private static Logger logger = LoggerFactory.getLogger(HBaseUtils.class);

    public static Admin getAdmin() {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://mini01:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "mini01,mini02,mini03");
        Connection conn = null;
        Admin admin = null;
        try {
            conn = ConnectionFactory.createConnection(conf);
            admin = conn.getAdmin();
        } catch (IOException e) {
            e.toString();
            logger.warn("连接HBase异常！", e);
        }
        return admin;
    }

    public static void close(Admin admin) {
        if (admin != null) {
            try {
                admin.close();
                admin.getConnection().close();
            } catch (IOException e) {
                e.toString();
                logger.warn("关闭Admin异常！", e);
            }
        }
    }

    public static Table getTable(String tableName) {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.rootdir", "hdfs://mini01:9000/hbase");
        conf.set("hbase.zookeeper.quorum", "mini01,mini02,mini03");
        Connection conn = null;
        Table table = null;
        try {
            conn = ConnectionFactory.createConnection(conf);
            if (StringUtils.isEmpty(tableName)) {
                tableName = "hbase:meta";
            }
            table = conn.getTable(TableName.valueOf(tableName));
        } catch (IOException e) {
            e.toString();
            logger.warn("获取Table异常！", e);
        }
        return table;
    }

    public static void closeTable(Table table) {
        if (null != table) {
            try {
                table.close();
            } catch (IOException e) {
                logger.warn("关闭Table的时候异常!", e);
            }
        }
    }

    public static void showTable(String tableName) {

    }
}

Namespace

CreateNamespace

public class CreateNamespace {
    private static Logger logger = LoggerFactory.getLogger(CreateNamespace.class);

    public static void main(String[] args) throws IOException {
        Admin admin = HBaseUtils.getAdmin();
        try {
            //1. 创建namespace对象
            NamespaceDescriptor descriptor = NamespaceDescriptor.create("myns01").build();
            //2. 提交hbase中创建对象
            admin.createNamespace(descriptor);
            NamespaceDescriptor[] namespaceDescriptors = admin.listNamespaceDescriptors();
            for (NamespaceDescriptor namespaceDescriptor : namespaceDescriptors) {
                System.out.println(namespaceDescriptor);
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }
}

ListNamespace

public class ListNamespace {
    private static Logger logger = LoggerFactory.getLogger(ListNamespace.class);

    public static void main(String[] args) {
        //1. 获取admin对象
        Admin admin = HBaseUtils.getAdmin();
        try {
            //2. 获取namespace的所有描述器
            NamespaceDescriptor[] namespaceDescriptors = admin.listNamespaceDescriptors();
            //3. 遍历
            for (NamespaceDescriptor namespaceDescriptor : namespaceDescriptors) {
                System.out.println(namespaceDescriptor);
            }
        } catch (IOException e) {
            //logger.warn("异常信息----->", e);
        } finally {
            //4. 关闭
            HBaseUtils.close(admin);
        }
    }
}

ListNamespaceTables

public class ListNamespaceTables {
    private static Logger logger = LoggerFactory.getLogger(ListNamespaceTables.class);

    public static void main(String[] args) throws IOException {
        //1. 获取admin对象
        Admin admin = HBaseUtils.getAdmin();
        try {
            //2. 获取所有的表名
            //TableName[] tableNames = admin.listTableNames();
            //3. 获取myns1的所有的表名
            TableName[] tableNames = admin.listTableNamesByNamespace("myns01");
            //4. 遍历
            for (TableName tableName : tableNames) {
                System.out.println(tableName.getNameAsString());
            }
            //5. 获取myns1所有的表描述
            HTableDescriptor[] hTableDescriptors = admin.listTableDescriptorsByNamespace("myns01");
            //6. 遍历
            for (HTableDescriptor htableDescriptor : hTableDescriptors) {
                System.out.println(htableDescriptor);
            }
        } catch (IOException e) {

        } finally {
            //7. 关闭
            HBaseUtils.close(admin);
        }

    }
}

DeleteNamespace

public class DeleteNamespace {
    private static Logger logger = LoggerFactory.getLogger(DeleteNamespace.class);

    public static void main(String[] args) {
        //1. 获取admin对象
        Admin admin = HBaseUtils.getAdmin();
        try {
            //2. 删除
            admin.deleteNamespace("user_info");
        } catch (IOException e) {

        } finally {
            //3. 关闭
            HBaseUtils.close(admin);
        }
    }
}

Table

CreateTable

public class CreateTable {
    private static Logger logger = LoggerFactory.getLogger(CreateTable.class);

    public static void main(String[] args) throws IOException {
        createTable("myns01:user_info", "base_info", "extra_info");
    }

    public static void createTable(String tableName, String... columnFamilyName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                System.out.println("Table : " + tn + " already exists !");
            } else {
                HTableDescriptor hTableDescriptor = new HTableDescriptor(tn);
                int len = columnFamilyName.length;
                for (int i = 0; i < len; i++) {
                    HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(columnFamilyName[i]);
                    // 设置列簇版本从1到5,默认为3
                    //columnDescriptor.setMinVersions(1);
                    //columnDescriptor.setMaxVersions(5);
                    hColumnDescriptor.setVersions(1, 5);
                    // 指定最大的TTL,单位是ms,过期数据会被自动删除
                    //hColumnDescriptor.setTimeToLive(24 * 60 * 60 * 1000);
                    // setBloomFilterType
                    hColumnDescriptor.setBloomFilterType(BloomType.ROW);
                    // 设置HBase数据存放的副本数
                    //columnDescriptor.setDFSReplication(3);
                    // 将列簇添加到表中
                    hTableDescriptor.addFamily(hColumnDescriptor);
                }
                // 提交
                admin.createTable(hTableDescriptor);
                System.out.println(tableName + " 表创建成功！");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }
}

AlterTable

public class AlterTable {
    private static Logger logger = LoggerFactory.getLogger(AlterTable.class);

    public static void main(String[] args) {
        listColumnFamily("myns01:user_info");
        //addColumnFamilies("myns01:user_info", "newCF1", "newCF2");
        //deleteColumnFamilies("myns01:user_info", "newCF1", "newCF2");
        //truncateTable("myns01:user_info");
        addColumnFamilies("myns01:user_info", "newCF1");
        listColumnFamily("myns01:user_info");
        deleteColumnFamily("myns01:user_info", "newCF1");
    }

    public static void listColumnFamily(String tableName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                HTableDescriptor hTableDescriptor = admin.getTableDescriptor(tn);
                HColumnDescriptor[] hColumnDescriptors = hTableDescriptor.getColumnFamilies();
                for (HColumnDescriptor hColumnDescriptor : hColumnDescriptors) {
                    System.out.println(hColumnDescriptor.getNameAsString());
                    System.out.println(hColumnDescriptor.getBlocksize());
                    System.out.println(hColumnDescriptor.getBloomFilterType());
                }
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }

    public static void addColumnFamilies(String tableName, String... columnFamilyName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                HTableDescriptor hTableDescriptor = admin.getTableDescriptor(tn);
                int len = columnFamilyName.length;
                for (int i = 0; i < len; i++) {
                    HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(columnFamilyName[i].getBytes());
                    // 设置列簇版本从1到5,默认为3
                    hColumnDescriptor.setVersions(1, 5);
                    // setBloomFilterType
                    hColumnDescriptor.setBloomFilterType(BloomType.ROW);
                    // 设置HBase数据存放的副本数
                    //columnDescriptor.setDFSReplication(3);
                    // 将列簇添加到表中
                    hTableDescriptor.addFamily(hColumnDescriptor);
                }
                // 提交
                admin.modifyTable(tn, hTableDescriptor);
                System.out.println(tableName + " 表列簇添加成功！");
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }

    public static void deleteColumnFamilies(String tableName, String... columnFamilyName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                HTableDescriptor hTableDescriptor = admin.getTableDescriptor(tn);
                int len = columnFamilyName.length;
                for (int i = 0; i < len; i++) {
                    //HColumnDescriptor columnDescriptor =
                    hTableDescriptor.removeFamily(columnFamilyName[i].getBytes());
                }
                admin.modifyTable(tn, hTableDescriptor);
                System.out.println(tableName + " 表列簇删除成功！");
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }

    public static void deleteColumnFamily(String tableName, String columnFamilyName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                admin.deleteColumn(tn, columnFamilyName.getBytes());
                System.out.println(tableName + " 表列簇删除成功！");
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }

    public static void truncateTable(String tableName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                if (admin.isTableEnabled(tn)) {
                    admin.disableTable(tn);
                }
                admin.truncateTable(tn, true);
                System.out.println(tableName + " 表清空成功！");
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }
}

DeleteTable

public class DeleteTable {
    private static Logger logger = LoggerFactory.getLogger(DeleteTable.class);
    public static void main(String[] args) {
        deleteTable("myns01:user_info.tmp");
    }

    public static void deleteTable(String tableName) {
        Admin admin = HBaseUtils.getAdmin();
        TableName tn = TableName.valueOf(tableName);
        try {
            if (admin.tableExists(tn)) {
                if (admin.isTableEnabled(tn)) {
                    admin.disableTable(tn);
                }
                admin.deleteTable(tn);
                System.out.println(tableName + " 表删除成功！");
            } else {
                System.out.println("Table : " + tn + " is not exists !");
            }
        } catch (IOException e) {

        } finally {
            HBaseUtils.close(admin);
        }
    }
}

PutDemo

public class PutDemo {
    private static Logger logger = LoggerFactory.getLogger(PutDemo.class);

    public static void main(String[] args) {
        //insertRecord("myns01:user_info", "rk001", "base_info", "name", "张三丰");
        //insertRecord("myns01:user_info", "rk001", "base_info", "name", "张四丰");
        insertRecords("myns01:user_info", "rk00", "base_info");
    }

    public static void insertRecord(String tableName, String rowKey, String columnFamily, String qualifier, String value) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Put row = new Put(rowKey.getBytes());
            row.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier), Bytes.toBytes(value));
            //put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(qualifier), Bytes.toBytes(value));
            table.put(row);
            System.out.println(tableName + " 表插入数据成功！");
        } catch (Exception e) {
            System.out.println(tableName + " 表插入数据失败！");
            e.printStackTrace();
        } finally {
            HBaseUtils.closeTable(table);
        }
    }

    public static void insertRecords(String tableName, String rowKey, String columnFamily) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            List<Put> rows = new ArrayList<Put>();
            String sex;
            for (int i = 0; i < 20; i++) {
                Put row = new Put((rowKey + i).getBytes());
                row.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("name"), Bytes.toBytes("李哥Faker" + i));
                row.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("age"), Bytes.toBytes(String.valueOf(i + 18)));
                if (i % 2 == 0) sex = "fmale";
                else sex = "male";
                row.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes("sex"), Bytes.toBytes(sex));
                //row.add(new KeyValue());
                rows.add(row);
            }
            table.put(rows);
            System.out.println(tableName + " 表插入数据成功！");
        } catch (Exception e) {
            System.out.println(tableName + " 表插入数据失败！");
            e.printStackTrace();
        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

GetDemo

public class GetDemo {
    private static Logger logger = LoggerFactory.getLogger(GetDemo.class);

    public static void main(String[] args) {
        //getOneRecord("myns01:user_info", "rk004");
        getRecords("myns01:user_info", 0, 10);
    }

    public static Result getOneRecord(String tableName, String rowKey) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Get get = new Get(rowKey.getBytes());
            Result rs = table.get(get);

            System.out.println(tableName + " 表获取数据成功！");
            System.out.println("RowKey为 : " + rowKey);

            List<Cell> cells = rs.listCells();
            for (Cell cell : cells) {
                System.out.println(Bytes.toString(cell.getRow())
                        + "--" + Bytes.toString(cell.getFamily())
                        + "--" + Bytes.toString(cell.getQualifier())
                        + "--" + cell.getTimestamp()
                        + " : " + Bytes.toString(cell.getValue()));
            }
            return rs;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            HBaseUtils.closeTable(table);
        }
    }

    public static Result[] getRecords(String tableName, int startRow, int num) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            List<Get> gets = new ArrayList<Get>();
            for (int i = startRow; i < num; i++) {
                Get get = new Get(Bytes.toBytes("rk00" + i));
                gets.add(get);
            }
            Result[] rss = table.get(gets);

            System.out.println(tableName + " 表获取数据成功！");

            for (Result rs : rss) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "--" + Bytes.toString(cell.getFamily())
                            + "--" + Bytes.toString(cell.getQualifier())
                            + "--" + cell.getTimestamp()
                            + " : " + Bytes.toString(cell.getValue()));
                }
            }
            return rss;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

ScanDemo

public class ScanDemo {
    private static Logger logger = LoggerFactory.getLogger(ScanDemo.class);

    public static void main(String[] args) {
        //getAll("myns01:user_info");
        get("myns01:user_info", "base_info", "name", "rk000", "rk005");
    }

    public static List<Result> getAll(String tableName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            ResultScanner results = table.getScanner(scan);
            System.out.println(tableName + " 表获取数据成功！");
            List<Result> list = new ArrayList<Result>();
            for (Result rs : results) {
                list.add(rs);
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "--" + Bytes.toString(cell.getFamily())
                            + "--" + Bytes.toString(cell.getQualifier())
                            + "--" + cell.getTimestamp()
                            + " : " + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
            System.out.println(tableName + " 表获取所有记录成功！");
            return list;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            HBaseUtils.closeTable(table);
        }
    }

    public static List<Result> get(String tableName, String family, String qualifier, String startRow, String stopRow) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            scan.setStartRow(Bytes.toBytes(startRow));
            scan.setStopRow(Bytes.toBytes(stopRow + "\001"));
            scan.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            //scan.getBatch(); //?????????
            ResultScanner results = table.getScanner(scan);
            System.out.println(tableName + " 表获取数据成功！");
            List<Result> list = new ArrayList<Result>();
            for (Result rs : results) {
                list.add(rs);
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "--" + Bytes.toString(cell.getFamily())
                            + "--" + Bytes.toString(cell.getQualifier())
                            + "--" + cell.getTimestamp()
                            + " : " + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
            System.out.println(tableName + " 表获取所有记录成功！");
            return list;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

DeleteDemo

public class DeleteDemo {
    private static Logger logger = LoggerFactory.getLogger(DeleteDemo.class);

    public static void main(String[] args) {
        deleteRecord("myns01:user_info", "rk0014");
    }

    public static void deleteRecord(String tableName, String rowKey) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Delete del = new Delete(rowKey.getBytes());
            table.delete(del);
            System.out.println(tableName + " 表删除数据成功！");
        } catch (IOException e) {
            System.out.println(tableName + " 表删除数据失败！");
            e.printStackTrace();
        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

Filter

抽象操作符（比较运算符）

LESS <

LESS_OR_EQUAL <=

EQUAL =

NOT_EQUAL <>

GREATER_OR_EQUAL >=

GREATER >

NO_OP 排除所有

比较器（指定比较机制）

BinaryComparator 按字节索引顺序比较指定字节数组，采用 Bytes.compareTo(byte[])

BinaryPrefixComparator 跟前面相同，只是比较左端的数据是否相同

NullComparator 判断给定的是否为空

BitComparator 按位比较

RegexStringComparator 提供一个正则的比较器，仅支持 EQUAL 和非 EQUAL

SubstringComparator 判断提供的子串是否出现在 value 中

RowFilter

public class RowFilterDemo {
    public static void main(String[] args) {
        rowFilterDemo("myns01:user_info");
    }

    // 行过滤器
    public static void rowFilterDemo(String tableName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            Filter rowFilter = new RowFilter(CompareFilter.CompareOp.GREATER_OR_EQUAL, new BinaryComparator("rk003".getBytes()));
            scan.setFilter(rowFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + "\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

FamilyFilter

public class FamilyFilterDemo {
    public static void main(String[] args) {
        familyFilterDemo("myns01:user_info", "base_info");
    }

    // 列簇过滤器
    public static void familyFilterDemo(String tableName, String familyName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            Filter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(familyName.getBytes()));
            scan.setFilter(familyFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

QualifierFilter

public class QualifierFilterDemo {
    public static void main(String[] args) {
        qualifierFilterDemo("myns01:user_info", "name");
    }

    // 列过滤器
    public static void qualifierFilterDemo(String tableName, String qualifierName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            Filter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(qualifierName.getBytes()));
            scan.setFilter(qualifierFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

TimestampsFilter

public class TimestampsFilterDemo {
    public static void main(String[] args) {
        timestampsFilterDemo("myns01:user_info", 571836136913L);
    }

    // 时间戳过滤器
    public static void timestampsFilterDemo(String tableName, Long... timestamp) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            List<Long> list = new ArrayList<Long>();
            for (int i = 0; i < timestamp.length; i++) {
                list.add(timestamp[i]);
            }
            Filter timestampsFilter = new TimestampsFilter(list);
            scan.setFilter(timestampsFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

ValueFilter

public class ValueFilterDemo {
    public static void main(String[] args) {
        valueFilterDemo("myns01:user_info", "fmale");
    }

    // 值过滤器
    public static void valueFilterDemo(String tableName, String valueName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            Filter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(valueName.getBytes()));
            scan.setFilter(valueFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

PrefixFilter

public class PrefixFilterDemo {
    public static void main(String[] args) {
        prefixFilter("myns01:user_info", "rk000");
    }

    // 行前缀过滤器
    public static void prefixFilter(String tableName, String prefix) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            PrefixFilter prefixFilter = new PrefixFilter(prefix.getBytes());
            scan.setFilter(prefixFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

ColumnPrefixFilter

public class ColumnPrefixFilterDemo {
    public static void main(String[] args) {
        columnPrefixFilter("myns01:user_info", "ag");
    }

    // 列前缀过滤器
    public static void columnPrefixFilter(String tableName, String columnPrefix) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(columnPrefix.getBytes());
            scan.setFilter(columnPrefixFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

SingleColumnValueFilter

public class SingleColumnValueFilterDemo {
    public static void main(String[] args) {
        singleColumnValueFilter("myns01:user_info", "base_info", "name");
    }

    // 单列值过滤器
    public static void singleColumnValueFilter(String tableName, String familyName, String columnName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();

            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(familyName.getBytes(), columnName.getBytes(),
                    CompareFilter.CompareOp.EQUAL, new SubstringComparator("1"));
            //如果不设置为 true，则那些不包含指定 column 的行也会返回
            singleColumnValueFilter.setFilterIfMissing(true);

            scan.setFilter(singleColumnValueFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

SingleColumnValueExcludeFilter

public class SingleColumnValueExcludeFilterDemo {
    public static void main(String[] args) {
        singleColumnValueExcludeFilter("myns01:user_info", "base_info", "name");
    }

    // 单列值排除器(先选择，再去除指定列)
    public static void singleColumnValueExcludeFilter(String tableName, String familyName, String columnName) {
        Table table = HBaseUtils.getTable(tableName);
        try {
            Scan scan = new Scan();
            SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = new SingleColumnValueExcludeFilter(familyName.getBytes(), columnName.getBytes(),
                    CompareFilter.CompareOp.EQUAL, new SubstringComparator("Faker0"));
            singleColumnValueExcludeFilter.setFilterIfMissing(true);
            scan.setFilter(singleColumnValueExcludeFilter);
            ResultScanner results = table.getScanner(scan);
            for (Result rs : results) {
                List<Cell> cells = rs.listCells();
                for (Cell cell : cells) {
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
            }
            results.close();
        } catch (IOException e) {

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}

PageFilter

过滤器链Demo

public class MixFilterDemo {
    public static void main(String[] args) {
        mixFilter("myns01:user_info");
    }
    // 过滤器链
    public static void mixFilter(String tableName){
        Table table = HBaseUtils.getTable(tableName);
        FilterList filterList1 = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        FilterList filterList2 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
        // select * user_info where age <= 22 and name not like '1' or sex != M
        SingleColumnValueFilter ageFilter = new SingleColumnValueFilter(
                Bytes.toBytes("base_info"), Bytes.toBytes("age"),
                CompareFilter.CompareOp.LESS_OR_EQUAL, Bytes.toBytes("22"));

        SingleColumnValueFilter nameFilter = new SingleColumnValueFilter(
                Bytes.toBytes("base_info"), Bytes.toBytes("name"),
                CompareFilter.CompareOp.NOT_EQUAL, new SubstringComparator("1"));

        SingleColumnValueFilter sexFilter = new SingleColumnValueFilter(
                Bytes.toBytes("base_info"), Bytes.toBytes("sex"),
                CompareFilter.CompareOp.EQUAL, new SubstringComparator("fmale"));
        filterList1.addFilter(ageFilter);
        filterList1.addFilter(nameFilter);
        filterList2.addFilter(filterList1);
        filterList2.addFilter(sexFilter);
        try {
            Scan scan = new Scan();
            scan.setFilter(filterList2);
            ResultScanner scanner = table.getScanner(scan);
            for(Result rs : scanner){
                List<Cell> cells = rs.listCells();
                for(Cell cell : cells){
                    System.out.println(Bytes.toString(cell.getRow())
                            + "\t" + Bytes.toString(cell.getFamily())
                            + "\t" + Bytes.toString(cell.getQualifier())
                            + "\t" + cell.getTimestamp()
                            + ":\t" + Bytes.toString(cell.getValue()));
                }
          }
        } catch (IOException e){

        } finally {
            HBaseUtils.closeTable(table);
        }
    }
}