通过API实现对HBase表以及表数据进行增删查操作

通过API实现对HBase表以及表数据进行增删查操作

一、手动操作:

创建名字空间：create_namespace 'nameSpaceName'
创建表：create 'nameSpaceName:tbName', 'familyName','columnName'
删除表： 先禁用表 disable 'nameSpaceName:tbName' 然后删除 drop 'nameSpaceName:tbName'
扫描：scan 'nameSpaceName:tbName'
查询：get 'nameSpaceName:tbName','rowKey','familyName'
插入：put 'nameSpaceName:tbName','rowKey','familyName:id',1

二、代码API实现

import org.apache.hadoop.conf.Configuration;
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;


/**
 * @Author      王磊
 * @Date        2019/1/2
 * @ClassName   HBaseTableCRDU
 * @Description 通过API实现对HBase表/表数据进行增删查操作
 **/
public class HBaseTableCRDU {
    public static void main(String[] args) throws Exception {
        // 获取配置对象
        Configuration conf = HBaseConfiguration.create();
        // 通过连接工厂获取连接对象
        Connection conn = ConnectionFactory.createConnection(conf);
        // 通过表名获取表名对象（空间名：表名）
        TableName tbname = TableName.valueOf("nameSpaceName:tbName");
        // 通过表名对象获取表对象
        Table tb = conn.getTable(tbname);
        // 构建rowkey字节数组
        byte[] row = Bytes.toBytes("rowName");
        
		// ===== 表数据操作 ===== 
        // 增
        // 通过rowkey构建put对象
        Put put = new Put(row);
        // 分别获取列簇、列、值的数组对象
        byte[] family = Bytes.toBytes("familyName");
        byte[] column = Bytes.toBytes("columnName");
        byte[] putValue = Bytes.toBytes("value");
        // 通过定位数据与插入字节数据数对put对象添加Column
        Put putMeta = put.addColumn(family, column, putValue);
        // 执行插入
        tb.put(putMeta);

        // 查
        byte[] rowGet = Bytes.toBytes("rowName");
        Get getMeta = new Get(rowGet);
        Result result = tb.get(getMeta);
        byte[] familyGet = Bytes.toBytes("familyName");
        byte[] columnGet = Bytes.toBytes("columnName");
        byte[] columnValue = result.getValue(familyGet, columnGet);
        System.out.println("查询结果为：" + Bytes.toString(columnValue));

        // 删
        Delete del = new Delete(Bytes.toBytes("rowName"));
        del.addColumn(Bytes.toBytes("familyName"), Bytes.toBytes("columnName"));
        tb.delete(del);
		// ===== 表数据操作 ===== 
		createNameSpace(conn);
        createTable(conn);
        dropTable(conn);
        listNameSpace(conn);
        listTableName(conn);
        scanTable(conn);
        scanTable_2(conn);
    }
    
	/**
     * 创建名字空间
     * @param conn
     * @throws Exception
     */
    public static void createNameSpace(Connection conn) throws Exception {
        Admin admin = conn.getAdmin();
        NamespaceDescriptor nsd = NamespaceDescriptor.create("nameSpaceName").build();
        admin.createNamespace(nsd);
    }

    /**
     * 创建表
     * @param conn
     * @throws IOException
     */
    public static void createTable(Connection conn) throws IOException {
        Admin admin = conn.getAdmin();
        HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("nameSpaceName:tableName"));
        admin.createTable(htd);
    }

    /**
     * 删除表
     * @param conn
     * @throws IOException
     */
    public static void dropTable(Connection conn) throws IOException {
        Admin admin = conn.getAdmin();
        admin.disableTable(TableName.valueOf("nameSpaceName:tableName"));
        admin.deleteTable(TableName.valueOf("nameSpaceName:tableName"));
    }

    /**
     * 列出所有名字空间
     * @param conn
     * @throws IOException
     */
    public static void listNameSpace(Connection conn) throws IOException {
        Admin admin = conn.getAdmin();
        NamespaceDescriptor[] nsd = admin.listNamespaceDescriptors()
        for(NamespaceDescriptor ns: nsd){
            System.out.println(ns.getName());
        }
    }

    /**
     * 列出所有用户空间下的表
     * @param conn
     * @throws IOException
     */
    public static void listTableName(Connection conn) throws IOException {
        Admin admin = conn.getAdmin();
        TableName[] tbs = admin.listTableNames();
        for(TableName tb : tbs){
            System.out.println(tb.getNameAsString());
        }
    }

    /**
     * 扫描表（方式一）
     * @param conn
     * @throws IOException
     */
    public static void scanTable(Connection conn) throws IOException {
        Table tb = conn.getTable(TableName.valueOf("nameSpaceName:tableName"));
        Scan scan = new Scan();
        // 可以设置扫描的起始行（二者其一或者两者都选）
        scan.setStartRow(Bytes.toBytes("row1"));
        scan.setStopRow(Bytes.toBytes("tow50"));
        ResultScanner rs = tb.getScanner(scan);
        Iterator<Result> it = rs.iterator();
        while (it.hasNext()){
            // 行迭代
            Result re = it.next();
            Map<byte[], byte[]> metaMap = re.getFamilyMap(Bytes.toBytes("familyName"));
            // 列迭代
            for(Map.Entry<byte[], byte[]> m: metaMap.entrySet()){
                String columnName = Bytes.toString(m.getKey());
                String valueName = Bytes.toString(m.getValue());
                System.out.println(columnName + "," + valueName);
            }
        }
    }

    /**
     * 扫描表（方式二）
     * @param conn
     * @throws IOException
     */
    public static void scanTable_2(Connection conn) throws IOException {
        Table tb = conn.getTable(TableName.valueOf("nameSpaceName:tableName"));
        Scan scan = new Scan();
        // 设置扫描的起始行(略[扫描方式一有举例scanTable()])
        ResultScanner rs = tb.getScanner(scan);
        Iterator<Result> it = rs.iterator();
        while (it.hasNext()){
            Result re = it.next();
            // 行
            NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map = re.getMap();
            //  Map.Entry<family,<column,<timeStamp,value>>>
            // 列簇
            for(Map.Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> entry : map.entrySet()){
                System.out.println("Family:" + Bytes.toString(entry.getKey()));
                NavigableMap<byte[], NavigableMap<Long, byte[]>> columnMap = entry.getValue();
                // 列
                for(Map.Entry<byte[], NavigableMap<Long, byte[]>> columnEntry : columnMap.entrySet()){
                    System.out.println("column:" + Bytes.toString(columnEntry.getKey()));
                    Map<Long, byte[]> versionMap = columnEntry.getValue();
                    // 每个列同一个字段的不同版本
                    for(Map.Entry<Long, byte[]> versionEntry : versionMap.entrySet()){
                        System.out.println("version:" + Bytes.toString(versionEntry.getKey());
                        System.out.println("value:" + Bytes.toString(versionEntry.getValue()));
                    }
                }
            }
        }
    }
}