用java API连接HBase

版权声明：转载附链接并联系 https://blog.csdn.net/BigCabbageFy/article/details/84677865

创建maven项目

1、在resource包下导入 core-site.xml、hbase-site.xml、hdfs-site.xml、log4j.properties 文件

2、在pom.xml文件中添加依赖：

 <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.3.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>
    
    //防止pom.xml文件报错，如果pom.xml文件在加入上面两个依赖没有报错时，可以不要这个依赖
     <dependency>
        <groupId>jdk.tools</groupId>
        <artifactId>jdk.tools</artifactId>
        <version>1.6</version>
        <scope>system</scope>
        <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
    </dependency>
    

Hbase API

1、判断表是否存在

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.HBaseConfiguration;
public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 判断表是否存在
    **/
    public static boolean isExist(String tableName) {
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        //创建管理表对象
        Admin admin = conncetion.getAdmin();
        return admin.tableExists(TableName.valueOf(tableName));
    }

    public static void main(String[] args){
        System.out.println (isExist("aaa"));
    }
}

2、HBase表的创建

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * Hbase表的创建
    **/
    public static void createTable(String tableName, String... columnFamily) throws IOException{
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Admin admin = connection.getAdmin();
        //isExist()方法同上一个代码块
        //判断表是否存在，如果存在则不创建，如果不存在则创建表
        if (isExist(tableName)) {
            System.out.println("表已存在！")
        } else {
            //创建表描述器
            HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(tableName));
            //遍历传入参数：列族
            for(String cf: columnFamily) {
                
                //添加列族，new列描述器
                htd.addFamily(new HColumnDescriptor(cf));
            }
            
            //创建表
            admin.createTable(htd);
        }
       
    }
    //主方法测试
    public static void main(String[] args){
       createTable("staff", "info1", "info2");
    }
}

3、hbase表的删除

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * Hbase表的删除
    **/
    public static void deleteTable(String tableName) throws IOException {
        //连接hbase
        Connection connection = ConnectionFactory.createConnection(conf);
        Admin admin = connection.getAdmin();
        
        //判断表是否存在
        if(isExist(tableName)) {
            //将表置为无效
            if (!admin.isTableDisabled(TableName.valueOf(tableName))){
                admin.disableTable(TableName.valueOf(tableName));
            }
            //删除表
            admin.deleteTable(TableName.valueOf(tableName));
            System.out.println("表已删除");
        }else {
            System.out.println("表不存在");
        }
    }
    //主方法测试
    public static void main(String[] args){
       deleteTable("staff");
    }
}

4、添加一行数据

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 添加一行数据
    **/
    public static void addRow(String tableName, String rowKey, String cf,
     String column, String value) throws IOException {
       
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Table table = connection.getTable(TableName.valueOf(tableName));
        
        // 判断表是否存在
        //如果表存在
        if (isExist(tableName)) {
            //new Put对象
            Put put = new Put(Bytes.toBytes(rowKey));
            //添加列族到put中
            put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(column), Bytes.toBytes(value));
            //添加数据
            table.put(put);
        //如果表不存在
        }else {
            //创建表
            createTable(tableName, cf);

            Put put = new Put(Bytes.toBytes(rowKey));
            put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(column), Bytes.toBytes(value));
            table.put(put);
        }
        System.out.println("数据插入成功");
    }
    //主方法测试
    public static void main(String[] args){
      addRow("aaa", "1001", "info1", "name", "nick");
    }
}

5、删除一行数据

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 删除一行数据
    **/
    public static void deleteRow(String tableName,String rowKey ,String cf) throws IOException {
        
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Table table = connection.getTable(TableName.valueOf(tableName));
        
        //new Delete对象
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        //删除数据
        table.delete(delete);
    }
    //主方法测试
    public static void main(String[] args){
      deleteRow("aaa", "1001", null);
    }
}

6、删除多行数据

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 删除多行数据
    **/
    public static void deleteRows(String tableName, String... rowKeys) throws IOException {
        
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Table table = connection.getTable(TableName.valueOf(tableName));
        
        //创建一个泛型为Delete的列表
        List<Delete> list = new ArrayList<Delete>();
        //遍历传入的rowKeys
        for(String row: rowKeys) {
            //new Delete对象
            Delete delete = new Delete(Bytes.toBytes(row));
            //将delete对象添加到队列中
            list.add(delete);
        }
        //删除数据
        table.delete(list);
    }
    
    //主方法测试
    public static void main(String[] args){
        deleteRows("aaa", "1001", "1002");
    }
}

7、扫描整张表

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 扫描整张表
    **/
    public static void getAllRows(String tableName) throws IOException {
        
        //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Table table = connection.getTable(TableName.valueOf(tableName));
        
        //new一个scan对象用于扫描全表
        Scan scan = new Scan();
        ResultScanner resultScanner = table.getScanner(scan);
        
        //遍历resultScanner对象
        for(Result result: resultScanner) {
            //将result对象转换成单元格形式，存放进数组中
            Cell[] cells = result.rawCells();
            //遍历数组
            for(Cell cell:cells) {
                //分别得到相关数据
                System.out.println("行键" + Bytes.toString(CellUtil.cloneRow(cell)));
                System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
                System.out.println("列" + Bytes.toString(CellUtil.cloneQualifier(cell)));
                System.out.println("值" + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }
    }
    
    //主方法测试
    public static void main(String[] args){
        getAllRows("aaa");
    }
        }

8、得到一个具体的数据

public class HbaseDemo {
    public static Configuration conf;
    /**
    * 静态代码块的特点：
    * 随着类的加载而执行，而且只执行一次
    * 静态代码块的执行顺序优先于main函数
    */
    static{
        conf = HBaseConfiguration.create();
    }
    /**
    * 得到一个具体的数据
    **/
    public static void getRow(String tableName, String rowKey) throws IOException {
       
       //连接HBase
        Connection connection = ConnectionFactory.createConnection(conf);
        Table table = connection.getTable(TableName.valueOf(tableName));
        
        //利用get对象获取具体数据
        Get get = new Get(Bytes.toBytes(rowKey));
        Result result = table.get(get);
        //将result对象转换成单元格形式，存放进数组中
        Cell[] cells = result.rawCells();
        //遍历数组
        for(Cell cell : cells) {
            //分别得到相关数据
            System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
            System.out.println("列" + Bytes.toString(CellUtil.cloneQualifier(cell)));
            System.out.println("值" + Bytes.toString(CellUtil.cloneValue(cell)));
        }
    }
    
    //主方法测试
    public static void main(String[] args){
        getRow("aaa", "1003");
    }
}