HBase深入----API

创建Maven工程

配置pom文件

 <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.3.1</version>
        </dependency>

APITest

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.yarn.webapp.hamlet.Hamlet;


import java.io.IOException;

/**
 * @Auther: Wangxy
 * @Date: 2021/11/2 - 11 - 02 - 18:15
 * @Description: IntelliJ IDEA
 * @version: 1.0
 */

public class TeesAPI {
    /**
     * DDL
     * 1.判断表是否存在
     * 2.创建表
     * 3.删除表
     * 4.创建命名空间
     * 5.删除命名空间
     *
     *
     * DML
     * 1.插入数据
     * 2.查数据
     * 3.scan数据
     * 4.删除数据
     */
    private static Connection connection = null;
    private static Admin admin = null ;
    static {

        try {
            //由于HBaseConfiguration为已经淘汰的方法故选择新方法尽心调用
            //HBaseConfiguration entries = new HBaseConfiguration();
            //新方法中需要创建新的API
            Configuration entries = HBaseConfiguration.create();
            //配置信息
            entries.set("hbase.zookeeper.quorum","master,slave1,slave2");
            //获取管理员对象
            //HBaseAdmin为旧API的方法
            //HBaseAdmin hBaseAdmin = new HBaseAdmin(entries);
            //需要获取新的连接的工厂类来获取管理员对象 根据entries来获取配置信息
              connection = ConnectionFactory.createConnection(entries);
            //获得连接(connection)后来get admin
            //admin在之后的也需要进行获取故 将其封装到静态的方法中
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //判断是否存在 测试是否与数据库接通(旧API)
    public static boolean isTableExist(String tableName) throws IOException {
//        //由于HBaseConfiguration为已经淘汰的方法故选择新方法尽心调用
//        //HBaseConfiguration entries = new HBaseConfiguration();
//        //新方法中需要创建新的API
//        Configuration entries = HBaseConfiguration.create();
//        //配置信息
//        entries.set("hbase.zookeeper.quorum","master,slave1,slave2");
//        //获取管理员对象
//        //HBaseAdmin为旧API的方法
//        //HBaseAdmin hBaseAdmin = new HBaseAdmin(entries);
//        //需要获取新的连接的工厂类来获取管理员对象 根据entries来获取配置信息
//        Connection connection = ConnectionFactory.createConnection(entries);
//        //获得连接(connection)后来get admin
//        //admin在之后的也需要进行获取故 将其封装到静态的方法中
//        Admin admin = connection.getAdmin();
        boolean exists = admin.tableExists(TableName.valueOf(tableName));
        //关闭连接
        //由于之后会有其他的admin的操作故 应在最后进行close
      //  admin.close();
        //返回结果
        return exists;
    }

    //创建表
    public static void createTable( String tablename,String... cfs) throws IOException {

        //1.判断是否存在列族信息
        if (cfs.length<=0){
            System.out.println("请设置列族信息");
            return;
        }
        //2.判断表是否存在
        if (isTableExist(tablename)){
            System.out.println(tablename+"表已存在");
            return;
        }
        //3.创建表描述器
        HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf(tablename));
        //由于列族信息不止一个 我们需要循环添加列族信息

        for (String cf :cfs){
            //创建列族描述器
            //添加具体的列族信息
            HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cf);

            hTableDescriptor.addFamily(hColumnDescriptor);
        }
        //创建表流程
        //1.创建表
        admin.createTable(hTableDescriptor);

    }
    //删除表
    public static void dropTable(String tablename) throws IOException {
        //判断表是否存在
        if(!isTableExist(tablename)){
            System.out.println( tablename+"表不存在");
            return;
        }
        //使表下线
        admin.disableTable(TableName.valueOf(tablename));
        //删除表
        admin.deleteTable(TableName.valueOf(tablename));

    }
    //创建命名空间
    public static void createNameSpace(String ns){
        //创建命名空间描述器
        NamespaceDescriptor build = NamespaceDescriptor.create(ns).build();
        //创建命令
        try {
            admin.createNamespace(build);
        } catch (NamespaceExistException e){
            System.out.println(ns+"命名空间已存在");
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("这里`");

    }
    //删除命名空间
    public static  void dropNamespace(String dns){
        try {
            admin.deleteNamespace(dns);
            System.out.println(dns+"命名空间已删除");
        }catch (NamespaceNotFoundException e){
            System.out.println(dns+"命名空间不存在");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //关闭资源
    public static void close(){
        if (admin != null){
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
    //DML
    //插入数据
    public static void putData(String tableName,String rowKey,String cf ,String cn ,String value) throws IOException {




        TableName tableName1=TableName.valueOf(tableName);
        // 1.获取表对象
        Table table = connection.getTable(tableName1);
        //2.创建put对象
        Put put = new Put(Bytes.toBytes(rowKey));
        //3.给put对象赋值
       put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
        //4.插入数据
        table.put(put);
        //关闭连接
        table.close();

    }
    //获取数据(get)
    public static void getData(String tableName,String rowkey,String cf,String cn) throws IOException {
        //获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        //创建get对象
        Get get = new Get(Bytes.toBytes(rowkey));
        //指定获取的列族
        //get.addFamily(Bytes.toBytes(cf));
        //获取指定列族和列
        get.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn));
        get.setMaxVersions();
        //获取数据
        Result result = table.get(get);
        //解析result
        for (Cell cell : result.rawCells()) {
            //打印数据
            System.out.println("CF:"+Bytes.toString(CellUtil.cloneFamily(cell))+"\n"+
                                "CN:"+ Bytes.toString(CellUtil.cloneQualifier(cell))+"\n"+
                                "Value:" + Bytes.toString(CellUtil.cloneValue(cell))+"\n"+ "-------------" );
        }
        //关闭表连接
        table.close();
    }
    //获取数据(scan)
    public static void scanTable(String tableName) throws IOException {
        //获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        //构建scan对象
        //扫描全表
       // Scan scan = new Scan(Bytes.toBytes();
        //扫描[1001,1002)
        Scan scan = new Scan(Bytes.toBytes("1001"),Bytes.toBytes("1002"));
        //扫描表
        ResultScanner scanner = table.getScanner(scan);
        //解析scanner
        for (Result result : scanner) {
            //解析并打印
            for (Cell cell : result.rawCells()) {
                System.out.println("RowKey:"+Bytes.toString(CellUtil.cloneRow(cell))+"\n"+
                        "CF:"+Bytes.toString(CellUtil.cloneFamily(cell))+"\n"+
                        "CN:"+ Bytes.toString(CellUtil.cloneQualifier(cell))+"\n"+
                        "Value:" + Bytes.toString(CellUtil.cloneValue(cell))+"\n"+ "-------------" );
            }
        }
        //关闭表连接
        table.close();
    }
    //删除数据
    public static void deleteData(String tableName,String rowKey,String cf,String cn) throws IOException {
        //获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        //构建删除对象(rowKey)相当于客户端操作的deleteall
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        //delete.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cn));
        //不指定时间戳 删除最新版本(建议使用addColumns)
        //delete.addColumns(Bytes.toBytes(cf),Bytes.toBytes(cn));
        //删除指定的列族
        delete.addFamily(Bytes.toBytes(cf));
        //删除数据(rowKey)
        table.delete(delete);
        //
        table.close();
    }
    public static void main(String[] args) throws IOException {
        //测试表是否存在
        // System.out.println(isTableExist("bigdata:stu3"));
        //System.out.println(isTableExist("bigdata:stu3"));
        //2.创建表测试
        createTable("stu","info1","info2");
        //3.删除表测试
        //wdropTable("stu");
        //4.创建命名空间测试
        //createNameSpace("test1");
        //删除表空间测试
        //dropNamespace("test1");
        //创建数据
        //putData("bigdata:stu1","1008","info2","country","china");

        putData("stu","1001","info2","name","zhangshan");
//        putData("bigdata:stu1","1008","info2","sex","male");
//        putData("bigdata:stu1","1008","info1","name","lisi");
//        putData("bigdata:stu1","1008","info1","sex","male");
        //putData("bigdata:stu1","1002","info2","country","english");
        //获取单行数据(get)

        //getData("bigdata:stu1", "1002", "info2", "country");
        //获取单行数据(scan)
        //scanTable("bigdata:stu1");
        deleteData("bigdata:stu1","1008","info1","sex");


        //由于在方法中定义了close方法 这里直接调用
        close();
    }
}