HBase 简单数据操作

最新推荐文章于 2024-04-26 23:34:35 发布
最新推荐文章于 2024-04-26 23:34:35 发布
阅读量288 收藏
点赞数
分类专栏： Hbase 文章标签： hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changzhou0519/article/details/71540036
版权

直接上代码吧，API比较简单

```
package com.sdnware.start04.hbase;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
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.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PrefixFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * HBase CURD例子
 * @author chenb.bob
 * 2017年5月10日
 *
 */
public class HBaseDMLExample {

    private static Logger LOG = LoggerFactory.getLogger(HBaseDMLExample.class);

    private static Configuration conf = null;

    static {
        System.setProperty("hadoop.home.dir", "E:/soft/hadoop-2.6.0");
        conf = HBaseConfiguration.create();
    }

    /**
     * put方法测试
     * desc:
     * author:chen.bob
     * time:2017年5月10日 上午11:23:08
     * @return
     */
    public static boolean putTo(){
        Connection connection = null;
        Table table = null;
        try {
            //Old
            //HTable table = new HTable(conf, "sdnware:mytest");
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10002");
            Put put = new Put(row);
            byte[] family = Bytes.toBytes("c1");
            byte[] qualifier = Bytes.toBytes("name"); 
            byte[] value = Bytes.toBytes("cb");
            put.addColumn(family, qualifier, value);
            put.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("age"), Bytes.toBytes("30"));
            put.addColumn(Bytes.toBytes("c2"), Bytes.toBytes("name"), Bytes.toBytes("nxj"));
            put.addColumn(Bytes.toBytes("c2"), Bytes.toBytes("age"), Bytes.toBytes("25"));
            put.addColumn(Bytes.toBytes("c2"), Bytes.toBytes("city"), Bytes.toBytes("beijing"));
            table.put(put);

            LOG.error("数据存储成功！");
        } catch (IOException e) {
            LOG.error("数据存储失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;
    }

    /**
     * 
     * desc:更新指定的列
     * author:chen.bob
     * time:2017年5月10日 下午3:03:32
     * @return
     */
    public static boolean putTo2(){
        Connection connection = null;
        Table table = null;
        try {
            //Old
            //HTable table = new HTable(conf, "sdnware:mytest");
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10002");
            Put put = new Put(row);
            put.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("city"), Bytes.toBytes("changzhou"));
            put.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("post"), Bytes.toBytes("0519"));
            //多个。。。。。
            table.put(put);

            LOG.error("数据存储成功！");
        } catch (IOException e) {
            LOG.error("数据存储失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;
    }

    /**
     * 
     * desc:get
     * author:chen.bob
     * time:2017年5月10日 上午11:23:25
     * @return
     */
    public static boolean get(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10001");
            Get get = new Get(row);
            Result result = table.get(get);
            byte[] colfam = Bytes.toBytes("c1");
            byte[] col = Bytes.toBytes("name");

            /*  方式1 ：
                byte[] value = result.getValue(colfam, col);
                LOG.info("取值================:"+Bytes.toString(value));
            */

            // 方式 2 ：
            List<Cell> columnCells = result.getColumnCells(colfam, col);
            for(Cell cell:columnCells){
                String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                LOG.info("取值================:"+value);
            }


            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }

    /**
     * 
     * desc:get
     * author:chen.bob
     * time:2017年5月10日 上午11:23:35
     * @return
     */
    public static boolean get2(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10001");
            Get get = new Get(row);
            Result result = table.get(get);

            List<Cell> listCells = result.listCells();
            LOG.info("开始遍历");
            for(Cell cell:listCells){
                String family = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
                String qualifier = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                LOG.info("family:"+family+",qualifier:"+qualifier+",value:"+value);
            }

            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }

    /**
     * 
     * desc:查询单个列
     * author:chen.bob
     * time:2017年5月10日 下午3:01:20
     * @return
     */
    public static boolean get3(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10001");
            Get get = new Get(row);

            get.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("name")); // 获取指定列族和列修饰符对应的列  

            Result result = table.get(get);

            List<Cell> listCells = result.listCells();
            LOG.info("开始遍历");
            for(Cell cell:listCells){
                String family = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
                String qualifier = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                LOG.info("family:"+family+",qualifier:"+qualifier+",value:"+value);
            }

            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }


    /**
     * 
     * desc:指定rowKey
     * author:chen.bob
     * time:2017年5月10日 下午1:38:12
     * @return
     */
    public static boolean scan(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            Scan scan = new Scan();
            scan.setStartRow(Bytes.toBytes("10002"));//指定rowKey

            ResultScanner rs = table.getScanner(scan);  
             LOG.info("开始遍历");
            for (Result r : rs) {  
                List<Cell> listCells = r.listCells();
                for(Cell cell:listCells){
                    String row = Bytes.toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());
                    String family = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
                    String qualifier = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                    String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                    LOG.info("row:"+row+",family:"+family+",qualifier:"+qualifier+",value:"+value);
                }
            }  
            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;   
    }

    /**
     * 
     * desc:指定rowKey前缀
     * author:chen.bob
     * time:2017年5月10日 下午1:38:12
     * @return
     */
    public static boolean scanByRowKeyPrefix(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            Scan scan = new Scan();
            scan.setFilter(new PrefixFilter("1000".getBytes())); //指定rowKey前缀 
            ResultScanner rs = table.getScanner(scan);  
             LOG.info("开始遍历");
            for (Result r : rs) {  
                List<Cell> listCells = r.listCells();
                for(Cell cell:listCells){
                    String row = Bytes.toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());
                    String family = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
                    String qualifier = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                    String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                    LOG.info("row:"+row+",family:"+family+",qualifier:"+qualifier+",value:"+value);
                }
            }  
            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;   
    }

    /**
     * 
     * desc:使用过滤
     * author:chen.bob
     * time:2017年5月10日 下午1:53:29
     * @return
     */
    public static boolean scanByFilter(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));


            //过滤器
            //1、FilterList代表一个过滤器列表
            //FilterList.Operator.MUST_PASS_ALL -->and
            //FilterList.Operator.MUST_PASS_ONE -->or
            //eg、FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE);
            //2、SingleColumnValueFilter
            //3、ColumnPrefixFilter用于指定列名前缀值相等
            //4、MultipleColumnPrefixFilter和ColumnPrefixFilter行为差不多，但可以指定多个前缀。
            //5、QualifierFilter是基于列名的过滤器。
            //6、RowFilter
            //7、RegexStringComparator是支持正则表达式的比较器。
            //8、SubstringComparator用于检测一个子串是否存在于值中，大小写不敏感。

            // 使用SingleColumnValueFilter会影响查询性能，在真正处理海量数据时会消耗很大的资源，且需要较长的时间
            // 过滤  c2:city = beijing
            Filter filter = new SingleColumnValueFilter(  
                    Bytes.toBytes("c2"), Bytes.toBytes("city"), CompareOp.EQUAL,  
                    Bytes.toBytes("beijing"));

            FilterList filterList=new FilterList();
            filterList.addFilter(filter);
            Scan scan = new Scan();
            //scan.setFilter(filter); 单个filter
            scan.setFilter(filterList); //多个filter组合
           // scan.addColumn(Bytes.toBytes("c2"), Bytes.toBytes("city"));
            scan.addFamily(Bytes.toBytes("c2"));

            /**
             * 注意此处，必须有定义，将查询的列簇显示加入，笔者测试发现，没有的话无法起到过滤效果
             * scan.addColumn 只会查询定位到当前 qualifer
             * scan.addFamily 会查询row
             * 
             */
            ResultScanner rs = table.getScanner(scan);  

             LOG.info("ResultScanner:开始遍历");
            for (Result r : rs) {  
                List<Cell> listCells = r.listCells();
                for(Cell cell:listCells){
                    String row = Bytes.toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());
                    String family = Bytes.toString(cell.getFamilyArray(), cell.getFamilyOffset(), cell.getFamilyLength());
                    String qualifier = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                    String value = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                    LOG.info("row:"+row+",family:"+family+",qualifier:"+qualifier+",value:"+value);
                }
            }  
            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;   
    }

    /**
     * 
     * desc:删除列
     * author:chen.bob
     * time:2017年5月10日 下午3:23:33
     * @return
     */
    public static boolean deleteQualifier(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10002");
            Delete deleteColumn = new Delete(row);

            deleteColumn.addColumn(Bytes.toBytes("c1"), Bytes.toBytes("post"));
            table.delete(deleteColumn); 

            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }

    /**
     * 
     * desc:删除列簇所有列
     * author:chen.bob
     * time:2017年5月10日 下午3:36:59
     * @return
     */
    public static boolean deleteFamilyQualifier(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10002");
            Delete deleteColumn = new Delete(row);
            deleteColumn.addFamily(Bytes.toBytes("c1"));
            table.delete(deleteColumn); 

            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }

    /**
     * 
     * desc:删除行
     * author:chen.bob
     * time:2017年5月10日 下午3:36:59
     * @return
     */
    public static boolean deleteRow(){
        Connection connection = null;
        Table table = null;
        try { 
            connection = ConnectionFactory.createConnection(conf);
            table = connection.getTable(TableName.valueOf("sdnware:mytest"));
            byte[] row = Bytes.toBytes("10002");
            Delete deleteColumn = new Delete(row);
            table.delete(deleteColumn); 

            return Boolean.TRUE;        
        }catch (IOException e) {
            LOG.error("数据取值失败！",e);
        }finally{
            if(null != table){
                try {
                    table.close();
                } catch (IOException e) {
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (IOException e) {
                }
            }
        }
        return Boolean.FALSE;       
    }

    public static void main(String[] args) {
        //putTo2();
        deleteRow();
    }

}

在查询中还有一种方式是索引，可以参考http://www.cnblogs.com/kxdblog/p/4328699.html

飞起的蜗牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HBase原理－数据读取流程解析
01-27
其二是因为HBase中更新操作以及删除操作实现都很简单，更新操作并没有更新原有数据，而是使用时间戳属性实现了多版本。删除操作也并没有真正删除原有数据，只是插入了一条打上”deleted”标签的数据，而真正的数据...
【甘道夫】HBase基本数据操作详解【完整版，绝对精品】
Do you believe something?
06-15 286
引言 之前详细写了一篇HBase过滤器的文章，今天把基础的表和数据相关操作补上。 本文档参考最新（截止2014年7月16日）的官方Ref Guide、Developer API编写。 所有代码均基于“hbase0.96.2-hadoop2”版本编写，均实测通过。 欢迎转载，请注明来源： http://blog.csdn.net/u010967382/article/details/37878701 概述 对于建表，和RDBMS类似，HBase也有namespace的概念，可以指定表空间创建表，也可以直接创.
Hbase具体操作(图文并茂且超超全~~~)
sun7_9的博客
11-18 9395
目的： （1）理解 HBase 在 Hadoop 体系结构中的角色。 （2）熟练使用 HBase 操作常用的 Shell 命令。 要求： （1）熟悉hbase相关操作，掌握建表、修改表、查表、删除表等操作。 （2）可以自己建一个表，熟悉上述操作，并插入不少于10条的数据，以便于后续过滤器的使用。 进行相关操作的步骤：启动hadoop–>启动hbase–>打开hbase shell 一、数据定义 1.创建表 （1）HBase中创建表需要指明表名和列族名，如创建表中的学生信息表Student的.
HBase MapReduce数据操作
晓晓的天空
03-03 1316
HBase MapReduce数据操作
Hbase基本操作
qq_61604164的博客
07-25 3158
HBASE基本操作
hive和hbase的一些数据导入导出操作
quantam的博客
11-21 2020
hive 、hbase的一些基本操作
Hbase的安装过程及基本操作
10-11
来自一位老学姐的Hbase安装详细教程（清华大学镜像下）及基本操作，希望能带给你们些许帮助。主要包含Hbase的下载过程及其遇到的小问题，后续会继续完善该文档！
thrift操作Hbase数据库
01-17
代码文件，C#语言编写，通过Thrift2操作Hbase库，对数据进行简单的增、删、改、查处理·。
HBASE数据库.docx
06-16
具有一定结构,但语义不够确定,典型的如 HTML 网页,有些字段是确定的(title),有些不确定(table) 非结构化:杂乱无章的数据,很难按照一个概念去进行抽取,无规律性 Hbase 查询数据功能很简单，不支持 join 等复杂操作，...
hbase MultiRowRangeFilter的原理、作用和实例
linweidong的专栏
04-26 372
是HBase中的一个过滤器，用于在扫描操作中过滤多个行键范围。
如何在docker上面使用hbase shell
linweidong的专栏
04-26 609
在新公司上班，hbase是cdh6.3.2安装在docker上面，如何直接在shell上面使用hbase shell是访问不到的。
智慧学院智能化项目规划设计方案PPT(45页).pptx
05-03
智慧学院智能化项目规划设计方案PPT(45页).pptx
AO工艺设计计算(全).xls
05-03
污水处理计算书
ASP+ACCESS动态网站设计与制作(源代码+设计说明书).zip
05-03
ASP+ACCESS动态网站设计与制作(源代码+设计说明书).zip
基于matlab实现的二维渗流代码，用于模拟在二维条件下，格点所受碰撞的次数.rar
05-03
基于matlab实现的二维渗流代码，用于模拟在二维条件下，格点所受碰撞的次数.rar
基于matlab实现可实现脉冲编码调制，模拟信号的数字传输：抽样、量化、编码.rar
05-03
基于matlab实现可实现脉冲编码调制，模拟信号的数字传输：抽样、量化、编码.rar
ASP+access网上购物系统(设计说明书+源代码).zip
05-03
ASP+access网上购物系统(设计说明书+源代码).zip
Screenshot_20240503_054519.jpg
05-03
Screenshot_20240503_054519.jpg
node-v12.17.0-linux-armv7l.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
java操作hbase获取数据
05-18
在 Java 中操作 HBase 获取数据可以使用 HBase 提供的 Java API。以下是一个简单的示例代码： ```java import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值