HBase API

HBase Java API

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
</dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>2.2.7</version>
</dependency>

<dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.6</version>
</dependency>
<dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.7.6</version>
</dependency>

基础代码：

package com.shujia.base;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * 数据库连接对象，数据库操作对象
 */
public class HBaseAPI {
    private Connection conn;
    private Admin admin;
    @Before
    public void getConnection() {
        try {
            //1、获取hbase集群的配置文件对象
            //0.90.0之前旧版本写法：
//        HBaseConfiguration conf = new HBaseConfiguration();
            //新版本写法：调用静态方法public static Configuration create()
            Configuration conf = HBaseConfiguration.create();

            //2、因为hbase的数据都一条元数据，元数据也存储再一张表中，这张表也有元数据，存储在zookeeper中
            //配置文件设置自己的zookeeper集群,conf中的"master:2181,node1:2181,node2:2181"前提是自己电脑中配置了host映射
            conf.set("hbase.zookeeper.quorum","master:2181,node1:2181,node2:2181");
            
            //3、狐猴去数据库的连接对象
            conn=ConnectionFactory.createConnection(conf);

            //获取数据库操作对象
            //旧版本写法
//            HBaseAdmin hBaseAdmin = new HBaseAdmin(conn);

            //新版本写法
            admin = conn.getAdmin();//使用连接对象获取数据库操作对象

            System.out.println("数据库连接对象获取成功"+conn);
            System.out.println("数据库操作对象获取成功"+admin);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建一张表
     */
    @Test
    public void createOneTable(){
        try {
            //先将表名封装成TableName对象
            TableName tn = TableName.valueOf("students");
//        旧版本写法(HTableDescriptor):
//        HTableDescriptor hTableDescriptor = new HTableDescriptor(tn);
//        新版本写法(TableDescriptorBuilder)获取表描述器对象：
            TableDescriptorBuilder students = TableDescriptorBuilder.newBuilder(tn);
            //旧版本创建列簇描述器对象
//        HColumnDescriptor hColumnDescriptor = new HColumnDescriptor("info");
            //新版本创建列簇描述器对象
            ColumnFamilyDescriptor info = ColumnFamilyDescriptorBuilder.of("info");
            //将表和列簇进行关联
            //旧版本中表描述器调用addColumnFamily方法：
//        students.addColumnFamily(info);
            //新版本中表描述器调用setColumnFamily方法：
            students.setColumnFamily(info);

            //调用方法，创建表
//        createTable(TableDescriptorBuilder desc);
            admin.createTable(students.build());
            System.out.println(tn+"创建成功");
        } catch (IOException e) {
            System.out.println("创建失败");
            e.printStackTrace();
        }
    }

    /**
     * 删除一张表
     */
    @Test
    public void dropOneTable(){
        try {
            //先将表明封装成一个TableName对象
            TableName tn = TableName.valueOf("students");
            //先判断要删除的表是否存在
            if (admin.tableExists(tn)){
                //先禁用表
                admin.disableTable(tn);
                //使用admin对象调用方法删除表
                //void  deleteTable(TableName tableName)
                admin.deleteTable(tn);
                System.out.println(tn+"表删除成功");
            }else {
                System.out.println("表不存在!!!!!!");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 向表中添加一条数据
     * put 'students','1001','info:name','xiaohu'
     */
    @Test
    public void putOneData(){
        try {
            //先将表名封装成一个TableName对象
            TableName tn = TableName.valueOf("students");
            //还是先判断表是否存在
            if (admin.tableExists(tn)){
                Table students = conn.getTable(tn);
                //创建put对象
//                Put put = new Put("1001".getBytes());
//                //对put对象进行设置，添加列簇、列名和列值
//                put.addColumn("info".getBytes(),"name".getBytes(),"xiaohu".getBytes());

                //hbase自带的一个工具类Bytes，可以将字符串转成字节数组
                //创建put对象
                Put put = new Put(Bytes.toBytes("1001"));//行键的字节数组形式
                //对put对象进行设置，添加列簇、列名和列值
                //旧版本但没有过时：
//                put.addColumn(Bytes.toBytes("info"),Bytes.toBytes("name"),Bytes.toBytes("xiaohu"));
                //新版本：
//                Cell是一个接口，无法被实例化，使用它的实现类KeyValue来创建对象
                put.add(new KeyValue(Bytes.toBytes("1001"),Bytes.toBytes("info"),Bytes.toBytes("age"),Bytes.toBytes("18")));

                //void put(Put put)
                //需要先将我们添加的列数据封装成put对象
                students.put(put);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加多条数据
     */
    @Test
    public void putMoreData(){
        BufferedReader br=null;
        try {
            //先将表名封装成一个TableName的对象
            TableName tn = TableName.valueOf("students");
            //创建字符缓冲输入流对象
            br = new BufferedReader(new FileReader("data/students.csv"));
            String[] colNameArray={"","name","age","gender","clazz"};

            //判断表是否存在
            if(admin.tableExists(tn)){
                //获取表对象
                Table students = conn.getTable(tn);
                //循环读取数据
                String line = null;
                while((line=br.readLine())!=null){
                    String[] info = line.split(",");
                    byte[] rowkey = Bytes.toBytes(info[0]);
                    //创建这一行的put的对象
                    Put put = new Put(rowkey);
                    //第一列作为行键作为唯一标识，从第二列开始，每一行都要被封装成put对象
                    for (int i=1;i<info.length;i++){
                        byte[] colName = Bytes.toBytes(info[i]);
                        put.addColumn(Bytes.toBytes("info"),Bytes.toBytes(colNameArray[i]),Bytes.toBytes(info[i]));
                        //添加该列数据
                        students.put(put);
                    }
                }
                System.out.println(tn+"表添加数据成功");
            }else {
                System.out.println(tn+"表不存在");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @After
    public void closeSource() {
        try {
            if(admin != null){
                admin.close();
            }
            if (conn != null){
                conn.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}