Java Api实现HBase的增删改查（工具类）

1.

获取hBase配置文件的工具类

package com.dgindusoft.connector.util;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 获取hBase配置文件的工具类
 *
 * @author: lil
 * @date: 2020/7/28
 */
@Component
@Order(value = 1)
public class GetPropertiesUtil {

    private static String quorum;

    @Value("${hbase.zookeeper.quorum}")
    public void setProQuorum(String quorumTemp) {
        quorum = quorumTemp;
    }

    public static String getQuorum() {
        return quorum;
    }
}

2.获取连接和关闭连接

package com.dgindusoft.connector.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Table;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @author lijj
 * @date 2020-03-29
 * 0.创建配置对象，获取habse的连接
 * 1.获取Habase连接对象
 * 2. 获取操作对象
 * 3.获取操作结果
 * 4.关闭数据库连接
 * 该类是封装数据库的连接和连接指定表的对象
 */
@Slf4j
@Component
@Order(value = 2)
public class HBaseConn {

    private static final HBaseConn INSTANCE = new HBaseConn();
    private static Configuration configuration;
    private static Connection connection;

    private HBaseConn() {
        try {
            if (configuration == null) {
                configuration = HBaseConfiguration.create();//创建配置对象，获取hbase的连接
                configuration.set("hbase.zookeeper.quorum", GetPropertiesUtil.getQuorum());
                log.debug("=======================================");
                log.debug(GetPropertiesUtil.getQuorum());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取数据库的连接
    private Connection getConnection() {
        if (connection == null || connection.isClosed()) {
            try {
                connection = ConnectionFactory.createConnection(configuration);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return connection;
    }

    public static Connection getHBaseConn() {
        return INSTANCE.getConnection();
    }

    public static Table getTable(String tableName) throws IOException {
        return INSTANCE.getConnection().getTable(TableName.valueOf(tableName));
    }

    public static void closeConn() {
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }
}

3.创建、删除表以及查看表是否存在、一次插入和批量插入

package com.dgindusoft.connector.util;

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.List;

/**
 * @author lijj
 * @date 2019-08-27
 */
public class HBaseUtil {

    /**
     * 创建HBase表.
     *
     * @param tableName 表名
     * @param cfs       列族的数组
     * @return 是否创建成功
     */
    public static boolean createTable(String tableName, List<String> cfs) {
        try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {//获取操作对象admin
            if (admin.tableExists(TableName.valueOf(tableName))) {
                return false;
            }
            List<ColumnFamilyDescriptor> familyDescriptors = new ArrayList<>(cfs.size());
            for (String column : cfs) {
                familyDescriptors.add(ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(column)).build());
        }
        TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName))
                .setColumnFamilies(familyDescriptors).build();
        admin.createTable(tableDescriptor);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    /**
     * 查看HBase表是否存在
     *
     * @param tableName 表名
     * @return 是否存在该表
     */
    public static boolean isTableExist(String tableName) {
        try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {
            if (admin.tableExists(TableName.valueOf(tableName))) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 删除hbase表.
     *
     * @param tableName 表名
     * @return 是否删除成功
     */
    public static boolean deleteTable(String tableName) {
        try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {
            admin.disableTable(TableName.valueOf(tableName));
            admin.deleteTable(TableName.valueOf(tableName));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    /**
     * hbase插入一条数据.
     *put参数 family列族名  column列名本身 val/data 列值
     * String family="info" string column= "name" string val = "zhangsan"
     * @param tableName 表名
     * @param rowKey    唯一标识
     * @param cfName    列族名（family)
     * @param qualifier 列标识 列名本身
     * @param data      数据 列值
     * @return 是否插入成功
     */
    public static boolean putRow(String tableName, String rowKey, String cfName, String qualifier,
                                 String data) {
        try (Table table = HBaseConn.getTable(tableName)) {
            Put put = new Put(Bytes.toBytes(rowKey));//把字符串变成字节序列
            put.addColumn(Bytes.toBytes(cfName), Bytes.toBytes(qualifier), Bytes.toBytes(data));//增加列
            table.put(put);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return true;
    }

    public static boolean putRows(String tableName, List<Put> puts) {
        try (Table table = HBaseConn.getTable(tableName)) {
            table.put(puts);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return true;
    }
            }

4.hbase基本操作service层

package com.dgindusoft.connector.service;


import com.dgindusoft.connector.entity.Result;
import org.apache.hadoop.hbase.client.Put;

import java.util.List;
import java.util.Map;

/**
 * @description: HBase基本操作
 * @author: lijj
 * @create: 2020-04-03 12:53
 **/
public interface BaseService {

    /**
     * 创建表
     *
     * @param tableName
     * @return
     */
    Result createTable(String tableName);

    /**
     * 插入数据
     *
     * @param tableName
     * @param deviceTime
     * @param modelID
     * @param deviceID
     * @param dataMap
     * @return
     */
    Result insertData(String tableName, String deviceTime, String modelID, String deviceID, Map<String, Object> dataMap);

    /**
     * 批量插入数据
     *
     * @param tableName
     * @param puts
     * @return
     */
    Result insertData(String tableName, List<Put> puts);
    /**
     * 判断表是否存在
     *
     * @param tableName
     * @return
     */
    Result isTableExist(String tableName);
}

5.service层实现类

package com.dgindusoft.connector.service.impl;

import com.dgindusoft.connector.util.HBaseUtil;
import com.dgindusoft.connector.entity.Result;
import com.dgindusoft.connector.entity.ResultCodeEnum;
import com.dgindusoft.connector.service.BaseService;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.stereotype.Service;


import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @description: HBase基本操作实现类
 * @author: lijj
 * @create: 2020-04-03 12:59
 **/
@Service
public class BaseServiceImpl implements BaseService {

    @Override
    public Result createTable(String tableName) {
        List<String> cfs = new ArrayList<>();
        cfs.add("data");
        if (HBaseUtil.createTable(tableName, cfs)) {
            return Result.ok().message("表创建成功");
        } else {
            return Result.setResult(ResultCodeEnum.TABLE_EXIST_ERROR);
        }
    }

    @Override
    public Result insertData(String tableName, String deviceTime, String modelID, String deviceID, Map<String, Object> dataMap) {
//        String rowKey = tableName + LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        String rowKey = modelID + deviceID + deviceTime;
        List<Put> puts = new ArrayList<>();
        Put put = new Put(Bytes.toBytes(rowKey));
        dataMap.forEach((key, value) -> {
            put.addColumn(Bytes.toBytes("data"), Bytes.toBytes(key),
                    Bytes.toBytes("" + value));
            puts.add(put);
        });
        try {
            HBaseUtil.putRows(tableName, puts);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ok().message("插入成功");
    }



    @Override
    public Result insertData(String tableName, List<Put> puts) {
        try {
            HBaseUtil.putRows(tableName, puts);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ok().message("插入成功");
    }

    @Override
    public Result isTableExist(String tableName) {
        Boolean result = HBaseUtil.isTableExist(tableName);
        if (result) {
            return Result.setResult(ResultCodeEnum.TABLE_EXIST_ERROR);
        } else {
            return Result.ok().message("该表不存在");
        }
    }
}