AiTi修炼|重剑无锋,拈花微笑 | IT修炼,技术fans.重剑无锋,拈花微笑才是最高境界,聊以此站记录一些个人学习、思考以及感悟Java,Scala,Spark,Hadoop,Storm,Nodejs,RSpark,Storm,Hbase,Hive,Flume等IT技术的历程 | Page 5
  • Home
Header
Header
$pageNumDef = 0;

Hbase API增删改查数据到HbaseUtil封装工具类

 HBase提供了一套Java API来支持Java程序对HBase数据库的请求操作,进行一系列的管理涉及到对表的管理、数据的操作等。当然在使用API的时候需要注意对应的Hbase版本,不同版本之间可能某些API有所差别。

一、Hbase的常见的API操作以及概念

 在Hbase中常用的API操作有:

  • 1、表的操作——HBaseAdmin、HTable
     在Hbase提供的API中,对表的创建、删除、显示以及修改等,可以用HBaseAdmin,一旦创建了表,那么可以通过HTable的实例来访问表,每次可以往表里增加数据。

    • 2、 插入数据——Put
       当往Hbase数据表插入数据的时候,需要通过API创建一个Put对象,在这个Put对象里可以指定要给哪个列增加数据(Hbase是列式数据库),以及当前的时间戳等值,然后通过调用HTable.put(Put)来提交操作,特别在这里提请注意的是:在创建Put对象的时候,你必须指定一个行(RowKey)值,在构造Put对象的时候作为参数传入(具体原因可以参考Hbase的数据模型)。
  • 3、 获取数据——Get
     在Hbase中要读取表的数据时候可以使用Get对象,Get对象同Put对象一样有好几个构造函数,通常在构造的时候传入行值,表示取第几行的数据,通过HTable.get(Get)来调用。

  • 4、浏览每一行
     通过Scan可以对表中的行进行浏览,得到每一行的信息,比如列名,时间戳等,Scan相当于一个游标,通过next()来浏览下一个,通过调用HTable.getScanner(Scan)来返回一个ResultScanner对象HTable.get(Get)和HTable.getScanner(Scan)都是返回一个Result。Result是一个KeyValue的链表。

  • 5、 删除——Delete
     使用Delete来删除记录,通过调用HTable.delete(Delete)来执行删除操作。需要注意在Hbase中删除并不是马上将数据从表中删除。且在调用delete这个API的时候要保证数据库表已经disable了,否则无法删除。

  • 6、 锁——行锁
     需要注意的是Hbase在进行新增、获取、删除的操作过程中会对所操作的行加一个锁,而浏览却不会。

二、Hbase Java API 的开发流程

 对使用Java开发语言来调用HBase API的开发流程,可以简单归纳为以下几个步骤:

1. 获得Configuration实例:其中保存了环境和配置信息

2. 在Configuration中设置zk和master的相关信息,如果hbase的配置文件在环境变量中则不需要配置

3. 获得Connection实例连接到zk

4. 通过Connection实例获得Admin和Table实例调用其方法进行操作

 其中Admin和Table为HBase API中提供的一个统一操作接口,在1.0中对应的是HAdmin和HTable,Admin对应的是DDL操作,Table对应的是相关表的DML操作,上述步骤的主要代码如下:
java
//1.获得Configuration实例并进行相关设置
Configuration configuration = HBaseConfiguration.create();
configuration.set("hbase.zookeeper.quorum","rscala:2181");
configuration.set("hbase.master","rscala:16010");
//2.获得Connection实例
Connection connection = ConnectionFactory.createConnection(configuration);
//3.1获得Admin接口
Admin admin = connection.getAdmin();
//3.2获得Table接口,需要传入表名
Table table = connection.getTable(tableName)

### 三、Hbase API代码示例 ###

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

public class RscalaHBaseUtil {
    private static Configuration conf;
    private static Connection con;
    // 初始化连接
    static {
        conf = HBaseConfiguration.create(); // 获得配制文件对象
        conf.set("hbase.zookeeper.quorum", "rscala");
        try {
            con = ConnectionFactory.createConnection(conf);// 获得连接对象
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 获得连接
    public static Connection getCon() {
        if (con == null || con.isClosed()) {
            try {
                con = ConnectionFactory.createConnection(conf);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return con;
    }

    // 关闭连接
    public static void close() {
        if (con != null) {
            try {
                con.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 创建表
    public static void createTable(String tableName, String... FamilyColumn) {
        TableName tn = TableName.valueOf(tableName);
        try {
            Admin admin = getCon().getAdmin();
            HTableDescriptor htd = new HTableDescriptor(tn);
            for (String fc : FamilyColumn) {
                HColumnDescriptor hcd = new HColumnDescriptor(fc);
                htd.addFamily(hcd);
            }
            admin.createTable(htd);
            admin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 删除表
    public static void dropTable(String tableName) {
        TableName tn = TableName.valueOf(tableName);
        try {
            Admin admin = con.getAdmin();
            //先调用disable才可以删除
            admin.disableTable(tn);
            admin.deleteTable(tn);
            admin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 插入或者更新数据
    public static boolean insert(String tableName, String rowKey,
            String family, String qualifier, String value) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            //Hbase存储的是字节数组
            Put put = new Put(Bytes.toBytes(rowKey));
            put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier),
                    Bytes.toBytes(value));
            t.put(put);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            HBaseUtil.close();
        }
        return false;
    }

    // 删除
    public static boolean del(String tableName, String rowKey, String family, String qualifier) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            Delete del = new Delete(Bytes.toBytes(rowKey));
            if (qualifier != null) {
                del.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            } else if (family != null) {
                del.addFamily(Bytes.toBytes(family));
            }
            t.delete(del);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            HBaseUtil.close();
        }
        return false;
    }
    //删除一行
    public static boolean del(String tableName, String rowKey) {
        return del(tableName, rowKey, null, null);
    }
    //删除一行下的一个列族
    public static boolean del(String tableName, String rowKey, String family) {
        return del(tableName, rowKey, family, null);
    }

    // 数据读取
    //取到一个值
    public static String byGet(String tableName, String rowKey, String family,
            String qualifier) {
        try {
            Table t = getCon().getTable(TableName.valueOf(tableName));
            Get get = new Get(Bytes.toBytes(rowKey));
            get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            Result r = t.get(get);
            return Bytes.toString(CellUtil.cloneValue(r.listCells().get(0)));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    //取到一个族列的值
        public static Map<String, String> byGet(String tableName, String rowKey, String family) {
            Map<String, String> result = null ;
            try {
                Table t = getCon().getTable(TableName.valueOf(tableName));
                Get get = new Get(Bytes.toBytes(rowKey));
                get.addFamily(Bytes.toBytes(family));
                Result r = t.get(get);
                List<Cell> cs = r.listCells();
                result = cs.size() > 0 ? new HashMap<String, String>() : result;
                for (Cell cell : cs) {
                    result.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }
    //取到多个族列的值
        public static Map<String, Map<String, String>> byGet(String tableName, String rowKey) {
            Map<String, Map<String, String>> results = null ;
            try {
                Table t = getCon().getTable(TableName.valueOf(tableName));
                Get get = new Get(Bytes.toBytes(rowKey));
                Result r = t.get(get);
                List<Cell> cs = r.listCells();
                results = cs.size() > 0 ? new HashMap<String, Map<String, String>> () : results;
                for (Cell cell : cs) {
                    String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
                    if (results.get(familyName) == null)
                    {
                        results.put(familyName, new HashMap<String,  String> ());
                    }
                    results.get(familyName).put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return results;
        }
}

rscala.com版权所有,本文Hbase API增删改查数据到HbaseUtil封装工具类
转载请注明出处:http://rscala.com/index.php/402.html