HBASEUtil

import lombok.extern.slf4j.Slf4j;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.*;

/**
 * 应用模块名称：
 * <p>
 * 代码描述：
 * <p>
 * Copyright: Copyright (C) 2020 XXX, Inc. All rights reserved.
 * <p>
 * Company: 
 *
 * @author mirror
 * @date: 2020年10月19日 17:12
 **/
@Slf4j
@Service
public class HbaseUtils implements HBaseCURD {

    private boolean isTableExist(String table) {
        log.info("isTableExist方法，判断表是否存在，表名是：" + table);
        boolean flag = false;

        try {
            TableName tablename = TableName.valueOf(table);
            Admin admin = HBaseConnectionUtils.getInstance().getAdmin();
            if (admin.tableExists(tablename)) {
                flag = true;
            }
        } catch (IOException var5) {
            log.error("isTableExist方法，错误信息：" + var5.getMessage());
            var5.printStackTrace();
        }

        log.info("isTableExist方法，判断表是否存在，flag标志：" + flag);
        return flag;
    }

    public ResultScanner getResultScanner(String name, FilterList filterList) {

        TableName tableName = TableName.valueOf(name);
        Table table = null;
        try {
            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
        } catch (IOException e) {
            log.error("建立hbase连接失败，错误信息是" + e.getMessage());
            e.printStackTrace();
        }
        Scan scan = new Scan();
        scan.setFilter(filterList);

        if (table == null) {
            return null;
        }
        ResultScanner scanner = null;
        try {
            scanner = table.getScanner(scan);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                table.close();
            } catch (IOException e) {

                e.printStackTrace();
            }
        }
        return scanner;
    }

    public List<RowVO> loopResults(ResultScanner results) {
        log.info("loopResults方法，用scan方式获取数据");
        List<RowVO> rowVOList = new ArrayList();
        Iterator var3 = results.iterator();

        while (var3.hasNext()) {
            Result result = (Result) var3.next();
            RowVO row = new RowVO();
            List<String> familyNameList = new ArrayList();
            List<String> columnNameList = new ArrayList();
            List<String> valueList = new ArrayList();
            row.setRowkey(Bytes.toString(result.getRow()));
            long timestamp = 0L;
            Cell[] cells = result.rawCells();
            Cell[] var12 = cells;
            int var13 = cells.length;

            for (int var14 = 0; var14 < var13; ++var14) {
                Cell cell = var12[var14];
                String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
                familyNameList.add(familyName);
                String columnName = Bytes.toString(CellUtil.cloneQualifier(cell));
                columnNameList.add(columnName);
                String value = Bytes.toString(CellUtil.cloneValue(cell));
                valueList.add(value);
                timestamp = cell.getTimestamp();
            }

            row.setTimestamp(timestamp);
            row.setFamilyName(familyNameList);
            row.setColumnName(columnNameList);
            row.setValue(valueList);
            rowVOList.add(row);
        }

        log.info("loopResults方法，用scan方式获取数据，rowVOList的条数：" + rowVOList.size());
        return rowVOList;
    }

    private List<RowVO> loopResults(Result[] results) {
        log.info("loopResults方法，用List<Get>方式获取批量数据");
        List<RowVO> rowVOList = new ArrayList();
        Result[] var3 = results;
        int var4 = results.length;

        for (int var5 = 0; var5 < var4; ++var5) {
            Result result = var3[var5];
            RowVO row = new RowVO();
            List<String> familyNameList = new ArrayList();
            List<String> columnNameList = new ArrayList();
            List<String> valueList = new ArrayList();
            row.setRowkey(Bytes.toString(result.getRow()));
            long timestamp = 0L;
            Cell[] cells = result.rawCells();
            Cell[] var14 = cells;
            int var15 = cells.length;

            for (int var16 = 0; var16 < var15; ++var16) {
                Cell cell = var14[var16];
                String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
                familyNameList.add(familyName);
                String columnName = Bytes.toString(CellUtil.cloneQualifier(cell));
                columnNameList.add(columnName);
                String value = Bytes.toString(CellUtil.cloneValue(cell));
                valueList.add(value);
                timestamp = cell.getTimestamp();
            }

            row.setTimestamp(timestamp);
            row.setFamilyName(familyNameList);
            row.setColumnName(columnNameList);
            row.setValue(valueList);
            rowVOList.add(row);
        }

        log.info("loopResults方法，用List<Get>方式获取批量数据，rowVOList数据条数：" + rowVOList.size());
        return rowVOList;
    }

    public Map<String, Object> getMapByPage(Table table, ResultScanner resultScanner, int pageSize, int pageNum) throws IOException {
        Map<String, Object> map = new HashMap();
        List<String> rowkeyList = new ArrayList();
        Iterator var7 = resultScanner.iterator();

        while (var7.hasNext()) {
            Result result = (Result) var7.next();
            String rowkey = Bytes.toString(result.getRow());
            rowkeyList.add(rowkey);
        }

        int totalCount = rowkeyList.size();
        if (totalCount == 0) {
            map.put("totalCount", 0);
            map.put("rowVOList", (Object) null);
            return map;
        } else {
            map.put("totalCount", totalCount);
            int startIndex = 0;
            int endIndex;
            if (pageNum >= 1 && pageSize > 0) {
                int lastPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
                if (pageNum == lastPage) {
                    startIndex = pageSize * (pageNum - 1);
                    endIndex = totalCount - 1;
                } else {
                    startIndex = pageSize * (pageNum - 1);
                    endIndex = pageSize * pageNum - 1;
                }
            } else {
                endIndex = totalCount - 1;
            }

            List<Get> getList = new ArrayList();

            for (int i = startIndex; i <= endIndex; ++i) {
                Get get = new Get(Bytes.toBytes((String) rowkeyList.get(i)));
                getList.add(get);
            }

            Result[] results = table.get(getList);
            map.put("rowVOList", this.loopResults(results));
            return map;
        }
    }

    public void addOrUpdateRow(String hbaseTableName, List<RowVO> rowVOList) {
        log.info("addOrUpdateRow方法，批量增加或更新记录，rowVOList数据条数：" + rowVOList);
        Table table = null;

        try {
            if (this.isTableExist(hbaseTableName)) {
                TableName tablename = TableName.valueOf(hbaseTableName);
                List<Put> putList = new ArrayList();
                Iterator var6 = rowVOList.iterator();

                while (var6.hasNext()) {
                    RowVO vo = (RowVO) var6.next();
                    Put put = new Put(Bytes.toBytes(vo.getRowkey()));
                    List<String> familyNameList = vo.getFamilyName();
                    List<String> columnNameList = vo.getColumnName();
                    List<String> valueList = vo.getValue();

                    for (int i = 0; i < familyNameList.size(); ++i) {
                        put.addColumn(Bytes.toBytes((String) familyNameList.get(i)), Bytes.toBytes((String) columnNameList.get(i)), Bytes.toBytes((String) valueList.get(i)));
                    }

                    putList.add(put);
                }

                table = HBaseConnectionUtils.getInstance().getConnection().getTable(tablename);
                table.put(putList);
            }
        } catch (IOException var21) {
            log.error("addOrUpdateRow方法，错误信息：" + var21.getMessage());
            var21.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var20) {
                var20.printStackTrace();
            }

        }

    }

    public void deleteRows(String hbaseTableName, List<RowVO> rowVOList) {
        log.info("deleteRows方法，根据多个主键rowkey批量删除表的行，表名是：" + hbaseTableName + "--删除行数是：" + rowVOList);
        Table table = null;

        try {
            TableName tablename = TableName.valueOf(hbaseTableName);
            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tablename);
            List<Delete> deleteList = new ArrayList();
            Iterator var6 = rowVOList.iterator();

            while (var6.hasNext()) {
                RowVO rowVO = (RowVO) var6.next();
                Delete delete = new Delete(Bytes.toBytes(rowVO.getRowkey()));
                deleteList.add(delete);
            }

            table.delete(deleteList);
            log.info("deleteRows方法，根据多个主键rowkey批量删除表的行，deleteList删除了多少行：" + deleteList.size());
        } catch (IOException var17) {
            log.error("deleteRows方法，错误信息：" + var17.getMessage());
            var17.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var16) {
                var16.printStackTrace();
            }

        }

    }

    public void dropTable(String hbaseTableName) {
        log.info("dropTable方法，删除表，表名是：" + hbaseTableName);
        Admin admin = null;

        try {
            admin = HBaseConnectionUtils.getInstance().getAdmin();
            TableName tablename = TableName.valueOf(hbaseTableName);
            if (this.isTableExist(hbaseTableName)) {
                admin.disableTable(tablename);
                admin.deleteTable(tablename);
            }

            log.info("dropTable方法，完成。");
        } catch (Exception var12) {
            log.error("dropTable方法，错误信息：" + var12.getMessage());
            var12.printStackTrace();
        } finally {
            try {
                if (admin != null) {
                    admin.close();
                }
            } catch (IOException var11) {
                var11.printStackTrace();
            }

        }

    }

    public void truncateTable(String hbaseTableName) {
        log.info("truncateTable方法，清空表，表名是：" + hbaseTableName);
        Admin admin = null;

        try {
            admin = HBaseConnectionUtils.getInstance().getAdmin();
            TableName tablename = TableName.valueOf(hbaseTableName);
            if (this.isTableExist(hbaseTableName)) {
                admin.disableTable(tablename);
                admin.truncateTable(tablename, true);
            }
        } catch (Exception var12) {
            log.error("truncateTable方法，错误信息：" + var12.getMessage());
            var12.printStackTrace();
        } finally {
            try {
                if (admin != null) {
                    admin.close();
                }
            } catch (IOException var11) {
                var11.printStackTrace();
            }

        }

    }

    public void createTable(String hbaseTableName, String[] columnFamilys) {
        log.info("createTable方法，创建表，表名是：" + hbaseTableName);
        Admin admin = null;

        try {
            TableName tableName = TableName.valueOf(hbaseTableName);
            admin = HBaseConnectionUtils.getInstance().getAdmin();
            if (this.isTableExist(hbaseTableName)) {
                log.info(hbaseTableName + "--表已经存在！");
            } else {
                HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
                String[] var6 = columnFamilys;
                int var7 = columnFamilys.length;

                for (int var8 = 0; var8 < var7; ++var8) {
                    String columnFamily = var6[var8];
                    HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(columnFamily);
                    hTableDescriptor.addFamily(hColumnDescriptor);
                }

                admin.createTable(hTableDescriptor);
            }
        } catch (IOException var19) {
            log.error("createTable方法，错误信息：" + var19.getMessage());
            var19.printStackTrace();
        } finally {
            try {
                if (admin != null) {
                    admin.close();
                }
            } catch (IOException var18) {
                var18.printStackTrace();
            }

        }

    }


    public List<RowVO> getAllData(String hbaseTableName) {
        log.info("getAllData方法，扫描全表，表名是：" + hbaseTableName);
        Table table = null;
        List<RowVO> rowVOList = null;

        try {
            TableName tableName = TableName.valueOf(hbaseTableName);
            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
            Scan scan = new Scan();
            scan.setCaching(1000);
            ResultScanner resultScanner = table.getScanner(scan);
            rowVOList = this.loopResults(resultScanner);
        } catch (IOException var15) {
            log.error("getAllData方法，错误信息：" + var15.getMessage());
            var15.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var14) {
                var14.printStackTrace();
            }

        }

        log.info("getAllData方法，扫描全表，数据条数是：" + rowVOList.size());
        return rowVOList;
    }

    public List<RowVO> getAllDataFilter(String hbaseTableName, FilterList filters) {
        log.info("getAllData方法，扫描全表，表名是：" + hbaseTableName);
        Table table = null;
        List rowVOList = null;

        try {
            TableName tableName = TableName.valueOf(hbaseTableName);
            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
            Scan scan = new Scan();
            scan.setFilter(filters);
            scan.setCaching(1000);
            ResultScanner resultScanner = table.getScanner(scan);
            rowVOList = this.loopResults(resultScanner);
        } catch (IOException var15) {
            log.error("getAllData方法，错误信息：" + var15.getMessage());
            var15.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var14) {
                var14.printStackTrace();
            }

        }

        log.info("getAllData方法，扫描全表，数据条数是：" + rowVOList.size());
        return rowVOList;
    }

    public RowVO getOneRow(String hbaseTableName, String rowkey) {
        log.info("getOneRow方法，根据rowkey获取一行数据，表名是：" + hbaseTableName + "--主键是：" + rowkey);
        Table table = null;
        RowVO row = null;

        try {
            TableName tableName = TableName.valueOf(hbaseTableName);

            HBaseConnectionUtils instance = HBaseConnectionUtils.getInstance();

            Connection connection = instance.getConnection();
            table =connection.getTable(tableName);


            Get get = new Get(Bytes.toBytes(rowkey));
            Result result = table.get(get);
            row = new RowVO();
            List<String> familyNameList = new ArrayList();
            List<String> columnNameList = new ArrayList();
            List<String> valueList = new ArrayList();
            row.setRowkey(Bytes.toString(result.getRow()));
            long timestamp = 0L;
            Cell[] cells = result.rawCells();
            Cell[] var14 = cells;
            int var15 = cells.length;

            for (int var16 = 0; var16 < var15; ++var16) {
                Cell cell = var14[var16];
                String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
                familyNameList.add(familyName);
                String columnName = Bytes.toString(CellUtil.cloneQualifier(cell));
                columnNameList.add(columnName);
                String value = Bytes.toString(CellUtil.cloneValue(cell));
                valueList.add(value);
                timestamp = cell.getTimestamp();
            }

            row.setTimestamp(timestamp);
            row.setFamilyName(familyNameList);
            row.setColumnName(columnNameList);
            row.setValue(valueList);
        } catch (IOException var29) {
            log.error("getOneRow方法，错误信息：" + var29.getMessage());
            var29.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var28) {
                var28.printStackTrace();
            }

        }

        log.info("getOneRow方法，根据rowkey获取一行数据，这行数据是：" + row);
        return row;
    }

    public Map<String, Object> selectByRowFilterPage(String hbaseTableName, String min, String max, String type, int pageSize, int pageNum) {
        log.info("selectByRowFilterPage方法，根据主键过滤分页方法，表名是：" + hbaseTableName + "，最小值是：" + min + "，最大值是：" + max + "，类型是：" + type + "，页面大小：" + pageSize + "，页数：" + pageNum);
        Table table = null;
        Map map = null;

        try {
            TableName tableName = TableName.valueOf(hbaseTableName);
            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
            Scan scan = new Scan();
            scan.setFilter(this.getRowFilters(min, max, type, (String) null));
            scan.setCaching(1000);
            ResultScanner resultScanner = table.getScanner(scan);
            map = this.getMapByPage(table, resultScanner, pageSize, pageNum);
        } catch (IOException var20) {
            log.error("selectByRowFilterPage方法，错误信息是" + var20.getMessage());
            var20.printStackTrace();
        } finally {
            try {
                if (table != null) {
                    table.close();
                }
            } catch (IOException var19) {
                var19.printStackTrace();
            }

        }

        log.info("selectByRowFilterPage方法，根据主键过滤分页方法，map条数是：" + map.size());
        return map;
    }

    /**
     * 根据行过滤分页方法
     *
     * @param hbaseTableName Hbase 表名称
     * @param startRowKey    开始RowKey
     * @param endRowKey      结束RowKey
     * @param filters        过滤条件
     * @param pageSize       每页多少条数据
     * @param pageNum        页码
     * @param isReverse      是否倒序
     * @return
     */
    public Map<String, Object> selectDataByRowFilterPage(String hbaseTableName, String startRowKey, String endRowKey, FilterList filters, int pageSize, int pageNum, boolean isReverse) {
        log.info("selectDataByRowFilterPage，根据行过滤分页方法，表名：" + hbaseTableName + "，开始RowKey：" + startRowKey + "，结束RowKey：" + endRowKey + "，页面大小：" + pageSize + "，页数：" + pageNum + ", 是否倒序：" + isReverse);
        Table table = null;
        Map<String, Object> map = new HashMap();
        List rowVOList = null;
        List rowVOResultList = null;

        label147:
        {
            Map<String, Object> var31;
            try {
                TableName tableName = TableName.valueOf(hbaseTableName);
                table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
                Scan scan = new Scan();
                scan.withStartRow(Bytes.toBytes(startRowKey));
                scan.withStopRow(Bytes.toBytes(endRowKey));
                scan.setFilter(filters);
                scan.setCaching(1000);
                ResultScanner resultScanner = table.getScanner(scan);
                rowVOList = this.loopResults(resultScanner);

                int totalCount = rowVOList.size();// 记录总数
                if (totalCount != 0) {
                    map.put("totalCount", totalCount);
                    if (isReverse) {
                        Collections.reverse(rowVOList);
                    }
                    if (pageNum >= 1 && pageSize > 0) {
                        Integer pageCount = 0; // 页数
                        if (totalCount % pageSize == 0) {
                            pageCount = totalCount / pageSize;
                        } else {
                            pageCount = totalCount / pageSize + 1;
                        }
                        int fromIndex = 0; // 开始索引
                        int toIndex = 0; // 结束索引
                        if (pageNum != pageCount) {
                            fromIndex = (pageNum - 1) * pageSize;
                            toIndex = fromIndex + pageSize;
                        } else {
                            fromIndex = (pageNum - 1) * pageSize;
                            toIndex = totalCount;
                        }

                        rowVOResultList = rowVOList.subList(fromIndex, toIndex);
                    } else {
                        rowVOResultList = rowVOList;
                    }

                    map.put("rowVOList", rowVOResultList);
                    break label147;
                }
                map.put("totalCount", 0);
                map.put("rowVOList", (Object) null);
                var31 = map;
            } catch (IOException var28) {
                log.error("selectDataByRowFilterPage，错误信息是" + var28.getMessage());
                var28.printStackTrace();
                break label147;
            } finally {
                try {
                    if (table != null) {
                        table.close();
                    }
                } catch (IOException var27) {
                    var27.printStackTrace();
                }

            }
            return var31;
        }

        log.info("selectDataByRowFilterPage，根据行过滤分页方法，map条数是：" + map.size());
        return map;
    }

    public Map<String, Object> selectByRowFilterPageReverse(String hbaseTableName, String min, String max, String type, int pageSize, int pageNum) {
        log.info("selectByRowFilterPageReverse方法，根据主键过滤分页倒排方法，表名是：" + hbaseTableName + "，最小值是：" + min + "，最大值是：" + max + "，类型是：" + type + "，页面大小：" + pageSize + "，页数：" + pageNum);
        Table table = null;
        Map<String, Object> map = new HashMap();
        List rowVOList = null;

        label147:
        {
            Map<String, Object> var31;
            try {
                TableName tableName = TableName.valueOf(hbaseTableName);
                table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);
                Scan scan = new Scan();
                scan.setFilter(this.getRowFilters(min, max, type, (String) null));
                scan.setCaching(1000);
                ResultScanner resultScanner = table.getScanner(scan);
                List<String> rowkeyList = new ArrayList();
                Iterator var14 = resultScanner.iterator();

                String endRowkey;
                while (var14.hasNext()) {
                    Result result = (Result) var14.next();
                    endRowkey = Bytes.toString(result.getRow());
                    rowkeyList.add(endRowkey);
                }

                int totalCount = rowkeyList.size();
                if (totalCount != 0) {
                    map.put("totalCount", totalCount);
                    Collections.reverse(rowkeyList);
                    String startRowkey = "";
                    endRowkey = "";
                    if (pageNum >= 1 && pageSize > 0) {
                        int lastPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
                        if (pageNum == lastPage) {
                            startRowkey = (String) rowkeyList.get(pageSize * (pageNum - 1));
                            endRowkey = (String) rowkeyList.get(totalCount - 1);
                        } else {
                            startRowkey = (String) rowkeyList.get(pageSize * (pageNum - 1));
                            endRowkey = (String) rowkeyList.get(pageSize * pageNum - 1);
                        }
                    } else {
                        startRowkey = (String) rowkeyList.get(0);
                        endRowkey = (String) rowkeyList.get(totalCount - 1);
                    }

                    Scan scanTemp = new Scan();
                    scanTemp.withStartRow(endRowkey.getBytes(), true);
                    scanTemp.withStopRow(startRowkey.getBytes(), true);
                    scanTemp.setCaching(1000);
                    ResultScanner resultScannerTemp = table.getScanner(scanTemp);
                    rowVOList = this.loopResults(resultScannerTemp);
                    Collections.reverse(rowVOList);
                    map.put("rowVOList", rowVOList);
                    break label147;
                }

                map.put("totalCount", 0);
                map.put("rowVOList", (Object) null);
                var31 = map;
            } catch (IOException var28) {
                log.error("selectByRowFilterPageReverse方法，错误信息是" + var28.getMessage());
                var28.printStackTrace();
                break label147;
            } finally {
                try {
                    if (table != null) {
                        table.close();
                    }
                } catch (IOException var27) {
                    var27.printStackTrace();
                }

            }
            return var31;
        }

        log.info("selectByRowFilterPageReverse方法，根据主键过滤分页倒排方法，map条数是：" + map.size());
        return map;
    }

    public HbaseResultDO selectByRowFilterPage(String hbaseTableName, FilterList filter, int pageSize, int pageNum) {
        log.info(
                "selectByRowFilterPage方法，根据主键过滤分页方法，表名是：" + hbaseTableName
                        + "，页面大小：" + pageSize + "，页数：" + pageNum);

        Table table = null;

        HbaseResultDO hbaseResultDO = new HbaseResultDO();

        try {

            TableName tableName = TableName.valueOf(hbaseTableName);

            table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);

            Scan scan = new Scan();
            FilterList rowFilters = getRowFilters(null, null, null, null);
            if (filter != null) {
                rowFilters.addFilter(filter);
            }
            scan.setFilter(rowFilters);

            scan.setCaching(1000);

            ResultScanner resultScanner = table.getScanner(scan);

            hbaseResultDO = getHbaseResultDO(table, resultScanner, pageSize, pageNum);

        } catch (IOException e) {

            log.error("selectByRowFilterPage方法，错误信息是" + e.getMessage());

            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                if (table != null) {

                    table.close();
                }
            } catch (IOException e) {

                e.printStackTrace();
            }
        }

        return hbaseResultDO;
    }



    private HbaseResultDO getHbaseResultDO(Table table, ResultScanner resultScanner, int pageSize, int pageNum)
            throws IOException {

        HbaseResultDO hbaseResultDO = new HbaseResultDO();

        List<String> rowkeyList = new ArrayList<>();

        for (Result result : resultScanner) {

            String rowkey = Bytes.toString(result.getRow());

            rowkeyList.add(rowkey);
        }

        int totalCount = rowkeyList.size();

        if (totalCount == 0) {

            hbaseResultDO.setTotal(0);

            return hbaseResultDO;
        }

        hbaseResultDO.setTotal(totalCount);

        int startIndex = 0;

        int endIndex = 0;

        if (pageNum >= 1 && pageSize > 0) {

            int lastPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;

            if (pageNum == lastPage) {

                startIndex = pageSize * (pageNum - 1);

                endIndex = totalCount - 1;

            } else {
                startIndex = pageSize * (pageNum - 1);

                endIndex = pageSize * pageNum - 1;
            }
        } else {
            endIndex = totalCount - 1;
        }
        List<Get> getList = new ArrayList();

        for (int i = startIndex; i <= endIndex; i++) {//把rowkey加到get里，再把get装到list中

            Get get = new Get(Bytes.toBytes(rowkeyList.get(i)));

            getList.add(get);
        }
        //重点在这，直接查getList<Get>
        Result[] results = table.get(getList);

        hbaseResultDO.setResults(results);
        return hbaseResultDO;
    }


    private FilterList getRowFilters(String max, String min, String type, String prefix) {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        RowFilter filter3;
        if (max != null && !"".equals(max)) {
            filter3 = new RowFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, new BinaryComparator(max.getBytes()));
            filterList.addFilter(filter3);
        }

        if (min != null && !"".equals(min)) {
            filter3 = new RowFilter(CompareFilter.CompareOp.GREATER_OR_EQUAL, new BinaryComparator(min.getBytes()));
            filterList.addFilter(filter3);
        }

        if (type != null && !"".equals(type)) {
            filter3 = new RowFilter(CompareFilter.CompareOp.EQUAL, new RegexStringComparator(".*-" + type));
            filterList.addFilter(filter3);
        }

        if (prefix != null && !"".equals(prefix)) {
            PrefixFilter filter5 = new PrefixFilter(prefix.getBytes());
            filterList.addFilter(filter5);
        }

        KeyOnlyFilter filter6 = new KeyOnlyFilter();
        filterList.addFilter(filter6);
        return filterList;
    }









    private FilterList getFamilyFilter(String[] params) {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        String[] var3 = params;
        int var4 = params.length;

        for (int var5 = 0; var5 < var4; ++var5) {
            String param = var3[var5];
            Filter filter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(param.getBytes()));
            filterList.addFilter(filter);
        }

        KeyOnlyFilter filter1 = new KeyOnlyFilter();
        filterList.addFilter(filter1);
        return filterList;
    }

    private FilterList getQualifierFilter(String[] params) {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        String[] var3 = params;
        int var4 = params.length;

        for (int var5 = 0; var5 < var4; ++var5) {
            String param = var3[var5];
            Filter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(param.getBytes()));
            filterList.addFilter(qualifierFilter);
        }

        KeyOnlyFilter filter1 = new KeyOnlyFilter();
        filterList.addFilter(filter1);
        return filterList;
    }

    private FilterList getValueFilter(String[] params) {
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
        String[] var3 = params;
        int var4 = params.length;

        for (int var5 = 0; var5 < var4; ++var5) {
            String param = var3[var5];
            Filter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(param));
            filterList.addFilter(valueFilter);
        }

        KeyOnlyFilter filter1 = new KeyOnlyFilter();
        filterList.addFilter(filter1);
        return filterList;
    }


    public void queryTable(String tableNameString) throws Exception{

        TableName tableName = TableName.valueOf(tableNameString);

        Table table = HBaseConnectionUtils.getInstance().getConnection().getTable(tableName);

        ResultScanner scanner = table.getScanner(new Scan());

        for (Result result : scanner) {

            byte[] row = result.getRow();
            System.out.println("rowKey = " + row);


        }


    }




}