南修子学Hbase-Hbase java API

package org.nanxiuzi.test;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.regionserver.NoSuchColumnFamilyException;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;
import java.util.Iterator;

/**
 * DDL:
 * 1.判断表是否存在
 * 2、创建表
 * 3、创建命名空间
 * 4、删除表
 *
 * DML：
 * 5、插入数据
 * 6、查数据（get）
 * 7、查数据（scan）
 * 8、删除数据
 *
 * hbase 2.1.0
 */
public class TestAPI {
    private static Connection connection=null;
    private static Admin admin=null;

    static{
        //配置信息
        //HBaseConfiguration conf = new HBaseConfiguration();//老版本的
        Configuration conf = HBaseConfiguration.create();
        //在hbase-site.xml里面查看
        conf.set("hbase.zookeeper.quorum","rhel072:2181,rhel079:2181,rhel076:2181");
        // conf.set("hbase.zookeeper.property.clientPort", "2181");
        // HBaseAdmin hBaseAdmin = new HBaseAdmin(conf); //老版本的
        //操作对象信息
        try {
            //获取连接对象
            connection = ConnectionFactory.createConnection(conf);
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 关闭资源
     */
    public static void close(){
        if(connection!=null){
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(admin!=null){
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 判断表存不存在
     * @param tableName
     * @return
     * @throws IOException
     */
    public static boolean isTableExist(String tableName) throws IOException {
        return admin.tableExists(TableName.valueOf(tableName));
    }


    /**
     * 创建表
     * @param tableName 表名
     * @param columnFamilyArr  可变形参，列族
     * @throws IOException
     */
    public static void createTable(String tableName,String ... columnFamilyArr) throws IOException {
        //判断列族信息
        if(columnFamilyArr.length==0){
            System.out.println("请设置列族信息");
            return;
        }
        //判断表是否已经存在
        if(isTableExist(tableName)){
            System.out.println("表"+tableName+"已经存在");
            return;
        }
        //创建表描述器构建器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName));
        for(String cf : columnFamilyArr){
            //列族描述器构建器
            ColumnFamilyDescriptorBuilder columnFamilyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(cf.getBytes());
            //增加列族到表描述器构建器里面
            tableDescriptorBuilder.setColumnFamily(columnFamilyDescriptorBuilder.build());
        }
        //表描述器
        TableDescriptor build = tableDescriptorBuilder.build();
        //创建表
        admin.createTable(build);
        System.out.println("表创建成功");
    }

    /**
     * 删除表
     * @param tableName 表名
     * @throws IOException
     */
    public static void dropTable(String tableName) throws IOException {
        if(!isTableExist(tableName)){
            System.out.println("表不存在");
            return;
        }
        try {
            admin.disableTable(TableName.valueOf(tableName));
            admin.deleteTable(TableName.valueOf(tableName));
        } catch (IOException e) {
            System.out.println("删除失败");
            e.printStackTrace();
        }
        System.out.println("删除成功");
    }

    /**
     * 创建命名空间
     * @param nameStr
     * @throws IOException
     */
    public static void createNameSpace(String nameStr)   {
        //得到命名空间描述器
        NamespaceDescriptor build = NamespaceDescriptor.create(nameStr).build();
        try {
            admin.createNamespace(build);
        }catch (NamespaceExistException e){
            System.out.println(nameStr+"命名空间已经存在");
        }catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(nameStr+"命名空间创建成功");
    }

    /**
     * 插入数据到hbase
     * @param tableName 表名
     * @param rowKey rowkey
     * @param columnFamily 列族
     * @param columnQualifier 列
     * @param valueData 值
     * @throws IOException
     */
    public static void putData(String tableName,String rowKey,String columnFamily,String columnQualifier,String valueData) throws IOException {
        //1、获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        //创建put对象
        Put put = new Put(Bytes.toBytes(rowKey));
        //给put填值
        put.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(columnQualifier),Bytes.toBytes(valueData));
        //put数据
        table.put(put);
        //关闭资源
        table.close();
    }

    /**
     * get方式查询数据
     * @param tableName 表名
     * @param rowKey rowkey
     * @param columnFamily 列族
     * @param columnQualifier 列
     * @throws IOException
     */
    public static void getData(String tableName,String rowKey,String columnFamily,String columnQualifier) throws IOException {
        //获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        //创建Get对象
        Get get = new Get(Bytes.toBytes(rowKey));
        if(!columnFamily.isEmpty() && columnQualifier.isEmpty()) {
            get.addFamily(Bytes.toBytes(columnFamily));
        }
        if(!columnFamily.isEmpty() && !columnQualifier.isEmpty()) {
            get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnQualifier));
        }
        get.readAllVersions();//获取所有的版本
        //get.readVersions(10);//获取最新的10条版本
        //上面两个获取版本的不生效，暂不知为啥
        //获取数据
        try {
            Result result = table.get(get);
            for (Cell cell : result.rawCells()) {
                //打印数据
                System.out.println("CF:" + Bytes.toString(CellUtil.cloneFamily(cell))
                        + " CQ:" + Bytes.toString(CellUtil.cloneQualifier(cell))
                        + " Value:" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }catch (NoSuchColumnFamilyException e){
            System.out.println(columnFamily+" ： 该列族找不到");
        }
        //关闭资源
        table.close();
    }

    /**
     * scan方式查询数据
     * @param tableName 表名
     * @throws IOException
     */
    public static void scanData(String tableName) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Scan scan = new Scan();
        scan.setMaxResultSize(10);//无效
        ResultScanner scanner = table.getScanner(scan);
        Iterator<Result> iterator = scanner.iterator();
        while(iterator.hasNext()){
            Result next = iterator.next();
            for (Cell cell : next.rawCells()) {
                //打印数据
                System.out.println("CF:" + Bytes.toString(CellUtil.cloneRow(cell))
                        + " CF:" + Bytes.toString(CellUtil.cloneFamily(cell))
                        + " CQ:" + Bytes.toString(CellUtil.cloneQualifier(cell))
                        + " Value:" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
        table.close();
    }

    /**
     * 删除数据
     * @param tableName 表名
     * @param rowKey rowkey
     * @param columnFamily 列族 （不能单独删除删列名）
     * @param columnQualifier 列名
     */
    public static void deleteData(String tableName,String rowKey,String columnFamily,String columnQualifier) throws IOException {
        Table table = connection.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        if(!columnFamily.isEmpty() && columnQualifier.isEmpty()) {
            delete.addFamily(Bytes.toBytes(columnFamily));
        }
        if(!columnFamily.isEmpty() && !columnQualifier.isEmpty()) {
            //addColumn 不建议用
            //addColumn 如果不传时间戳就是删除最新的一条记录，如果传了时间戳就是删除时间戳的那条记录  总之addColumn都是删除单条记录
            //delete.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(columnQualifier));
            
            //addColumns 如果不传时间戳就是删除所有的，如果传了时间戳就删除该时间戳之前的所有
            delete.addColumns(Bytes.toBytes(columnFamily), Bytes.toBytes(columnQualifier));

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

    public static void main(String[] args) throws IOException {

        /*1、测试表是否存在*/
        //System.out.println(isTableExist("stu3"));

        /*2、测试创建表*/
        //createTable("stu4","info","nums");

        /*3、测试删除表*/
        //dropTable("stu4");

        /*4、测试创建命名空间*/
        //createNameSpace("hrxspace"); //查看命名空间的命令： list_namespace
        /*测试在创建的命名空间下面创建表*/
        //createTable("hrxspace:stu4","info","nums");

        /*测试插入数据    scan 'hrxspace:stu4'*/
        //putData("hrxspace:stu4","10086","info","name","nanxiuzi");
        //putData("hrxspace:stu4","10087","info","name","dashuju");

        /*测试get获取数据*/
        //getData("hrxtest","1001","","");

        /*测试scan获取数据*/
        //scanData("hrxtest");

        /*测试删除数据*/
        //deleteData("hrxtest","1002","info","name");
        //关闭资源
        close();
    }
}