Hbase Java Api操作

注意:pom.xml文件添加（hbase版本和服务器上的版本可以不一致，但尽量保证一致）

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.1</version>
    <scope>runtime</scope>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
        <exclusion>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>2.0.4</version>
    <exclusions>
        <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
        </exclusion>
    </exclusions>
</dependency>

1、工具类HBaseHelper.java

package com.vue.demo.utils;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.client.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author yangwj
 * @date 2020/9/7 10:09
 * @desc
 */
public class HBaseHelper implements Closeable {

    private static final Logger log = LoggerFactory.getLogger(HBaseHelper.class);

    private Configuration configuration = null;
    private Connection connection = null;
    private Admin admin = null;

    /**构造方法*/
    private HBaseHelper(Configuration configuration) throws IOException {
        this.configuration = configuration;
        this.connection = ConnectionFactory.createConnection(this.configuration);
        admin = this.connection.getAdmin();
    }

    /**获取对象*/
    public static HBaseHelper getHBaseHelper(Configuration configuration) throws IOException {
        return new HBaseHelper(configuration);
    }

    @Override
    public void close() throws IOException {
        admin.close();
        connection.close();
    }

    public Connection getConnection() {
        return connection;
    }

    public Configuration getConfiguration() {
        return configuration;
    }

    /**创建命名空间:数据隔离*/
    public void createNamespace(String namespace) {
        try {
            NamespaceDescriptor nd = NamespaceDescriptor.create(namespace).build();
            admin.createNamespace(nd);
        } catch (Exception e) {
            log.error("[createNamespace]Error: {}",e.getMessage());
        }
    }

    /**删除命名空间*/
    public void dropNamespace(String namespace, boolean force) {
        try {
            if (force) {
                TableName[] tableNames = admin.listTableNamesByNamespace(namespace);
                for (TableName name : tableNames) {
                    admin.disableTable(name);
                    admin.deleteTable(name);
                }
            }
        } catch (Exception e) {
            log.error("[dropNamespace]Error: {}",e.getMessage());
        }
        try {
            admin.deleteNamespace(namespace);
        } catch (IOException e) {
            log.error("[dropNamespace]Error: {}",e.getMessage());
        }
    }

    /**判断是否存在表*/
    public boolean existsTable(String table)
            throws IOException {
        return existsTable(TableName.valueOf(table));
    }

    public boolean existsTable(TableName table)
            throws IOException {
        return admin.tableExists(table);
    }

    /**
     * 创建表
     * @param table 表名
     * @param colfams 列簇
     * @throws IOException
     */
    public void createTable(String table, String... colfams)
            throws IOException {
        createTable(TableName.valueOf(table), 1, null, colfams);
    }

    public void createTable(TableName table, String... colfams)
            throws IOException {
        createTable(table, 1, null, colfams);
    }

    public void createTable(String table, int maxVersions, String... colfams)
            throws IOException {
        createTable(TableName.valueOf(table), maxVersions, null, colfams);
    }

    /**
     * 创建表
     * @param table 表名
     * @param maxVersions timestamp
     * @param colfams 列簇
     * @throws IOException
     */
    public void createTable(TableName table, int maxVersions, String... colfams)
            throws IOException {
        createTable(table, maxVersions, null, colfams);
    }


    public void createTable(String table, byte[][] splitKeys, String... colfams)
            throws IOException {
        createTable(TableName.valueOf(table), 1, splitKeys, colfams);
    }

    /**
     * 创建表
     * @param table 表名
     * @param maxVersions timestamp
     * @param splitKeys
     * @param colfams 列簇
     * @throws IOException
     */
    public void createTable(TableName table, int maxVersions, byte[][] splitKeys,
                            String... colfams)
            throws IOException {
        //表描述器构造器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(table);

        //列族描述构造器
        ColumnFamilyDescriptorBuilder cfDescBuilder;

        //列描述器
        ColumnFamilyDescriptor cfDesc;


        for (String cf : colfams) {
            cfDescBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf));
            cfDescBuilder.setMaxVersions(maxVersions);
            cfDesc = cfDescBuilder.build();
            tableDescriptorBuilder.setColumnFamily(cfDesc);
        }
        //获得表描述器
        TableDescriptor tableDescriptor = tableDescriptorBuilder.build();

        if (splitKeys != null) {
            admin.createTable(tableDescriptor, splitKeys);
        } else {
            admin.createTable(tableDescriptor);
        }
    }

    /**禁用表*/
    public void disableTable(String table) throws IOException {
        disableTable(TableName.valueOf(table));
    }

    public void disableTable(TableName table) throws IOException {
        admin.disableTable(table);
    }

    /**删除表*/
    public void dropTable(String table) throws IOException {
        dropTable(TableName.valueOf(table));
    }

    public void dropTable(TableName table) throws IOException {
        if (existsTable(table)) {
            if (admin.isTableEnabled(table)) {disableTable(table);}
            admin.deleteTable(table);
        }
    }


    public void put(String table, String row, String fam, String qual,
                    String val) throws IOException {
        put(TableName.valueOf(table), row, fam, qual, val);
    }

    /**插入或更新单行*/
    public void put(TableName table, String row, String fam, String qual,
                    String val) throws IOException {
        Table tbl = connection.getTable(table);
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(fam), Bytes.toBytes(qual), Bytes.toBytes(val));
        tbl.put(put);
        tbl.close();
    }

    public void put(String table, String row, String fam, String qual, long ts,
                    String val) throws IOException {
        put(TableName.valueOf(table), row, fam, qual, ts, val);
    }

    /**带时间戳插入或更新单行*/
    public void put(TableName table, String row, String fam, String qual, long ts,
                    String val) throws IOException {
        Table tbl = connection.getTable(table);
        Put put = new Put(Bytes.toBytes(row));
        put.addColumn(Bytes.toBytes(fam), Bytes.toBytes(qual), ts,
                Bytes.toBytes(val));
        tbl.put(put);
        tbl.close();
    }

    /**插入或者更新一个rowKey数据，一个Put里有一个rowKey，可能有多个列族和列名*/
    public void put(String tableNameString, Put put) throws IOException {
        TableName tableName = TableName.valueOf(tableNameString);
        Table table = connection.getTable(tableName);
        if (put != null && put.size() > 0) {
            table.put(put);
        }
        table.close();
    }

    public void put(String table, String[] rows, String[] fams, String[] quals,
                    long[] ts, String[] vals) throws IOException {
        put(TableName.valueOf(table), rows, fams, quals, ts, vals);
    }

    /**用于测试数据*/
    public void put(TableName table, String[] rows, String[] fams, String[] quals,
                    long[] ts, String[] vals) throws IOException {
        Table tbl = connection.getTable(table);
        for (String row : rows) {
            Put put = new Put(Bytes.toBytes(row));
            for (String fam : fams) {
                int v = 0;
                for (String qual : quals) {
                    String val = vals[v < vals.length ? v : vals.length - 1];
                    long t = ts[v < ts.length ? v : ts.length - 1];
                    System.out.println("Adding: " + row + " " + fam + " " + qual +
                            " " + t + " " + val);
                    put.addColumn(Bytes.toBytes(fam), Bytes.toBytes(qual), t,
                            Bytes.toBytes(val));
                    v++;
                }
            }
            tbl.put(put);
        }
        tbl.close();
    }

    public void dump(String table, String[] rows, String[] fams, String[] quals)
            throws IOException {
        dump(TableName.valueOf(table), rows, fams, quals);
    }

    /**测试dump数据*/
    public void dump(TableName table, String[] rows, String[] fams, String[] quals)
            throws IOException {
        Table tbl = connection.getTable(table);
        List<Get> gets = new ArrayList<Get>();
        for (String row : rows) {
            Get get = new Get(Bytes.toBytes(row));
            get.readAllVersions();
            if (fams != null) {
                for (String fam : fams) {
                    for (String qual : quals) {
                        get.addColumn(Bytes.toBytes(fam), Bytes.toBytes(qual));
                    }
                }
            }
            gets.add(get);
        }
        org.apache.hadoop.hbase.client.Result[] results = tbl.get(gets);
        for (org.apache.hadoop.hbase.client.Result result : results) {
            for (Cell cell : result.rawCells()) {
                System.out.println("Cell: " + cell +
                        ", Value: " + Bytes.toString(cell.getValueArray(),
                        cell.getValueOffset(), cell.getValueLength()));
            }
        }
        tbl.close();
    }


    public void dump(String table) throws IOException {
        dump(TableName.valueOf(table));
    }

    public void dump(TableName table) throws IOException {
        try (
                Table t = connection.getTable(table);
                ResultScanner scanner = t.getScanner(new Scan());
        ) {
            for (org.apache.hadoop.hbase.client.Result result : scanner) {
                dumpResult(result);
            }
        }
    }

    /**从Cell取Array要加上位移和长度，不然数据不正确*/
    public void dumpResult(Result result) {
        for (Cell cell : result.rawCells()) {
            System.out.println("Cell: " + cell +
                    ", Value: " + Bytes.toString(cell.getValueArray(),
                    cell.getValueOffset(), cell.getValueLength()));
        }
    }

    public void dumpCells(String key, List<Cell> list) {
        for (Cell cell : list) {
            String columnFamily = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
            String columnName = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
            String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
            System.out.printf("[key:%s]	[family:%s] [column:%s] [value:%s]
",
                    key, columnFamily, columnName, value);
        }
    }


    /**批量插入数据,list里每个map就是一条数据，并且按照rowKey columnFamily columnName columnValue放入map的key和value*/
    public void bulkInsert(String tableNameString, List<Map<String, Object>> list) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        List<Put> puts = new ArrayList<Put>();
        if (list != null && list.size() > 0) {
            for (Map<String, Object> map : list) {
                Put put = new Put(Bytes.toBytes(map.get("rowKey").toString()));
                put.addColumn(Bytes.toBytes(map.get("columnFamily").toString()),
                        Bytes.toBytes(map.get("columnName").toString()),
                        Bytes.toBytes(map.get("columnValue").toString()));
                puts.add(put);
            }
        }
        table.put(puts);
        table.close();
    }

    /**批量插入*/
    public void bulkInsert2(String tableNameString, List<Put> puts) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        if (puts != null && puts.size() > 0) {
            table.put(puts);
        }
        table.close();
    }

    /**根据rowKey删除所有行数据*/
    public void deleteByKey(String tableNameString, String rowKey) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        table.delete(delete);
        table.close();
    }

    /**根据rowKey和列族删除所有行数据*/
    public void deleteByKeyAndFamily(String tableNameString, String rowKey, String columnFamily) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        delete.addFamily(Bytes.toBytes(columnFamily));

        table.delete(delete);
        table.close();
    }

    /**根据rowKey、列族删除多个列的数据*/
    public void deleteByKeyAndFC(String tableNameString, String rowKey,
                                 String columnFamily, List<String> columnNames) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        for (String columnName : columnNames) {
            delete.addColumns(Bytes.toBytes(columnFamily), Bytes.toBytes(columnName));
        }
        table.delete(delete);
        table.close();
    }


    /**根据rowkey，获取所有列族和列数据*/
    public List<Cell> getRowByKey(String tableNameString, String rowKey) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));

        Get get = new Get(Bytes.toBytes(rowKey));

        org.apache.hadoop.hbase.client.Result result = table.get(get);

//        Cell[] cells = result.rawCells();
        List<Cell> list = result.listCells();
        table.close();
        return list;
    }

    /**根据rowKey，family,qualifier获取列值*/
    public List<Cell> getRowByKeyAndColumn(String tableNameString, String rowKey, String cf, String clName) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));
        Get get = new Get(Bytes.toBytes(rowKey));
        get.addColumn(Bytes.toBytes(cf), Bytes.toBytes(clName));

        org.apache.hadoop.hbase.client.Result result = table.get(get);
        List<Cell> list = result.listCells();
        table.close();
        return list;
    }

    /**根据rowkey，获取所有列族和列数据*/
    public Map<String, List<Cell>> getRowByKeys(String tableNameString, String... rowKeys) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableNameString));

        List<Get> gets = new ArrayList<>();
        for (String rowKey : rowKeys) {
            Get get = new Get(Bytes.toBytes(rowKey));
            gets.add(get);
        }

        org.apache.hadoop.hbase.client.Result[] results = table.get(gets);

        Map<String, List<Cell>> map = new HashMap<>();
        for (org.apache.hadoop.hbase.client.Result res : results) {
            map.put(Bytes.toString(res.getRow()), res.listCells());
        }

        table.close();
        return map;
    }

    private Map<String, List<Cell>> formatToMap(String tableNameString,Scan scan) throws IOException{
        //确保table和scanner被释放
        try (Table table = connection.getTable(TableName.valueOf(tableNameString));
             ResultScanner scanner = table.getScanner(scan);
        ) {
            Map<String, List<Cell>> map = new HashMap<>();
            for (org.apache.hadoop.hbase.client.Result result : scanner) {
                map.put(Bytes.toString(result.getRow()), result.listCells());
            }
            return map;
        }
    }

    /**根据rowKey过滤数据，rowKey可以使用正则表达式
     * 返回rowKey和Cells的键值对
    **/
    public Map<String, List<Cell>> filterByRowKeyRegex(String tableNameString, String rowKey, CompareOperator operator) throws IOException {

        Scan scan = new Scan();
        //使用正则
        RowFilter filter = new RowFilter(operator, new RegexStringComparator(rowKey));

        //包含子串匹配,不区分大小写。
//        RowFilter filter = new RowFilter(operator,new SubstringComparator(rowKey));

        scan.setFilter(filter);

        return formatToMap(tableNameString,scan);
    }

    //根据列族，列名，列值（支持正则）查找数据
    //返回值：如果查询到值，会返回所有匹配的rowKey下的各列族、列名的所有数据（即使查询的时候这些列族和列名并不匹配）
    public Map<String, List<Cell>> filterByValueRegex(String tableNameString, String family, String colName,
                                                      String value, CompareOperator operator) throws IOException {
        Scan scan = new Scan();

        //正则匹配
        SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes(family),
                Bytes.toBytes(colName), operator, new RegexStringComparator(value));

        //完全匹配
//        SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes(family),
//                Bytes.toBytes(colName),operator,Bytes.toBytes(value));

        //SingleColumnValueExcludeFilter排除列值

        //要过滤的列必须存在，如果不存在，那么这些列不存在的数据也会返回。如果不想让这些数据返回,设置setFilterIfMissing为true
        filter.setFilterIfMissing(true);
        scan.setFilter(filter);

        return formatToMap(tableNameString,scan);
    }

    //根据列名前缀过滤数据
    public Map<String, List<Cell>> filterByColumnPrefix(String tableNameString, String prefix) throws IOException {

        //列名前缀匹配
        ColumnPrefixFilter filter = new ColumnPrefixFilter(Bytes.toBytes(prefix));

        //QualifierFilter 用于列名多样性匹配过滤
//        QualifierFilter filter = new QualifierFilter(CompareOperator.EQUAL,new SubstringComparator(prefix));

        //多个列名前缀匹配
//        MultipleColumnPrefixFilter multiFilter = new MultipleColumnPrefixFilter(new byte[][]{});

        Scan scan = new Scan();
        scan.setFilter(filter);

        return formatToMap(tableNameString,scan);
    }

    //根据列名范围以及列名前缀过滤数据
    public Map<String, List<Cell>> filterByPrefixAndRange(String tableNameString, String colPrefix,
                                                          String minCol, String maxCol) throws IOException {

        //列名前缀匹配
        ColumnPrefixFilter filter = new ColumnPrefixFilter(Bytes.toBytes(colPrefix));

        //列名范围扫描，上下限范围包括
        ColumnRangeFilter rangeFilter = new ColumnRangeFilter(Bytes.toBytes(minCol), true,
                Bytes.toBytes(maxCol), true);

        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        filterList.addFilter(filter);
        filterList.addFilter(rangeFilter);

        Scan scan = new Scan();
        scan.setFilter(filterList);

        return formatToMap(tableNameString,scan);
    }


}

2、HbaseController.java代码

package com.vue.demo.controller;

import com.vue.demo.service.serviceimpl.HbaseServiceImpl;
import com.vue.demo.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


/**
 * @author yangwj
 * @date 2020/9/8 14:21
 * @desc
 */
@RestController
public class HbaseController {

    @Autowired
    private HbaseServiceImpl hbaseService;

    @RequestMapping(value = "/createTable")
    @CrossOrigin
    public Result createTable(String table, String... columnFamily) {
       return hbaseService.createTable(table,columnFamily);
    }

    @RequestMapping(value = "/insertData")
    @CrossOrigin
    public Result insertData(String table, String row, String fam, String qual, String val) {
       return hbaseService.putData(table, row, fam, qual, val);
    }

    @RequestMapping(value = "/addFamily")
    @CrossOrigin
    public Result addFamily(String table, String fam) {
       return hbaseService.addFamily(table,fam);
    }

    @RequestMapping(value = "/getDataByRowByKeyAndColumn")
    @CrossOrigin
    public Result getDataByRowByKeyAndColumn(String table, String rowKey, String cf, String clName) {
        return hbaseService.getDataByRowByKeyAndColumn(table, rowKey, cf, clName);
    }

    @RequestMapping(value = "/deleteByKeyAndFamily")
    @CrossOrigin
    public Result deleteByKeyAndFamily(String tableNameStr, String rowKey, String columnFamily) {
        return hbaseService.deleteByKeyAndFamily(tableNameStr, rowKey, columnFamily);
    }
}

3、HbaseService.java代码

package com.vue.demo.service;

import com.vue.demo.utils.Result;

import java.io.IOException;

/**
 * @author yangwj
 * @date 2020/9/8 14:21
 * @desc
 */
public interface HbaseService {

    /**
     * 创建表
     * @param table 表名
     * @param columnFamily 列簇
     * @return
     */
    Result createTable(String table, String... columnFamily) throws IOException;

    /**
     * 添加列簇
     * @param table 表名
     * @param columnFamily 列簇
     */
    Result addFamily(String table, String... columnFamily) throws IOException;

    /**
     * 插入数据
     * @param table 表名
     * @param row rowkey
     * @param fam 列簇
     * @param qual 字段名
     * @param val  字段值
     */
    Result putData(String table, String row, String fam, String qual, String val);

    /**
     * 根据表名和rowkey删除数据
     * @param tableNameString 表名
     * @param rowKey rowkey
     */
    Result deleteByKey(String tableNameString, String rowKey);

    /**
     * 根据 rowkey ,cf ,column 获取数据
     * @param table 表名
     * @param rowKey rowkey
     * @param cf 列簇
     * @param clName 字段名
     */
    Result getDataByRowByKeyAndColumn(String table, String rowKey, String cf, String clName);

    /**
     * 根据rowkey、columnFamily 删除多个数据
     * @param tableNameStr 表名
     * @param rowKey rowkey
     * @param columnFamily 列簇
     * @return
     */
    Result deleteByKeyAndFamily(String tableNameStr, String rowKey, String columnFamily);


}

4、HbaseServiceImpl.java

package com.vue.demo.service.serviceimpl;

import com.vue.demo.service.HbaseService;
import com.vue.demo.utils.HBaseHelper;
import com.vue.demo.utils.ResponseResult;
import com.vue.demo.utils.Result;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

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

/**
 * @author yangwj
 * @date 2020/9/8 14:21
 * @desc
 */
@Service
public class HbaseServiceImpl implements HbaseService {

    private static final Logger log = LoggerFactory.getLogger(HbaseServiceImpl.class);

    static HBaseHelper helper;
    static Configuration conf ;
    static {
        conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", "localhost:2181");
        try {
            helper = HBaseHelper.getHBaseHelper(conf);
        } catch (IOException e) {
            log.error("hbase init error, the error is {} ",e.getMessage());
        }
    }

    @Override
    public Result createTable(String table, String... columnFamily){
        try {
            helper.createTable(table,columnFamily);
        } catch (IOException e) {
            log.error("hbase create table fail, the table name is {},and error msg is {}",table,e.getMessage());
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    @Override
    public Result addFamily(String table, String... columnFamily) {
        try {
            helper.addFamily(table,columnFamily);
        } catch (IOException e) {
            log.error("hbase addFamily fail, the table name is {},and error msg is {}",table,e.getMessage());
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    @Override
    public Result putData(String table, String row, String fam, String qual, String val){
        try {
            helper.put(table, row, fam, qual, val);
        } catch (IOException e) {
            log.error("insert data to hbase fail , the error msg is {},and table={},row={}, fam={},qual={},val={}",e.getMessage(),table,row,fam,qual,val);
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    @Override
    public Result deleteByKey(String tableNameStr, String rowKey) {
        try {
            helper.deleteByKey(tableNameStr,rowKey);
        } catch (IOException e) {
            log.error("delete data by key fail ,table={},rowkey={}, and the error msg is:{}",tableNameStr,rowKey,e.getMessage());
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    @Override
    public Result getDataByRowByKeyAndColumn(String table, String rowKey, String cf, String clName) {
        List<Cell> cells = new ArrayList<>();
        try {
            cells = helper.getRowByKeyAndColumn(table, rowKey, cf, clName);
            this.dumpCells(cells,rowKey);
        } catch (IOException e) {
            log.error("insert data to hbase fail , the error msg is {},and table={},row={}, fam={},qual={}",e.getMessage(),table,rowKey,cf,clName);
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    @Override
    public Result deleteByKeyAndFamily(String tableNameStr, String rowKey, String columnFamily) {
        try {
            helper.deleteByKeyAndFamily(tableNameStr, rowKey, columnFamily);
        } catch (IOException e) {
            return ResponseResult.error(400,e.getMessage());
        }
        return ResponseResult.success();
    }

    /**
     * 将数据封装
     * @param list Cell
     * @param rowkey rowkey
     */
    public void dumpCells(List<Cell> list,String rowkey){
        list.stream().forEach(cell -> {
            String cf = Bytes.toString(cell.getFamilyArray(),cell.getFamilyOffset(),cell.getFamilyLength());
            String cn = Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
            String value = Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
            //todo 带改进
            System.out.printf("[key:%s]	[family:%s] [column:%s] [value:%s]
", rowkey,cf,cn,value);
        });

    }


}

###############以上是Web的基本用法，下面的测试是对上面的补充######################

测试HbaseDemo.java

package com.vue.demo.controller;


import com.vue.demo.utils.HBaseHelper;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.client.Result;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author yangwj
 * @date 2020/9/7 10:12
 * @desc
 */
public class HbaseDemo {

    static HBaseHelper helper;
    final static String tableNameString ="demoTable" ;

    public static void main(String args[]) throws IOException {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", "localhost:2181");
//        conf.set("hbase.rootdir", "file:///opt/hbase_data");
//        conf.set("hbase.zookeeper.property.dataDir", "/opt/hbase_data/zookeeper");

        helper = HBaseHelper.getHBaseHelper(conf);

        //创建测试数据
        //createDemoTable();

        //测试cas
        //CheckAndMutateExample();

        //测试get
        //getData();

        //批量处理数据
        //batchData();

        //创建testtable表数据
        //createTestTable("testtable");

        //分页过滤
        //pageFilterData();
//            跳转过滤
        //skipFilterData();
//         多个过滤器组合
        mutilFilterData();
        //自定义过滤
        //customFilterData();

    }

    //清除并插入测试数据
    private static void createDemoTable() throws IOException {
        if (helper.existsTable(tableNameString))
        { helper.dropTable(tableNameString);}
        helper.createTable(tableNameString, 100, "cf1", "cf2");
        helper.put(tableNameString,
                new String[]{"row1"},
                new String[]{"cf1", "cf2"},
                new String[]{"qual1", "qual2", "qual3"},
                new long[]{1, 2, 3},
                new String[]{"val1", "val2", "val3"});
        helper.put(tableNameString,
                new String[]{"row2"},
                new String[]{"cf1", "cf2"},
                new String[]{"qual1", "qual2", "qual3"},
                new long[]{1, 2, 3},
                new String[]{"val1", "val2", "val3"});
        System.out.println("put data...");
        helper.dump(tableNameString);
    }

    //创建testtable测试数据
    private static void createTestTable(String tableNameString) throws IOException{
        if(tableNameString.isEmpty()) tableNameString = "testtable";
        if(helper.existsTable(tableNameString)){
            helper.dropTable(tableNameString);
        }
        helper.createTable(tableNameString,"info","ex","memo");

        List<Put> puts = new ArrayList<>();
        for(int i=0;i<100;i++){
            String rowKey = "rowKey"+i;
            Put put = new Put(Bytes.toBytes(rowKey));

            String columnFamily = "info";
            String columnName = "username";
            String columnValue = "user"+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "ex";
            columnName = "addr";
            columnValue = "street"+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "memo";
            columnName = "detail";
            columnValue = "remark"+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            puts.add(put);
        }
        helper.bulkInsert2(tableNameString,puts);
    }


    //测试操作原子性compare-and-set
    private static void CheckAndMutateExample() throws IOException {
        Table table = helper.getConnection().getTable(TableName.valueOf(tableNameString));
        boolean res = false;
        Put put = null;

        put = new Put(Bytes.toBytes("row1"));
        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("qual4"), 1, Bytes.toBytes("val1"));
//        如果row1 cf1 qual4 不存在值就插入put数据,存在则不插入
        res = table.checkAndMutate(Bytes.toBytes("row1"), Bytes.toBytes("cf1"))
                .qualifier(Bytes.toBytes("qual4"))
                .ifNotExists()
                .thenPut(put);
        System.out.println("1 result is (expected true) :" + res);

//        put = new Put(Bytes.toBytes("row1"));
//        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("qual1"), 4, Bytes.toBytes("val1"));
//        //如果row1 cf1 qual1 val1存在就插入put，因为这个value已经存在所以可以插入，结果返回true，时间戳变为4
//        res = table.checkAndMutate(Bytes.toBytes("row1"), Bytes.toBytes("cf1"))
//                .qualifier(Bytes.toBytes("qual1")).ifEquals(Bytes.toBytes("val1"))
//                .thenPut(put);
//        System.out.println("2 result is (expected true) :" + res);

//        put = new Put(Bytes.toBytes("row1"));
//        put.addColumn(Bytes.toBytes("cf1"),Bytes.toBytes("qual1"),5,Bytes.toBytes("val2"));
//        ////如果row1 cf1 qual1 不等于val2在就插入put
//        res = table.checkAndMutate(Bytes.toBytes("row1"), Bytes.toBytes("cf1"))
//                .qualifier(Bytes.toBytes("qual1"))
//                .ifMatches(CompareOperator.NOT_EQUAL,Bytes.toBytes("val2"))
//                .thenPut(put);
//        System.out.println("3 result is (expected true) :" + res);

        put = new Put(Bytes.toBytes("row1"));
        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("qual5"),1,Bytes.toBytes("val1"));
        put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("qual6"),1,Bytes.toBytes("val1"));

        Delete delete = new Delete(Bytes.toBytes("row1"));
        delete.addColumns(Bytes.toBytes("cf1"), Bytes.toBytes("qual4"));

        //RowMutations这个版本还没定型
        RowMutations mutations = new RowMutations(Bytes.toBytes("row1"));
        mutations.add(put);
        mutations.add(delete);

        //row1 cf1 qual4 val1存在,row1 cf1 qual5和row1 cf1 qual6无值则插入qual5和qual6的值，并删除qual4的值
        res = table.checkAndMutate(Bytes.toBytes("row1"),Bytes.toBytes("cf1")).qualifier(Bytes.toBytes("qual4"))
                .ifEquals(Bytes.toBytes("val1"))
                .qualifier(Bytes.toBytes("qual5")).ifNotExists()
                .qualifier(Bytes.toBytes("qual6")).ifNotExists()
                .thenMutate(mutations);
        System.out.println("1 result is (expected true) :" + res);


    }

    //get测试
    private static void getData() throws IOException{
        String key = "row1";
        String cf = "cf1";
        String cl = "qual1";

        System.out.println("first get:");
        helper.dumpCells(key,helper.getRowByKeyAndColumn(tableNameString,key,cf,cl));



        System.out.println("second get:");
        String tableName = "testtable";
        Map<String,List<Cell>> map = helper.getRowByKeys(tableName,"rowKey7","rowKey8","rowKey9");
        for(Map.Entry<String,List<Cell>> entry:map.entrySet()){
            helper.dumpCells(entry.getKey(),entry.getValue());
        }
    }

    //批处理数据,测试数据demoTable
    //注意：同一个rowKey不能同时使用put和delete
    private static void batchData() throws IOException{
        Table table = helper.getConnection().getTable(TableName.valueOf(tableNameString));

        byte[] row1 = Bytes.toBytes("row1");
        byte[] row2 = Bytes.toBytes("row2");
        byte[] cf1 = Bytes.toBytes("cf1");
        byte[] cf2 = Bytes.toBytes("cf2");
        byte[] qualifier1 = Bytes.toBytes("qual1");
        byte[] qualifier2 = Bytes.toBytes("qual2");

        List<Row> list = new ArrayList<>();


        //增/改
        Put put = new Put(row1);
        put.addColumn(cf1,qualifier1,5,Bytes.toBytes("row1_batch1"));
        put.addColumn(cf2,qualifier2,5,Bytes.toBytes("row1_batch2"));
        list.add(put);
        //查
        Get get = new Get(row1);
        get.addColumn(cf1,qualifier1);
        get.addColumn(cf2,qualifier2);
        list.add(get);
        //删
        Delete delete = new Delete(row2);
        delete.addColumns(cf1,qualifier2);
        list.add(delete);
        //删除不存在的
        get = new Get(row2);
        get.addFamily(Bytes.toBytes("noexists")); //列族不存在，这里将抛出异常
        list.add(get);

        Object[] results = new Object[list.size()];

        try {
            table.batch(list,results);
        }catch (Exception e){
            e.printStackTrace();
        }

        for(int i=0;i<results.length;i++){
            System.out.println("result["+i+"]: type = "+results[i].getClass().getSimpleName()+results[i]);
        }

        table.close();
        helper.dump(tableNameString);
        helper.close();
    }

    //分页过滤
    private static void pageFilterData() throws IOException{
        Table table = helper.getConnection().getTable(TableName.valueOf("testtable"));
        final byte[] POSTFIX = new byte[] { 0x00 };
        Filter filter = new PageFilter(10);

        int totalRows = 0;
        byte[] lastRow = null;
        while(true){
            Scan scan = new Scan();
            scan.setFilter(filter);
            if(lastRow!=null){

                //为了兼容以前的scan.setStartRow()代码
                //在上一次的最后一行加上一个空的byte数据，在下一个分页上，就会以新的key开始，
                // 但是实际上这个key并不存在，所以还是从真正的下一行开始扫描
                //这么做的原因是scan的扫描会自动包含起始行，如果不加空字节数据，那么定位上就会把上一次的最后一行作为起始行，最后的数据就会多一行。
                //而，新的api是withStartRow(byte[] startRow, boolean inclusive)，可以直接设置是否包含起始行，完美解决问题，但是又保留了对
                //以前api函数的兼容性
//                byte[] startRow = Bytes.add(lastRow,POSTFIX);
//                System.out.println("start row: " + Bytes.toStringBinary(startRow));
//                scan.withStartRow(startRow,true);


                System.out.println("start row: " + Bytes.toStringBinary(lastRow));
                //不包含起始行，所以可以直接使用上一次的最后一行作为起始行
                scan.withStartRow(lastRow,false);
            }
            ResultScanner scanner = table.getScanner(scan);
            int localRows = 0;
            Result result;
            while ((result=scanner.next())!=null){
                System.out.println(localRows++ + ": " + result);
                totalRows++;
                lastRow = result.getRow();
            }
            scanner.close();
            if(localRows==0){break;}
        }
        table.close();
        System.out.println("total rows: " + totalRows);
    }


    //跳转过滤
    private static void skipFilterData() throws IOException{
        Table table = helper.getConnection().getTable(TableName.valueOf("demoTable"));
        Filter filter = new ValueFilter(CompareOperator.EQUAL,new BinaryComparator(Bytes.toBytes("val2")));

        Scan scan = new Scan();
        scan.setFilter(filter);

        ResultScanner scanner1 = table.getScanner(scan);
        System.out.println("Results of scan #1:");
        int n = 0;
        for (Result result : scanner1) {
            for (Cell cell : result.rawCells()) {
                System.out.println("Cell: " + cell + ", Value: " +
                        Bytes.toString(cell.getValueArray(), cell.getValueOffset(),
                                cell.getValueLength()));
                n++;
            }
        }
        scanner1.close();

        //应用跳转过滤
        Filter skipFilter  = new SkipFilter(filter);
        Scan scan2 = new Scan();
        scan2.setFilter(skipFilter);
        ResultScanner scanner2 = table.getScanner(scan2);
        System.out.println("Total cell count for scan #1: " + n);
        n = 0;
        System.out.println("Results of scan #2:");
        for (Result result : scanner2) {
            for (Cell cell : result.rawCells()) {
                System.out.println("Cell: " + cell + ", Value: " +
                        Bytes.toString(cell.getValueArray(), cell.getValueOffset(),
                                cell.getValueLength()));
                n++;
            }
        }
        scanner2.close();
        table.close();
        System.out.println("Total cell count for scan #2: " + n);

    }

    //多个过滤器
    //使用FilterList要保证过滤器的顺序需要使用List<Filter>
    private static void mutilFilterData() throws IOException{
        Table table = helper.getConnection().getTable(TableName.valueOf("testtable"));

        List<Filter> filters = new ArrayList<Filter>();

        Filter filter1 = new RowFilter(CompareOperator.GREATER_OR_EQUAL,
                new BinaryComparator(Bytes.toBytes("rowKey60")));
        filters.add(filter1);

        Filter filter2 = new RowFilter(CompareOperator.LESS_OR_EQUAL,
                new BinaryComparator(Bytes.toBytes("rowKey69")));
        filters.add(filter2);

        Filter filter3 = new QualifierFilter(CompareOperator.EQUAL,
                new RegexStringComparator("username"));
        filters.add(filter3);

        FilterList filterList1 = new FilterList(FilterList.Operator.MUST_PASS_ALL,filters);

        Scan scan = new Scan();
        scan.setFilter(filterList1);
        ResultScanner scanner1 = table.getScanner(scan);
        System.out.println("Results of scan #1 - MUST_PASS_ALL:");
        int n = 0;
        for (Result result : scanner1) {
            for (Cell cell : result.rawCells()) {
                System.out.println("Cell: " + cell + ", Value: " +
                        Bytes.toString(cell.getValueArray(), cell.getValueOffset(),
                                cell.getValueLength()));
                n++;
            }
        }
        scanner1.close();
        table.close();

    }

    //使用自定义过滤器，只显示匹配列值的行
    private static void customFilterData() throws IOException{
        Table table = helper.getConnection().getTable(TableName.valueOf("testtable"));

        List<Filter> filters = new ArrayList<Filter>();

//        Filter filter1 = new CustomFilter(Bytes.toBytes("user30"));
//        filters.add(filter1);
//
//        Filter filter2 = new CustomFilter(Bytes.toBytes("user20"));
//        filters.add(filter2);
//
//        Filter filter3 = new CustomFilter(Bytes.toBytes("user90"));
//        filters.add(filter3);

        FilterList filterList = new FilterList(
                FilterList.Operator.MUST_PASS_ONE, filters);

        Scan scan = new Scan();
        scan.setFilter(filterList);
        ResultScanner scanner = table.getScanner(scan);
        for(Result result:scanner){
            helper.dumpResult(result);
        }

        scanner.close();
        table.close();
    }
}

测试MyHBase.java

package com.vue.demo.controller;


import com.vue.demo.utils.HBaseHelper;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

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

/**
 * @author yangwj
 * @date 2020/9/7 15:06
 * @desc
 */
public class MyHBase {
    Configuration conf;

    HBaseHelper helper;

    //初始化
    private void setUp() throws IOException{
        conf = HBaseConfiguration.create();
        //conf.set("hbase.master","192.168.31.10");
        //The port the HBase Master should bind to.
//        conf.set("hbase.master.port","16000");

        //The port for the HBase Master web UI. Set to -1 if you do not want a UI instance run.
//        conf.set("hbase.master.info.port","16010");

        //The port the HBase RegionServer binds to.
//        conf.set("hbase.regionserver.port","16020");

        //The port for the HBase RegionServer web UI Set to -1 if you do not want the RegionServer UI to run.
//        conf.set("hbase.regionserver.info.port","16030");

        conf.set("hbase.zookeeper.quorum", "localhost:2181");

        //Property from ZooKeeper’s config zoo.cfg. The port at which the clients will connect.
        // HBase数据库使用的端口
        //conf.set("hbase.zookeeper.property.clientPort", "2181");

        //单机
        //conf.set("hbase.rootdir","file:///opt/hbase_data");
        //conf.set("hbase.zookeeper.property.dataDir","/opt/hbase_data/zookeeper");

        helper = HBaseHelper.getHBaseHelper(conf);
    }


    //user表插入测试数据
    private void insertUserData() throws IOException{
        // 取得数据表对象
        Table table = helper.getConnection().getTable(TableName.valueOf("user"));

        // 需要插入数据库的数据集合

        List<Put> putList = new ArrayList<Put>();

        Put put;

        // 生成数据集合
        for(int i = 0; i < 10; i++){
            put = new Put(Bytes.toBytes("user" + i));
            put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("username"), Bytes.toBytes("中文战士" + i));
            put.addColumn(Bytes.toBytes("ex"), Bytes.toBytes("addr"), Bytes.toBytes("北京路1088号：" + i));

            putList.add(put);
        }

        // 将数据集合插入到数据库
        table.put(putList);
        table.close();


    }

    //查询导出所有数据
    private void queryAll(String tableNameString) throws IOException{
        System.out.println("导出数据："+tableNameString);
        // 取得数据表对象
        Table table = helper.getConnection().getTable(TableName.valueOf(tableNameString));

        // 取得表中所有数据
        ResultScanner scanner = table.getScanner(new Scan());

        for(Result result:scanner){
            byte[] row = result.getRow();
            System.out.println("row key is:" + new String(row));

            List<Cell> cellList = result.listCells();
            for(Cell cell:cellList){
                byte[] familyArray = cell.getFamilyArray();
                byte[] qualifierArray = cell.getQualifierArray();
                byte[] valueArray = cell.getValueArray();

                String s1 = "row familyArray is:" + Bytes.toString(cell.getFamilyArray(),cell.getFamilyOffset(),cell.getFamilyLength());
                String s2 = "row qualifierArray is:" + Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
                String s3 = "row value is:" + Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());

                System.out.println(s1+",  "+s2+",  "+s3+"	"+cell.getTimestamp());

                System.out.println();

                //直接使用出现乱码，要使用Bytes类，并且需要使用offset和length
//                System.out.println("row value is:" + new String(familyArray, StandardCharsets.UTF_8) + new String(qualifierArray,StandardCharsets.UTF_8)
//                        + new String(valueArray,StandardCharsets.UTF_8));
            }
        }
        scanner.close();
        table.close();

        System.out.println("导出结束...");
        System.out.println();
    }

    private void close() throws IOException{

        helper.close();
    }

    //插入testtable表数据
    private void initTestTable() throws IOException{
        String tableNameString = "user";
        if(helper.existsTable(tableNameString)){
            helper.disableTable(tableNameString);
            helper.dropTable(tableNameString);
        }

        helper.createTable(tableNameString,"info","ex","memo");
        helper.put(tableNameString,"row1","info","username","admin");
        helper.put(tableNameString,"row1","ex","addr","北京大道");
        helper.put(tableNameString,"row1","memo","detail","超级用户，地址：北京大道");


        helper.put(tableNameString,"row2","info","username","guest");
        helper.put(tableNameString,"row2","ex","addr","全国各地");
        helper.put(tableNameString,"row2","memo","detail","游客，地址：全国到处都是");

        helper.close();
    }

    private void bulkInsertTestTable() throws IOException{
        String tableNameString = "testtable";
        if(!helper.existsTable(tableNameString)){
            helper.createTable(tableNameString,"info","ex","memo");
        }

        System.out.println(".........批量插入数据start.........");
        List<Map<String,Object>> mapList = new ArrayList<>();
        for(int i=1;i<201;i++){
            Map<String,Object> map = new HashMap<>();
            map.put("rowKey","testKey"+i);
            map.put("columnFamily","info");
            map.put("columnName","username");
            map.put("columnValue","guest"+i);

            map.put("rowKey","testKey"+i);
            map.put("columnFamily","ex");
            map.put("columnName","addr");
            map.put("columnValue","北京路"+i+"号");

            map.put("rowKey","testKey"+i);
            map.put("columnFamily","memo");
            map.put("columnName","detail");
            map.put("columnValue","联合国地球村北京路第"+i+"号");

            mapList.add(map);
        }

        helper.bulkInsert(tableNameString,mapList);

        System.out.println(".........批量插入数据end.........");
    }

    private void insertByRowKey(String table,String rowKey) throws IOException{
        Put put = new Put(Bytes.toBytes(rowKey));

        String columnFamily ;
        String columnName ;
        String columnValue ;
        for(int i=0;i<10;i++){
            columnFamily = "info";
            columnName = "username"+i;
            columnValue = "user111";
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "ex";
            columnName = "addr"+i;
            columnValue = "street 111";
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "memo";
            columnName = "detail"+i;
            columnValue = "sssss zzz 111222 ";
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));
        }
        System.out.println("----> put size:"+put.size());

        helper.put(table,put);

    }

    private void bulkInsertTestTable2(String tableNameString) throws IOException{
//        String tableNameString = "testtable";
        if(!helper.existsTable(tableNameString)){
            helper.createTable(tableNameString,"info","ex","memo");
        }

        List<Put> puts = new ArrayList<>();
        for(int i=0;i<10;i++){
            String rowKey = "rowKey"+i;
            Put put = new Put(Bytes.toBytes(rowKey));

            String columnFamily = "info";
            String columnName = "username2";
            String columnValue = "user"+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "ex";
            columnName = "addr2";
            columnValue = "street "+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            columnFamily = "memo";
            columnName = "detail2";
            columnValue = "aazzdd "+i;
            put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnName),Bytes.toBytes(columnValue));

            System.out.println("put size:"+put.size());
            puts.add(put);
        }
        helper.bulkInsert2(tableNameString,puts);
    }

    private void dumpTable(String tableNameString) throws IOException{
        helper.dump(tableNameString);
        helper.close();
    }

    private void deleteByKey() throws IOException{
        String tableNameString = "testtable";
        String rowKey = "rowKey0";
        helper.deleteByKey(tableNameString,rowKey);
    }

    private void deleteByKeyAndFamily() throws IOException{
        String tableNameString = "testtable";
        String rowKey = "rowKey1";
        String columnFamily="ex";
        helper.deleteByKeyAndFamily(tableNameString,rowKey,columnFamily);
    }

    private void deleteByKeyAndFC() throws IOException{
        String tableNameString = "testtable";
        String rowKey = "rowKey3";
        String columnFamily="ex";
        List<String> list = new ArrayList<>();
//        list.add("addr");
        list.add("addr2");
        helper.deleteByKeyAndFC(tableNameString,rowKey,columnFamily,list);
    }

    private void createTableBySplitKey() throws IOException{
        String tableNameString = "testtable2";
        byte[][] splitKeys = {
                Bytes.toBytes("10"),
                Bytes.toBytes("60"),
                Bytes.toBytes("120"),
        };
        helper.createTable(tableNameString,splitKeys,"info","ex","memo");
    }

    private void getDataByRowKey(String table,String rowKey) throws IOException{
        List<Cell> cells = helper.getRowByKey(table,rowKey);
        dumpCells(rowKey,cells);
    }

    private void getDataByRowKeyFilter(String table,String rowKey) throws IOException{
        Map<String,List<Cell>> map = helper.filterByRowKeyRegex(table,rowKey, CompareOperator.EQUAL);
        for(Map.Entry<String,List<Cell>> entry: map.entrySet()){
            String key = entry.getKey();
            List<Cell> list = entry.getValue();
            dumpCells(key,list);
        }
    }

    private void getDataByValueFilter(String table,String family,String colName,String colValue) throws IOException{
        Map<String,List<Cell>> map = helper.filterByValueRegex(table,family,colName,colValue,CompareOperator.EQUAL);
        for(Map.Entry<String,List<Cell>> entry: map.entrySet()){
            String key = entry.getKey();
            List<Cell> list = entry.getValue();
            dumpCells(key,list);
        }
    }

    private void getDataByColumnPrefix(String table,String prefix) throws IOException{
        Map<String,List<Cell>> map = helper.filterByColumnPrefix(table,prefix);
        for(Map.Entry<String,List<Cell>> entry:map.entrySet()){
            String key = entry.getKey();
            List<Cell> list = entry.getValue();
            dumpCells(key,list);
        }
    }

    private void dumpCells(String key,List<Cell> list){
        for(Cell cell:list){
            String columnFamily = Bytes.toString(cell.getFamilyArray(),cell.getFamilyOffset(),cell.getFamilyLength());
            String columnName = Bytes.toString(cell.getQualifierArray(),cell.getQualifierOffset(),cell.getQualifierLength());
            String value = Bytes.toString(cell.getValueArray(),cell.getValueOffset(),cell.getValueLength());
            System.out.printf("[key:%s]	[family:%s] [column:%s] [value:%s]
",
                    key,columnFamily,columnName,value);
        }
    }


    private void getDataByComplexCol(String table,String colPrefix,String minCol,String maxCol) throws IOException{
        Map<String,List<Cell>> map = helper.filterByPrefixAndRange(table,colPrefix,minCol,maxCol);
        for(Map.Entry<String,List<Cell>> entry:map.entrySet()){
            String key = entry.getKey();
            List<Cell> list = entry.getValue();
            dumpCells(key,list);
        }
    }

    public static void main(String[] args) throws IOException{
//        System.out.println("字符编码："+System.getProperty("file.encoding"));
        MyHBase myHBase = new MyHBase();
        myHBase.setUp();

        //myHBase.initTestTable();
       // myHBase.insertUserData();
//        myHBase.createTableBySplitKey();
//        myHBase.deleteByKey();
//        myHBase.deleteByKeyAndFamily();
//        myHBase.deleteByKeyAndFC();
//        myHBase.bulkInsertTestTable2("testtable2");
       // myHBase.queryAll("user");
//        myHBase.queryAll("testtable");
//        myHBase.dumpTable("testtable2");
  //      myHBase.insertByRowKey("testtable2","rowKey0");
//        myHBase.getDataByRowKey("testtable2","rowKey0");
       // myHBase.getDataByRowKeyFilter("testtable2","Key1$");
       // myHBase.getDataByRowKeyFilter("user","^power");
        myHBase.getDataByValueFilter("user","info","username","战士1");

//        myHBase.getDataByColumnPrefix("user","ad");
        //myHBase.getDataByComplexCol("testtable2","username0","username0","username9");
        myHBase.close();


    }
}

 具体的可以参考:https://www.cnblogs.com/asker009/p/10626508.html