HBase使用API实例操作（学生管理系统）

HBase API 操作实例演示

所有实例都是基于课堂上老师的教学演示，希望大家好好听课，好好学习
如果老师画饼的话那就自己查资料，自己学（基本都靠自学🙄，遇到好老师一定要好好珍惜）

一、准备工作

1、VM虚拟机

这东西应该是学习分布式必备的东西了吧，除非你有好几台电脑（土豪可以忽略）

2、Xshell、Xftp

使用教程：Xshell、Xftp使用教程

3、Idea

这个不用多说了吧，最好用的java编译器不接受反驳

4、jar包

操作HBase需要安装jar包，idea创建maven工程后pom.xml配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>15</maven.compiler.source>
        <maven.compiler.target>15</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>2.1.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.1.9</version>
        </dependency>
    </dependencies>
</project>

主要就是两个包

• hbase-server
• hbase-client

下载的时间比较长，不要中途关idea

二、使用API操作

在使用API操作HBase库时，先确定你的虚拟机配置已经完成，并且在输入jps后显示所有的9个服务，这里就不多赘述，默认读者已经可以进入hbase shell进行一些基础的操作流程。

1、配置文件

将虚拟机中HBase的配置文件core-site.xml,hbase-site.xml通过Xftp拉到你的Windows上，然后加入你java工程中的resources目录。

因为API的连接接口会默认在这个文件夹中寻找你的配置文件，所以只有这个配置文件没有问题你才可以在之后的操作中成功的连接HBase

2、连接HBase

这里我创建了一个HBaseHelper的类，用来存放我的函数，方便调用。之后的增删查改、分页都会在该类中编写对应的函数。

//创建连接
public static Connection GetConn() throws IOException{
        Configuration conf = HBaseConfiguration.create();
        return ConnectionFactory.createConnection(conf);
    }

在main函数中调用这个函数就能连接上HBase

3、创建命名空间、表名、列族

	//操作对象封装
    public static Admin GetAdmin() throws IOException{
        return GetConn().getAdmin();
    }
    //创建命名空间
    public static boolean Exec_CreateNamesplace(String namesplace) throws  IOException{
        try{
            GetAdmin().getNamespaceDescriptor(namesplace);
            return true;
        }
        catch (NamespaceNotFoundException exception){
            NamespaceDescriptor build = NamespaceDescriptor.create(namesplace).build();
            GetAdmin().createNamespace(build);
            return true;
        }catch (IOException e){
            e.printStackTrace();
        }
        return false;
    }
    //创建表
    public static boolean Exec_CreateTable(String tableName,String family) throws IOException {
        //查询该表是否存在
        TableName Tname = TableName.valueOf(tableName);
        if(!GetAdmin().tableExists(Tname)){
            //如果不存在
            HTableDescriptor hTableDescriptor = new HTableDescriptor(Tname);        //创建表名
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(family);    //创建列族
            hTableDescriptor.addFamily(hColumnDescriptor);                          //将列族添加
            GetAdmin().createTable(hTableDescriptor);                               //创建表
            return true;
        }
        else {
            return false;
        }
    }

测试
一、不封装函数操作

public class connect_hbase {
    public static void main(String[] args) throws IOException {

        System.out.println("开始连接HBase...");
        //加载配置信息，连接HBase

        Configuration conf = HBaseConfiguration.create();
        Connection connection = ConnectionFactory.createConnection(conf);
        System.out.println("连接成功！");
        //获取操作对象
        Admin admin = connection.getAdmin();

        //判断是否存在Myschool的命名空间
        try{
            //尝试获取Myschool命名空间
            System.out.println("尝试获取Myschool命名空间...");
            admin.getNamespaceDescriptor("Myschool");
            System.out.println("已找到该命名空间，开始添加数据...");
        }catch (NamespaceNotFoundException ex){
            //没有就创建
            System.out.println("没有该命名空间，创建新的命名空间...");
            NamespaceDescriptor myschool = NamespaceDescriptor.create("Myschool").build();
            admin.createNamespace(myschool);
            System.out.println("创建Myschool成功！");
        }
    }
}

二、封装函数操作

public class connect_hbase {
    public static void main(String[] args) throws IOException {
        System.out.println("开始连接HBase...");
        //连接HBase
        HBaseHelper.GetConn();
        //获取操作对象
        HBaseHelper.
		System.out.println("连接成功！");
		HBaseHelper.Exec_CreateNamesplace("Myschool");
        HBaseHelper.Exec_CreateTable("Myschool:myschool","info");
		System.out.println("创建成功！");	
    }
}

可以看到封装之后调用起来更加简单便捷

4、添加数据

增删查改中，函数都没有加入输出，如果你需要查看结果可以自己sout一下，或者在hbase shell中查看

//插入数据，传参分别对应表民、列族、行键、列名、插入值
    public static boolean Exec_AddData(String Tname,String family,String rowkey,String column,String value){
        try {
            Put put = new Put(Bytes.toBytes(rowkey));
            put.addColumn(Bytes.toBytes(family), Bytes.toBytes(column), Bytes.toBytes(value));
            TableName tableName = TableName.valueOf(Tname);
            GetConn().getTable(tableName).put(put);
            return true;
        } catch (IOException e) {
            return false;
        }
    }

5、查询数据

5.1、查询整行数据

//查询数据
    public static Result Exec_GetDataByRowKey(String tname, String rowkey) throws IOException{
        Get get = new Get(Bytes.toBytes(rowkey));
        TableName tableName = TableName.valueOf(tname);
        Result result = GetConn().getTable(tableName).get(get);
        if(result.isEmpty()){
            return result;
        }else{
            return result;
        }
    }

5.2、查询单个数据

//查询单个数据
    public static  Result Exec_GetCell(String tname,String info,String rowkey,String column) throws IOException {
        Result result = Exec_GetDataByRowKey(tname,rowkey);
        if (!result.isEmpty()){
            Get get = new Get(Bytes.toBytes(rowkey));
            get.addColumn(Bytes.toBytes(info),Bytes.toBytes(column));
            return GetConn().getTable(TableName.valueOf(tname)).get(get);
        }else {
            return result;
        }
    }

5.2、通过单个数据查询整行数据

	//按照姓名查询
    public static void Exec_FilerAllName(String family,String Name) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, Bytes.toBytes(Name));
        scan.setFilter(singleColumnValueFilter);
        printOutput(scan);
    }

    //按照电话查询
    public static void Exec_FilerPhone(String tableName, String family, String Phone) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter phone = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("phone"), CompareFilter.CompareOp.EQUAL, Bytes.toBytes(Phone));
        scan.setFilter(phone);
        printOutput(scan);
    }
	//输出函数
    public static void printOutput(Scan scan) throws IOException {
        /*
         封装print函数，减少上面代码冗余
         */
        // 获取表名
        String tName = tableName;
        Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tName));
        // 在表上进行查询数据
        ResultScanner scannerResult = table.getScanner(scan);
        // 对数据进行遍历
        for (Result result : scannerResult) {
            System.out.println("--------------------------------");
            for (Cell cell : result.rawCells()) {
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell)) + "：" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }

可以看到，通过某一个值，我可以返还该值所在的行，并对该行的所有信息进行输出

6、删除数据

6.1、删除整行数据

//删除数据（整行）
    public static boolean Exce_DelByRowkey(String tablename,String rowkey) throws IOException {
        Result result = Exec_GetDataByRowKey(tablename,rowkey);
        //判断result是否获取到
        if (!result.isEmpty()){
            Delete delete = new Delete(Bytes.toBytes(rowkey));
            GetConn().getTable(TableName.valueOf(tablename)).delete(delete);
            return true;
        }else {
            return false;
        }
    }

6.2删除单个数据

 //删除（单个）
    public static boolean Exce_DelCell(String tablename,String info,String rowkey,String column) throws IOException {
        Result result = Exec_GetDataByRowKey(tablename,rowkey);
        if (!result.isEmpty()){
            Delete delete = new Delete(Bytes.toBytes(rowkey));
            delete.addColumn(Bytes.toBytes(info),Bytes.toBytes(column));
            GetConn().getTable(TableName.valueOf(tablename)).delete(delete);
            return true;
        }else {
            return false;
        }
    }

7、修改数据

修改数据的本质

• 先删除数据再添加数据
• 直接使用函数添加数据，将原先的数据覆盖

这里交给读者自己来实践一下，通过调用上文的函数可以非常简单的实现

8、过滤器

你可以简单的理解为查询的升级版；举例来说，如果数据库中有20个人重名，你该怎么办？又或者，你需要怎样才能找出rowkey为1开头的用户信息？你怎样才能知道张姓的用户有多少？

8.1、rowkey模糊查询

//过滤器，查看rowkey是xxx开头的数据
    public static void Exec_FilerRow(String tableName, String LessNumber) throws IOException {
        Scan scan = new Scan();
        //创建过滤器实体,BinaryPrefixComparator的意义就是从左往右进行匹配（模糊查询）
        Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(LessNumber.getBytes()));
        //将filter实体放入扫描实体
        scan.setFilter(filter);
        //创建扫描返回类
        ResultScanner resultScanner = HBaseHelper.GetConn().getTable(TableName.valueOf(tableName)).getScanner(scan);
        //输出查看查询结果
        for(Result result : resultScanner) {
            List<Cell> cells = result.listCells();
            System.out.println("---------------------------------");
            for (Cell cell : cells) {
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell)) + "：" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }

8.2、value值模糊查询

    //按照姓氏查询  
    public static void Exec_FilerName(String family,String Name) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes(Name)));
        scan.setFilter(singleColumnValueFilter);
        printOutput(scan);
    }

大家可以看到，BinaryPrefixComparator就是模糊查询的关键，它会进行从左往右的匹配

8.3、多个过滤器组合查询

这里给出一段代码，大家可以体会一下

FilterList allFilters = new FilterList(FilterList.Operator.MUST_PASS_ALL);
allFilters.addFilter(new PrefixFilter(Bytes.toBytes("abc")));
allFilters.addFilter(new RowFilter(CompareFilter.CompareOp.EQUAL,
            new RegexStringComparator(".*_(xyz|xxx)$"));
allFilters.addFilter(new QualifierFilter(CompareFilter.CompareOp.EQUAL,
            new SubstringComparator("china")));
scan.setFilter(allFilters);

一共有两个参数

• MUST_PASS_ALL
• MUST_PASS_ONE

MUST_PASS_ALL ：必须匹配所有的过滤器
MUST_PASS_ONE ：任意一个匹配

9、分页

可以仔细看一下注释

public class PageDemo {
    // 扫描结果，返回结果中的最后一条数据
    // ResultScanner 查询结果
    public static byte[] printResult(ResultScanner rs) {
        // 遍历查询结果，并得到最后一条数据，副值为lastRowKey
        byte[] lastRowKey = null;
        for (Result r : rs) {
            byte[] rowKey = r.getRow();
            String name = Bytes.toString(r.getValue(Bytes.toBytes("info1"), Bytes.toBytes("name")));
            String price = Bytes.toString(r.getValue(Bytes.toBytes("info1"), Bytes.toBytes("price")));
            String type = Bytes.toString(r.getValue(Bytes.toBytes("info2"), Bytes.toBytes("type")));
            String outStr = "编号: " + StringUtils.rightPad(Bytes.toString(rowKey), 5, " ") + " 书名: " + StringUtils.rightPad(name, 8, " ") + " 价格: " + StringUtils.rightPad(price, 8, " ") + " 类型: " + StringUtils.rightPad(type, 8, " ");
            System.out.println(outStr);
            lastRowKey = rowKey;
        }
        return lastRowKey;
    }

    public static void main(String[] args) throws IOException {
        PageFilter pageFilter = new PageFilter(2);//决定你每页需要几个数据，需要10个就输入10
        Scan scan = new Scan();
        scan.setFilter(pageFilter);
        // 获取表名
        String tableName = "bb";
        Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tableName));
        // 在表上进行查询第一页数据
        ResultScanner scannerResultPage1 = table.getScanner(scan);
        System.out.println("现在开始打印第一页：");
        byte[] lastRowKeyPage1 = printResult(scannerResultPage1);
        scannerResultPage1.close();
        // System.out.println(Bytes.toString(lastRowKeyPage1)); // 输出:102

        // 为scan设置开始行 startRowKey
        System.out.println("现在开始打印第二页：");
        // hbase排序是根据ascii来排序的，首先是101([49,48,49]),
        //      然后你往前加一个字节，他就匹配不到101因为比101多一点，所以就会匹配101的下一个值
        //        数据 101,101000000001,10100001,1011,10199999999,102排序如下：
        //         -> 101
        //         -> 101000000001
        //         -> 10100001
        //         -> 1011
        //         -> 101999999999
        //         -> 102
        //      如果你加一个字节刚好能匹配上，即下一个值，那么他就会直接打印这一条数据
        byte[] startRowKey = Bytes.add(lastRowKeyPage1, new byte[1]);
        scan.setStartRow(startRowKey);
        // 在表上进行查询第一页数据
        ResultScanner scannerResultPage2 = table.getScanner(scan);
        byte[] lastRowKeyPage2 = printResult(scannerResultPage2);

    }
}

三、一个简单的控制台学生信息管理系统

1、添加数据

这里选择了一种比较笨的方法。我也有写自动导入excel的函数，但是感觉大家应该用不到，这里就不放上来了

public class addData {
    static String tableName = "school";
    static String family= "info";
    public static void main(String[] args) throws IOException {
        HBaseHelper.Exec_CreateNamesplace(tableName);
        HBaseHelper.Exec_CreateTable(tableName, family);
        HBaseHelper.Exec_AddData(tableName,family,"001","name","张三");
        HBaseHelper.Exec_AddData(tableName,family,"001","phone","123489652");
        HBaseHelper.Exec_AddData(tableName,family,"001","address","江苏苏州张家港");
        HBaseHelper.Exec_AddData(tableName,family,"001","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"002","name","李四");
        HBaseHelper.Exec_AddData(tableName,family,"002","phone","123165498721");
        HBaseHelper.Exec_AddData(tableName,family,"002","address","江苏苏州昆山");
        HBaseHelper.Exec_AddData(tableName,family,"002","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"003","name","王五");
        HBaseHelper.Exec_AddData(tableName,family,"003","phone","21964794316");
        HBaseHelper.Exec_AddData(tableName,family,"003","address","福建福州宁德");
        HBaseHelper.Exec_AddData(tableName,family,"003","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"014","name","赵六");
        HBaseHelper.Exec_AddData(tableName,family,"014","phone","666666");
        HBaseHelper.Exec_AddData(tableName,family,"014","address","安徽黄山");
        HBaseHelper.Exec_AddData(tableName,family,"014","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"004","name","赵六他爹");
        HBaseHelper.Exec_AddData(tableName,family,"004","phone","2196454854");
        HBaseHelper.Exec_AddData(tableName,family,"004","address","安徽黄山");
        HBaseHelper.Exec_AddData(tableName,family,"004","sex","女");
        HBaseHelper.Exec_AddData(tableName,family,"005","name","小兔");
        HBaseHelper.Exec_AddData(tableName,family,"005","phone","464132418");
        HBaseHelper.Exec_AddData(tableName,family,"005","address","重庆梁平");
        HBaseHelper.Exec_AddData(tableName,family,"005","sex","女");
        HBaseHelper.Exec_AddData(tableName,family,"006","name","奥特曼");
        HBaseHelper.Exec_AddData(tableName,family,"006","phone","？");
        HBaseHelper.Exec_AddData(tableName,family,"006","address","M78星云");
        HBaseHelper.Exec_AddData(tableName,family,"006","sex","未知");
        HBaseHelper.Exec_AddData(tableName,family,"016","name","李四");
        HBaseHelper.Exec_AddData(tableName,family,"016","phone","123123123");
        HBaseHelper.Exec_AddData(tableName,family,"016","address","北京");
        HBaseHelper.Exec_AddData(tableName,family,"016","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"025","name","德里克罗斯");
        HBaseHelper.Exec_AddData(tableName,family,"025","phone","2196454854");
        HBaseHelper.Exec_AddData(tableName,family,"025","address","芝加哥");
        HBaseHelper.Exec_AddData(tableName,family,"025","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"011","name","陈奕迅");
        HBaseHelper.Exec_AddData(tableName,family,"011","phone","520");
        HBaseHelper.Exec_AddData(tableName,family,"011","address","香港");
        HBaseHelper.Exec_AddData(tableName,family,"011","sex","男");
        HBaseHelper.Exec_AddData(tableName,family,"012","name","陈冠希");
        HBaseHelper.Exec_AddData(tableName,family,"012","phone","300");
        HBaseHelper.Exec_AddData(tableName,family,"012","address","香港");
        HBaseHelper.Exec_AddData(tableName,family,"012","sex","男");
    }
}

2、HBaseHelper

public class HBaseHelper {
    static String tableName = "school";
    //创建连接
    public static Connection GetConn() throws IOException{
        Configuration conf = HBaseConfiguration.create();
        return ConnectionFactory.createConnection(conf);
    }
    //操作对象封装
    public static Admin GetAdmin() throws IOException{
        return GetConn().getAdmin();
    }
    //创建命名空间
    public static boolean Exec_CreateNamesplace(String namesplace) throws  IOException{
        try{
            GetAdmin().getNamespaceDescriptor(namesplace);
            return true;
        }
        catch (NamespaceNotFoundException exception){
            NamespaceDescriptor build = NamespaceDescriptor.create(namesplace).build();
            GetAdmin().createNamespace(build);
            return true;
        }catch (IOException e){
            e.printStackTrace();
        }
        return false;
    }
    //创建表
    public static boolean Exec_CreateTable(String tableName,String family) throws IOException {
        //查询该表是否存在
        TableName Tname = TableName.valueOf(tableName);
        if(!GetAdmin().tableExists(Tname)){
            //如果不存在
            HTableDescriptor hTableDescriptor = new HTableDescriptor(Tname);        //创建表名
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(family);    //创建列族
            hTableDescriptor.addFamily(hColumnDescriptor);                          //将列族添加
            GetAdmin().createTable(hTableDescriptor);                               //创建表
            return true;
        }
        else {
            return false;
        }
    }
    //插入数据
    public static boolean Exec_AddData(String Tname,String family,String rowkey,String column,String value){
        try {
            Put put = new Put(Bytes.toBytes(rowkey));
            put.addColumn(Bytes.toBytes(family), Bytes.toBytes(column), Bytes.toBytes(value));
            TableName tableName = TableName.valueOf(Tname);
            GetConn().getTable(tableName).put(put);
            return true;
        } catch (IOException e) {
            return false;
        }
    }
    //查询数据
    public static Result Exec_GetDataByRowKey(String tname, String rowkey) throws IOException{
        Get get = new Get(Bytes.toBytes(rowkey));
        TableName tableName = TableName.valueOf(tname);
        Result result = GetConn().getTable(tableName).get(get);
        if(result.isEmpty()){
            return result;
        }else{
            return result;
        }
    }
    //查询单个数据
    public static  Result Exec_GetCell(String tname,String info,String rowkey,String column) throws IOException {
        Result result = Exec_GetDataByRowKey(tname,rowkey);
        if (!result.isEmpty()){
            Get get = new Get(Bytes.toBytes(rowkey));
            get.addColumn(Bytes.toBytes(info),Bytes.toBytes(column));
            return GetConn().getTable(TableName.valueOf(tname)).get(get);
        }else {
            return result;
        }
    }

    //删除数据（整行）
    public static boolean Exce_DelByRowkey(String tablename,String rowkey) throws IOException {
        Result result = Exec_GetDataByRowKey(tablename,rowkey);
        if (!result.isEmpty()){
            Delete delete = new Delete(Bytes.toBytes(rowkey));
            GetConn().getTable(TableName.valueOf(tablename)).delete(delete);
            return true;
        }else {
            return false;
        }
    }

    //删除（单个）
    public static boolean Exce_DelCell(String tablename,String info,String rowkey,String column) throws IOException {
        Result result = Exec_GetDataByRowKey(tablename,rowkey);
        if (!result.isEmpty()){
            Delete delete = new Delete(Bytes.toBytes(rowkey));
            delete.addColumn(Bytes.toBytes(info),Bytes.toBytes(column));
            GetConn().getTable(TableName.valueOf(tablename)).delete(delete);
            return true;
        }else {
            return false;
        }
    }

    //删除表名
    public static boolean Exec_DelNamesplace(String tablename) throws IOException {
        TableName tableName = TableName.valueOf(tablename);
        System.out.println("确定永久删除表？(y/n)");
        Scanner scanner = new Scanner(System.in);
        String result = scanner.next();
        if("y".equals(result)) {
            GetAdmin().disableTable(tableName);
            GetAdmin().deleteTable(tableName);
            return true;
        }
        else {
            return false;
        }
    }

    //过滤器，查看学号是00开头的数据
    public static void Exec_FilerRow(String tableName, String LessNumber) throws IOException {
        Scan scan = new Scan();
        //创建过滤器实体
        Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(LessNumber.getBytes()));
        //将filter实体放入扫描实体
        scan.setFilter(filter);
        //创建扫描返回类
        ResultScanner resultScanner = HBaseHelper.GetConn().getTable(TableName.valueOf(tableName)).getScanner(scan);
        for(Result result : resultScanner) {
            List<Cell> cells = result.listCells();
            System.out.println("---------------------------------");
            for (Cell cell : cells) {
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell)) + "：" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }

    //按照姓名查询
    public static void Exec_FilerAllName(String family,String Name) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, Bytes.toBytes(Name));
        scan.setFilter(singleColumnValueFilter);
        printOutput(scan);
    }

    //按照电话查询
    public static void Exec_FilerPhone(String tableName, String family, String Phone) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter phone = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("phone"), CompareFilter.CompareOp.EQUAL, Bytes.toBytes(Phone));
        scan.setFilter(phone);
        printOutput(scan);
    }

    //按照姓氏查询  new BinaryPrefixComparator(Bytes.toBytes(Name))
    public static void Exec_FilerName(String family,String Name) throws IOException {
        Scan scan = new Scan();
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes("name"), CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes(Name)));
        scan.setFilter(singleColumnValueFilter);
        printOutput(scan);
    }

    //输出
    public static void printOutput(Scan scan) throws IOException {
        /*
         封装print函数，减少上面代码冗余
         */
        // 获取表名
        String tName = tableName;
        Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tName));
        // 在表上进行查询数据
        ResultScanner scannerResult = table.getScanner(scan);
        // 对数据进行遍历
        for (Result result : scannerResult) {
            System.out.println("--------------------------------");
            for (Cell cell : result.rawCells()) {
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell)) + "：" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }

    //分页
    public static void Exec_PageFiler(String tableName, long number,long page) throws IOException {
        PageFilter pageFilter = new PageFilter(number);
        Scan scan = new Scan();
        scan.setFilter(pageFilter);
        // 获取表名
        String tName = tableName;
        Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tName));
        //循环输出分页后的数据
        for (int i = 1; i<=page ;i++ ){
            try {
                ResultScanner scanner = table.getScanner(scan);
                System.out.printf("现在开始打印第%d页：\n",i);
                byte[] lastRowKeyPage = printResult(scanner);
                byte[] startRowKey = Bytes.add(lastRowKeyPage, new byte[i]);
                scan.setStartRow(startRowKey);
                System.out.println(" ");
            }catch (Exception e){
                System.out.println("数据已打印完毕！");
                return;
            }
        }
    }

    //分页输出
    public static byte[] printResult(ResultScanner rs) {
        // 遍历查询结果，并得到最后一条数据，副值为lastRowKey
        byte[] lastRowKey = null;
        for (Result r : rs) {
            byte[] rowKey = r.getRow();
            String name = StringUtils.rightPad(Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("name"))),8," ");
            String sex = StringUtils.rightPad(Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("sex"))),4," ");
            String phone = StringUtils.rightPad(Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("phone"))),12," ");
            String address = StringUtils.rightPad(Bytes.toString(r.getValue(Bytes.toBytes("info"), Bytes.toBytes("address"))),10," ");
            String outStr = "学号: " + StringUtils.rightPad(Bytes.toString(rowKey), 5, " ") + " 姓名: " + StringUtils.rightPad(name, 15, " ") + " 性别: " + StringUtils.rightPad(sex, 8, " ") + "电话号码： " + StringUtils.rightPad(phone, 15, " ") + "地址： " + StringUtils.rightPad(address, 25, " ");
            System.out.println(outStr);
            lastRowKey = rowKey;
        }
        return lastRowKey;
    }

    //判断输入的查询条件是否存在
    public static boolean SearchHBase(String tableName,String family,String column,String value) throws IOException {
        Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tableName));
        Scan scan = new Scan();
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes(column), CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes(value)));
        scan.setFilter(singleColumnValueFilter);
        ResultScanner scannerResult = table.getScanner(scan);
        Result result = (Result) scannerResult;
        if(result.isEmpty()){
            System.out.println("判断为空");
            return false;
        }else {
            System.out.println("判断不为空");
            return true;
        }
    }
}

3、学生管理系统控制台

public class student_system {
    static String tableName = "school";
    static String family = "info";
    public static void main(String[] args) throws IOException {
        HBaseHelper.Exec_CreateNamesplace(tableName);
        HBaseHelper.Exec_CreateTable(tableName, family);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("================================");
            System.out.println("欢迎来到学生管理系统！(输入q退出程序)");
            System.out.println("1、注册学生信息");
            System.out.println("2、查找学生信息");
            System.out.println("3、删除学生信息");
            System.out.println("4、修改学生信息");
            System.out.println("5、学生信息分页");
            String choose = scanner.next();
            switch (choose) {
                case "1":
                    AddStu();
                    break;
                case "2":
                    GetStu();
                    break;
                case "3":
                    DelStu();
                    break;
                case "4":
                    Changestu();
                    break;
                case "5":
                    PageStu();
                    break;
                case "q":
                    return ;
            }
        }
    }
    public static void AddStu() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------------------");
        System.out.println("这里是学生注册功能界面");
        System.out.println("请输入学号：");
        //判断输入是否为数字，因为学号为key键，不可以出错
        if (scanner.hasNextInt()) {
            String key = scanner.next();
            Get get =  new Get(Bytes.toBytes(key));
            if (HBaseHelper.GetConn().getTable(TableName.valueOf(tableName)).get(get).isEmpty()){
                System.out.println("请输入姓名：");
                String name = scanner.next();
                System.out.println("请输入性别：");
                String  sex = scanner.next();
                System.out.println("请输入电话号码：");
                String phoneNumber = scanner.next();
                System.out.println("请输入地址：");
                String address = scanner.next();
                HBaseHelper.Exec_AddData(tableName,"info",key,"name",name);
                HBaseHelper.Exec_AddData(tableName,"info",key,"sex",sex);
                HBaseHelper.Exec_AddData(tableName,"info",key,"phone",phoneNumber);
                HBaseHelper.Exec_AddData(tableName,"info",key,"address",address);
                System.out.println("注册成功！");
            }else {
                System.out.println("该学号已经存在！");
            }
        }else {
            System.out.println("输入学号格式不正确，返回主界面！");
        }

    }
    //删除学生信息
    public static void DelStu() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------------------");
        System.out.println("这里是删除功能界面");
        System.out.println("请选择：1、删除整行学生信息 2、删除单个列");
        String choose = scanner.next();
        if(choose.equals("1")){
            System.out.println("输入删除学生的学号：");
            String key = scanner.next();
            Get get =  new Get(Bytes.toBytes(key));
            //判断学号是否存在
            if(HBaseHelper.GetConn().getTable(TableName.valueOf(tableName)).get(get).isEmpty()) {
                System.out.println("该学号不存在！");
            }else {
                boolean r = HBaseHelper.Exce_DelByRowkey(tableName, key);
                if (r) {
                    System.out.println("删除成功！");
                }
            }
        }
        else if (choose.equals("2")){
            System.out.println("输入删除学生的学号：");
            String key = scanner.next();
            Get get =  new Get(Bytes.toBytes(key));
            //判断学号是否存在
            if(HBaseHelper.GetConn().getTable(TableName.valueOf(tableName)).get(get).isEmpty()) {
                System.out.println("该学号不存在！");
            }else {
                System.out.println("输入需要删除的信息（姓名、性别、电话号码、地址）：");
                String delColumn = scanner.next();
                if (delColumn.equals("姓名")) {
                    boolean r = HBaseHelper.Exce_DelCell(tableName, family, key, "name");
                    if (r) {
                        System.out.println("该信息被删除！");
                    }
                } else if (delColumn.equals("性别")) {
                    boolean r = HBaseHelper.Exce_DelCell(tableName, family, key, "sex");
                    if (r) {
                        System.out.println("该信息被删除！");
                    }
                } else if (delColumn.equals("电话号码") || delColumn.equals("电话")) {
                    boolean r = HBaseHelper.Exce_DelCell(tableName, family, key, "phone");
                    if (r) {
                        System.out.println("该信息被删除！");
                    }
                } else if (delColumn.equals("地址")) {
                    boolean r = HBaseHelper.Exce_DelCell(tableName, family, key, "address");
                    if (r) {
                        System.out.println("该信息被删除！");
                    }
                }
            }
        }
        else if(choose.equals("q")){
            return;
        }
    }

    //查询学生信息
    public static void GetStu() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------------------");
        System.out.println("这里是查找功能界面");
        System.out.println("请输入序号选择查询功能：");
        System.out.println("1、按学号查询");
        System.out.println("2、按姓名查询");
        System.out.println("3、模糊查询");
        System.out.println("4、查询学生姓名列、电话列");

        String choose = scanner.next();
        if(choose.equals("1")){
            System.out.println("输入学生学号：");
            String key = scanner.next();
            Result result = HBaseHelper.Exec_GetDataByRowKey(tableName,key);
            for (Cell cell : result.rawCells()){
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell))+ "："+ Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }else if(choose.equals("2")){
            System.out.println("输入学生姓名：");
            String name = scanner.next();
            HBaseHelper.Exec_FilerAllName(family,name);
        }else if(choose.equals("3")){
            System.out.println("1、按照学号开头筛选学生");
            System.out.println("2、按姓氏查询");
            System.out.println("3、电话号码查询");
            System.out.println("4、组合查询");
            String num = scanner.next();
            if(num.equals("1")){
                System.out.println("需要查询以多少为学号开头的学生信息：");
                String number = scanner.next();
                HBaseHelper.Exec_FilerRow(tableName,number);
            }else if(num.equals("2")){
                System.out.println("输入姓氏：");
                String name = scanner.next();
                HBaseHelper.Exec_FilerName(family,name);
            }else if (num.equals("3")){
                System.out.println("输入电话号码：");
                String phone = scanner.next();
                HBaseHelper.Exec_FilerPhone(tableName,family,phone);
            }else if (num.equals("4")){
                List<Filter> filters = new ArrayList<Filter>();
                System.out.println("你还记得多少？试着按照提示输入，如果遗忘可以输入f：");
                System.out.println("姓名或是姓氏：");
                String name = scanner.next();
                if(!name.equals("f")){
                    Filter filterName = new SingleColumnValueFilter(Bytes.toBytes(family),Bytes.toBytes("name"), CompareOperator.EQUAL,new BinaryPrefixComparator(Bytes.toBytes(name)));
                    filters.add(filterName);
                }
                System.out.println("性别：");
                String sex = scanner.next();
                if(!sex.equals("f")){
                    Filter filterSex = new SingleColumnValueFilter(Bytes.toBytes(family),Bytes.toBytes("sex"), CompareOperator.EQUAL,new BinaryPrefixComparator(Bytes.toBytes(sex)));
                    filters.add(filterSex);
                }
                System.out.println("电话号码，开头的数字也行：");
                String phone = scanner.next();
                if(!phone.equals("f")){
                    Filter filterPhone = new SingleColumnValueFilter(Bytes.toBytes(family),Bytes.toBytes("phone"), CompareOperator.EQUAL,new BinaryPrefixComparator(Bytes.toBytes(phone)));
                    filters.add(filterPhone);
                }
                System.out.println("所在地：");
                String address = scanner.next();
                if(!address.equals("f")){
                    Filter filterAddress = new SingleColumnValueFilter(Bytes.toBytes(family),Bytes.toBytes("address"), CompareOperator.EQUAL,new BinaryPrefixComparator(Bytes.toBytes(address)));
                    filters.add(filterAddress);
                }
                FilterList filterList = new FilterList(filters);
                Scan scan = new  Scan();
                scan.setFilter(filterList);
                Table table = HBaseHelper.GetConn().getTable(TableName.valueOf(tableName));
                ResultScanner resultScanner = table.getScanner(scan);
                for (Result result : resultScanner) {
                        for (Cell cell : result.rawCells()) {
                            System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell)) + "：" + Bytes.toString(CellUtil.cloneValue(cell)));
                        }
                }
            }

        }else if(choose.equals("4")){
            System.out.println("输入学生学号：");
            String key = scanner.next();
            Result result = HBaseHelper.Exec_GetCell(tableName,family,key,"name");
            for (Cell cell : result.rawCells()){
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell))+ "："+ Bytes.toString(CellUtil.cloneValue(cell)));
            }
            Result result1 = HBaseHelper.Exec_GetCell(tableName,family,key,"phone");
            for (Cell cell : result1.rawCells()){
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(cell))+ "："+ Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }
    //修改学生信息
    public static void Changestu() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入需要修改的学生学号：");
        String key = scanner.next();
        Result result = HBaseHelper.Exec_GetDataByRowKey(tableName,key);
        if(result.isEmpty()){
            System.out.println("没有找到该学生！");
        }else {
            System.out.println("需要修改哪个信息？（姓名、性别、电话号码、地址）");
            String input = scanner.next();
            if(input.equals("姓名")){
                HBaseHelper.Exce_DelCell(tableName,"info",key,"name");
                System.out.println("输入修改后的信息：");
                String name = scanner.next();
                HBaseHelper.Exec_AddData(tableName,"info",key,"name",name);
                System.out.println("姓名修改完成！");
            }else if (input.equals("性别")){
                HBaseHelper.Exce_DelCell(tableName,"info",key,"sex");
                System.out.println("输入修改后的信息：");
                String sex = scanner.next();
                HBaseHelper.Exec_AddData(tableName,"info",key,"sex",sex);
                System.out.println("性别修改完成！");
            }else if (input.equals("电话号码")||input.equals("电话")){
                HBaseHelper.Exce_DelCell(tableName,"info",key,"phone");
                System.out.println("输入修改后的信息：");
                String phoneNumber = scanner.next();
                HBaseHelper.Exec_AddData(tableName,"info",key,"phone",phoneNumber);
                System.out.println("电话号码修改完成！");
            }else if (input.equals("地址")){
                HBaseHelper.Exce_DelCell(tableName,"info",key,"address");
                System.out.println("输入修改后的信息：");
                String address = scanner.next();
                HBaseHelper.Exec_AddData(tableName,"info",key,"sex",address);
                System.out.println("地址修改完成！");
            } else if(input.equals("q")){
                return;
            }else {
                System.out.println("输入有误！");
            }
        }
    }
    public static void PageStu() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入每页需要的学生人数：");
        String number = scanner.next();
        System.out.println("输入需要输出的页数：");
        String page = scanner.next();
        HBaseHelper.Exec_PageFiler(tableName, Long.parseLong(number), Long.parseLong(page));
    }
}