hbase帮助类

package cn.piesat.dbhelper;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.filter.FilterList.Operator;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.log4j.Logger;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
* hbase数据库基本CRUD接口
* @author wudongdong
*/
public class HbaseHelper {

private Logger logger = Logger.getLogger(HbaseHelper.class);
private Admin admin = null;
private Connection connection = null;
private Configuration conf = null;

/**
 * 初始化
 * @param path 配置文件路径
 */
public HbaseHelper(String path) {
    try {
        InputStream inputStream = HbaseHelper.class.getClassLoader().getResourceAsStream(path);
        Properties properties = new Properties();
        properties.load(inputStream);
        conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", properties.getProperty("zookeeperAddress"));
        conf.set("hbase.zookeeper.property.clientPort", properties.getProperty("zookeeperPort"));
        connection = ConnectionFactory.createConnection(conf);
        this.admin = this.connection.getAdmin();
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**关闭连接*/
public void closeConnect(){
    try{
        if (connection != null && admin != null){
            connection.close();
            admin.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
}

/**
 * 创建表
 * @param tableName 表名
 * @param colFamiles 列族集合
 * @return 创建是否成功
 */
public Boolean createTable(String tableName, String[] colFamiles) {
    Boolean flag = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(TableName.valueOf(tableName))) {
            logger.info(tableName + "exist!");
        } else {
            HTableDescriptor desc = new HTableDescriptor(tableNameObj);
            for (String colFamily : colFamiles) {
                desc.addFamily(new HColumnDescriptor(colFamily));
            }
            admin.createTable(desc);
            flag = true;
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return flag;
}

/**
 * 删除表
 * @param tableName 表名
 * @return 删除是否成功
 */
public Boolean deleteTable(String tableName) {
    Boolean flag = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            admin.disableTable(tableNameObj);
            admin.deleteTable(tableNameObj);
            flag = true;
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return flag;
}

public Boolean tableExist(String tableName) {
    Boolean result = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        result = admin.tableExists(tableNameObj);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}

/**
 * 添加一条记录
 * @param tableName 表名
 * @param put 要保存的对象
 * @return 插入是否成功
 */
public Boolean insertData(String tableName, Put put) {
    Boolean flag = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            Table table = connection.getTable(tableNameObj);
            table.put(put);
            table.close();
            flag = true;
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return flag;
}

/**
 * 批量插入数据
 * @param tableName 表名
 * @param puts put集合
 * @return 插入是否成功
 */
public Boolean insertBatchData(String tableName, List<Put> puts) {
    Boolean flag = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            Table table = connection.getTable(tableNameObj);
            table.put(puts);
            table.close();
            flag = true;
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return flag;
}

/**
 * 根据rowkey查询一条数据
 * @param tableName 表名
 * @param rowkey rowkey
 * @return 查询结果
 */
public Result getScanResult(String tableName, String rowkey) {
    Result result = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            Table table = connection.getTable(tableNameObj);
            Get get = new Get(Bytes.toBytes(rowkey));
            result = table.get(get);
            table.close();
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}

/**
 * 文件查找
 * @param tableName 表名
 * @param rowKey rowKey
 * @return 文件字节
 */
public byte[] getByteResult(String tableName, String rowKey) {
    byte[] data = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            Table table = connection.getTable(tableNameObj);
            Get get = new Get(Bytes.toBytes(rowKey));
            Result result = table.get(get);
            data = result.value();
            table.close();
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return data;
}

/**
 * 小于查询
 * @param tableName 表名
 * @param value 比较值
 * @return 查询结果
 */
public List<Result> lessFilterFind(String tableName,String value){
    List<Result> results = new ArrayList<>();
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            Filter filter = new RowFilter(CompareFilter.CompareOp.LESS, new BinaryComparator(Bytes.toBytes(value)));
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return results;
}

/**
 * 小于或等于查找
 * @param tableName 表名
 * @param value 比较值
 * @return 查询结果
 */
public List<Result> lessOrEqualFilterFind(String tableName,String value){
    List<Result> results = new ArrayList<>();
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            Filter filter = new RowFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes(value)));
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return results;
}

/**
 * 大于查询
 * @param tableName 表名
 * @param value 比较值
 * @return 查询结果
 */
public List<Result> greaterFilterFind(String tableName,String value){
    List<Result> results = new ArrayList<>();
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            Filter filter = new RowFilter(CompareFilter.CompareOp.GREATER, new BinaryComparator(Bytes.toBytes(value)));
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return results;
}

/**
 * 大于或等于查询
 * @param tableName 表名
 * @param value 比较值
 * @return 查询结果
 */
public List<Result> greaterOrEqualFilterFind(String tableName,String value){
    List<Result> results = new ArrayList<>();
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            Filter filter = new RowFilter(CompareFilter.CompareOp.GREATER_OR_EQUAL, new BinaryComparator(Bytes.toBytes(value)));
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return results;
}

/**
 * LIKE查询
 * @param tableName 表名
 * @param value 要匹配的值
 * @return 查找结果
 */
public List<Result> likeFilterFind(String tableName,String value){
    List<Result> results = new ArrayList<>();
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(value));
            scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
    return results;
}

/**
 * 查询所有数据
 * @param tableName 表名
 * @return 查询的结果
 */
public List<Result> getResultScanner(String tableName) {
    List<Result> results = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return results;
}

/**
 * 根据范围查询
 * @param tableName 表名
 * @param startRow 起始行
 * @param stopRow 结束行
 * @return 查询的结果
 */
public List<Result> getResultScanner(String tableName, String startRow, String stopRow) {
    List<Result> results = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            scan.setStartRow(Bytes.toBytes(startRow));
            scan.setStopRow(Bytes.toBytes(stopRow));
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        } else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return results;
}

/**
 * 根据rowkey删除记录
 * @param tableName 表名
 * @param rowKey rowKey
 * @return 删除是否成功
 */
public Boolean delete(String tableName, String rowKey) {
    Boolean flag = false;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            Table table = connection.getTable(tableNameObj);
            Delete delete = new Delete(Bytes.toBytes(rowKey));
            table.delete(delete);
            table.close();
            flag = true;
        }else {
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
        logger.error(e.toString());
    }
    return flag;
}

/**
 * 根据条件查询
 * @param tableName 表名
 * @param filters 查询条件
 * @return 查询结果集
 */
public List<Result> getResultScannerByFilterList(String tableName, List<Filter> filters) {
    List<Result> results = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            FilterList filterList = new FilterList(Operator.MUST_PASS_ALL, filters);
            scan.setFilter(filterList);
            ResultScanner scanner = table.getScanner(scan);
            for(Result result : scanner){
                results.add(result);
            }
            scanner.close();
            table.close();
        }else{
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
        logger.error(e.toString());
    }
    return results;
}

/**
 * 多条件查询
 * @param tableName 表名
 * @param startRow 开始查询行
 * @param stopRow 结束查询行
 * @param filters 查询条件
 * @return 查询结果集
 */
public List<Result> getResultScannerByRowKeyAndFilters(String tableName, String startRow, String stopRow, List<Filter> filters) {
    List<Result> results = null;
    try {
        TableName tableNameObj = TableName.valueOf(tableName);
        if (admin.tableExists(tableNameObj)) {
            results = new ArrayList<>();
            Table table = connection.getTable(tableNameObj);
            Scan scan = new Scan();
            scan.setStartRow(Bytes.toBytes(startRow));
            scan.setStopRow(Bytes.toBytes(stopRow));
            if (filters.size() > 0) {
                FilterList filterList = new FilterList(Operator.MUST_PASS_ALL, filters);
                scan.setFilter(filterList);
            }
            //查询得到的结果集
            ResultScanner scanner = table.getScanner(scan);
            for (Result result : scanner) {
                results.add(result);
            }
            scanner.close();
            table.close();
        }else{
            logger.info(tableName + "not exist!");
        }
    } catch (Exception e) {
        e.printStackTrace();
        logger.error(e.toString());
    }
    return results;
}

}