SpringBoot + Hbase

最新推荐文章于 2024-07-05 17:55:00 发布
最新推荐文章于 2024-07-05 17:55:00 发布
阅读量619 收藏 2
点赞数
分类专栏： hbase java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43261465/article/details/119869871
版权

从来没有想过会去学习Java 大数据相关的东西，但因为项目需要，不得不使用 Hbase 存储数据，所以记录一些简单的 CRUD 过程

1、安装

1.1 Docker

docker pull harisekhon/hbase
docker run -d -h docker-hbase \
        -p 2181:2181 \
        -p 9090:9090 \
        -p 9095:9095 \
        -p 16000:16000 \
        -p 16010:16010 \
        -p 16020:16020 \
        -p 16201:16201 \
        -p 16301:16301 \
        --name hbase \
        --restart=always \
        --network my_net --network-alias hbase \
        harisekhon/hbase
## 访问
http://192.168.56.120:16010

1.2 直接安装在linux上

教程很多
或者：https://gitee.com/fyhcug/note （【单机 Zookeeper + Hadoop + Hbase】.md，该教程找不到出处了……）

2、Springboot

  • yaml
hbase:
  zookeeper:
    quorum: 192.168.56.120
    property:
      clientPort: 2181
  • Maven
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>2.4.4</version>
</dependency>
  • HbaseUtils
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;

/**
 * Created on 2021/7/17--20:57.
 * hbase 工具类
 * @author fengyuhao
 * @Description
 */
@Component
public class HbaseUtil {
    private static Admin admin = null;
    private static Connection con = null;

    private HbaseUtil(@Value("${hbase.zookeeper.quorum}") String zookeeperQuorum,
                      @Value("${hbase.zookeeper.property.clientPort}") String clientPort) throws IOException {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", zookeeperQuorum);
        conf.set("hbase.zookeeper.property.clientPort", clientPort);
        con = ConnectionFactory.createConnection(conf);
    }

    /**
     * 创建表
     *
     * @param tableName 表名称
     * @param cf        列族
     */
    public static void createTable(String tableName, String[] cf) {
        TableName tb = TableName.valueOf(tableName);
        try {
            admin = con.getAdmin();
            if (admin.tableExists(tb)) {
                System.out.println("talbe is exists!");
            } else {
                TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(tb);
                List<ColumnFamilyDescriptor> list = new ArrayList<>();
                // 添加列族
                for (String entry : cf) {
                    list.add(ColumnFamilyDescriptorBuilder.newBuilder(entry.getBytes(StandardCharsets.UTF_8)).build());
                }
                tableDescriptorBuilder.setColumnFamilies(list);
                admin.createTable(tableDescriptorBuilder.build());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查看已有表
     */
    public static TableName[] listTables() {
        TableName[] tableNames = new TableName[0];
        try {
            admin = con.getAdmin();
            tableNames = admin.listTableNames();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return tableNames;
    }

    /**
     * 删除表
     */
    public static void deleteTable(String tableName) {
        try {
            TableName tn = TableName.valueOf(tableName);
            admin = con.getAdmin();
            if (admin.tableExists(tn)) {
                admin.disableTable(tn);
                admin.deleteTable(tn);
            }
            admin.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加（更新）一条记录
     *
     * @param tableName 表名
     * @param rowkey    rowkey
     * @param cf        columnfamily
     * @param column    column
     * @param value     value
     */
    public static void put(String tableName, String rowkey, String cf, String column, String value) {
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowkey));
            put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(column), Bytes.toBytes(value));
            table.put(put);
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 批量添加（更新）数据
     *
     * @param tableName 表名
     * @param data      插入的数据,
     *                  Map 结构 -->Map(rowkey,Map(cf:column,value))
     */
    public static void batchPut(String tableName, Map<String, Map<String, Object>> data) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            Table table = con.getTable(TableName.valueOf(tableName));
            List<Put> list = new ArrayList<>();
            for (Map.Entry<String, Map<String, Object>> entry : data.entrySet()) {
                System.out.println(entry.getKey());
                // rowkey
                for (Map.Entry<String, Object> map : entry.getValue().entrySet()) {
                    Put put = new Put(Bytes.toBytes(entry.getKey()));
                    String[] keys = map.getKey().split(":");
                    if (keys.length > 1) {
                        put.addColumn(Bytes.toBytes(keys[0]), Bytes.toBytes(keys[1]), Bytes.toBytes(objectMapper.writeValueAsString(map.getValue())));
                    } else {
                        put.addColumn(Bytes.toBytes(keys[0]), null, Bytes.toBytes(objectMapper.writeValueAsString(map.getValue())));
                    }
                    list.add(put);
                }
            }
            table.put(list);
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 全表扫描
     *
     * @param tableName 表名
     */
    public static List<Map<String, Object>> scanTable(String tableName) {
        TableName tb = TableName.valueOf(tableName);
        ResultScanner scanner = null;
        try {
            Table table = con.getTable(tb);
            Scan scan = new Scan();
            scanner = table.getScanner(scan);
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> list = new ArrayList<>();
        if (scanner != null) {
            for (Result result : scanner) {
                Map<String, Object> map = new HashMap<>(8);
                //展示数据
                for (Cell cell : result.rawCells()) {
                    map.put("rowKey", Bytes.toString(CellUtil.cloneRow(cell)));
                    map.put("family", Bytes.toString(CellUtil.cloneFamily(cell)));
                    map.put("column", Bytes.toString(CellUtil.cloneQualifier(cell)));
                    map.put("value", Bytes.toString(CellUtil.cloneValue(cell)));
                }
                list.add(map);
            }
        }
        return list;
    }

    /**
     * 根据 rowkey 查询一条数据
     *
     * @param tableName 表
     * @param rowKey    rewkey
     */
    public static Result getByRowkey(String tableName, String rowKey) {
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Get get = new Get(rowKey.getBytes(StandardCharsets.UTF_8));
            Result result = table.get(get);
            table.close();
            if (!result.isEmpty()) {
                return result;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 根据 rowkey 查询一条数据
     *
     * @param tableName 表
     * @param rowKey    rewkey
     * @param cf    columnfamily
     */
    public static Result getByRowkey(String tableName, String rowKey,String cf) {
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Get get = new Get(rowKey.getBytes(StandardCharsets.UTF_8));
            get.addFamily(cf.getBytes(StandardCharsets.UTF_8));
            Result result = table.get(get);
            table.close();
            if (!result.isEmpty()) {
                return result;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 根据 rowkey 查询一条数据
     *
     * @param tableName 表
     * @param rowKey    rewkey
     * @param cf    columnfamily
     * @param column    column
     */
    public static Result getByRowkey(String tableName, String rowKey,String cf,String column) {
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Get get = new Get(rowKey.getBytes(StandardCharsets.UTF_8));
            get.addColumn(cf.getBytes(StandardCharsets.UTF_8),column.getBytes(StandardCharsets.UTF_8));
            Result result = table.get(get);
            table.close();
            if (!result.isEmpty()) {
                return result;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * rowkey 模糊查询
     * @param tableName 表
     * @param pattern 正则表达式
     */
    public static Iterator<Result> getByRowkeyPattern(String tableName,String pattern){
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Scan scan = new Scan();
            RowFilter mykey = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(pattern));
            scan.setFilter(mykey);
            Iterator<Result> iterator = table.getScanner(scan).iterator();
            table.close();
            return iterator;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * rowkey 范围查询 ( start < result < end)
     * @param tableName 表
     * @param start 开始 key
     * @param end   结束 key
     */
    public static  Iterator<Result> getByRowkeyRange(String tableName,String start,String end){
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            List<Filter> list = new ArrayList<>();
            Scan scan = new Scan();
            RowFilter mykey1 = new RowFilter(CompareOperator.GREATER, new BinaryComparator(start.getBytes(StandardCharsets.UTF_8)));
            list.add(mykey1);
            RowFilter mykey2 = new RowFilter(CompareOperator.LESS, new BinaryComparator(end.getBytes(StandardCharsets.UTF_8)));
            list.add(mykey2);
            scan.setFilter(new FilterList(list));
            Iterator<Result> iterator = table.getScanner(scan).iterator();
            table.close();
            return iterator;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 时间戳范围查询 ( start <= result < end)
     * @param tableName 表
     * @param start 开始 key
     * @param end   结束 key
     */
    public static Iterator<Result> getByTimestamp(String tableName,Long start,Long end){
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Scan scan = new Scan();
            scan.setTimeRange(start,end);
            Iterator<Result> iterator = table.getScanner(scan).iterator();
            table.close();
            return iterator;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     *  根据 rowkey删除一条记录
     * @param tableName 表
     * @param rowKey   rewkey
     */
    public static void deleteByRowkey(String tableName, String rowKey){
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            Delete delete = new Delete(rowKey.getBytes(StandardCharsets.UTF_8));
            table.delete(delete);
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     *  根据 rowkey 删除多条记录
     * @param tableName 表
     * @param rowKey   rewkey
     */
    public static void batchDeleteByRowkey(String tableName, String[] rowKey){
        try {
            Table table = con.getTable(TableName.valueOf(tableName));
            List<Delete> list = new ArrayList<>();
            for(String s : rowKey){
                Delete delete = new Delete(s.getBytes(StandardCharsets.UTF_8));
                list.add(delete);
            }
            table.delete(list);
            table.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

增删改查也就常用的几个类、接口等，根据类、接口大致看一下其子类或接口实现类基本就全部搞定了，没什么可说的
eg: 比如 Filter，根据其子类的名字就知道是要根据 rowkey 怎么过滤了在这里插入图片描述

  • Test
import com.cug.demo1.utils.HbaseUtil;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.*;

@SpringBootTest
class Demo1ApplicationTests {

    /**
     * 创建表
     */
    @Test
    public void createTable(){
        String[] cf = new String[2];
        cf[0] = "info";
        cf[1] = "address";
        HbaseUtil.createTable("test",cf);
    }

    /**
     * 查看表信息
     */
    @Test
    public void tableList(){
        TableName[] tableNames = HbaseUtil.listTables();
        for(TableName tableName: tableNames){
            System.out.println(tableName.getNameAsString());
        }
    }

    /**
     * 删除表
     */
    @Test
    public void deleteTable(){
       HbaseUtil.deleteTable("test");
    }

    /**
     * 添加一条数据
     */
    @Test
    public void put(){
        HbaseUtil.put("tbl_user","keyss","info","name","zhangsan");
    }

    /**
     * 批量添加数据
     */
    @Test
    public void batchPut(){
        Map<String,Map<String,Object>> data = new HashMap<>(8);
        Map<String,Object> list = new HashMap<>(4);
        list.put("address","zhangsan");
        Map<String,Object> list1 = new HashMap<>(4);
        list1.put("address","lisi");
        data.put("mykeys3",list);
        data.put("mykeys4",list1);
        HbaseUtil.batchPut("tbl_user",data);
    }

    /**
     * 查询数据
     */
    @Test
    public void getByRowkey(){
        // 根据 rowkey 查询一条数据
        System.out.println(HbaseUtil.getByRowkey("tbl_user", "mykeys1"));
        // rowkey 模糊查询
        Iterator<Result> tbl_user = HbaseUtil.getByRowkeyPattern("tbl_user", "mykey*");
        if(tbl_user != null){
            while (tbl_user.hasNext()){
                Result next = tbl_user.next();
                System.out.println(Bytes.toString(CellUtil.cloneRow(next.rawCells()[0])));
                System.out.println(Bytes.toString(CellUtil.cloneFamily(next.rawCells()[0])));
                System.out.println(Bytes.toString(CellUtil.cloneQualifier(next.rawCells()[0])));
                System.out.println(Bytes.toString(CellUtil.cloneValue(next.rawCells()[0])));
            }
        }
        // rowkey 范围
        System.out.println(HbaseUtil.getByRowkeyRange("tbl_user", "mykeys", "mykeys2"));
        // 时间戳范围查询
        System.out.println(HbaseUtil.getByTimestamp("tbl_user", 1626570049074L, 1626570273856L));
    }
}

3、Snapshot

## 创建快照，数据保存在 --> hdfs:xxx/hbase/.hbase-snapshot/   docker容器中，默认 /hbase-data/.hbase-snapshot/ 
hbase> snapshot 'src_table', 'snapshot_src_table'
## 查看快照
hbase> list_snapshots 
## 删除快照
hbase> delete_snapshot 'snapshot_src_table'
## 数据迁移
hbase org.apache.hadoop.hbase.snapshot.ExportSnapshot -snapshot snapshot_src_table -copy-to hdfs://192.168.1.132:8020/hbase -mappers 16 -bandwidth 20
## 数据恢复
hbase> clone_snapshot 'snapshot_src_table' , 'new_table_name'
阳台上的阳光
关注
专栏目录
springboot-集成hbase
子龙修仙的博客
04-13 2991
修改pom.xml 添加依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-hadoop</artifactId> <version>2.5.0.RELEASE</version&...
Spring Boot 2.x ：通过 spring-boot-starter-hbase 集成 HBase
weixin_43770982的博客
04-18 1075
本文内容 HBase 简介和应用场景 spring-boot-starter-hbase 开源简介 集成 HBase 实战 小结 一、HBase 简介和应用场景 1.1 HBase 是什么？ HBase 是什么？HBase 是在 Hadoop 分布式文件系统（简称：HDFS）之上的分布式面向列的数据库。而且是 2007 最初原型，历史悠久。 那追根究底，Hadoop 是什么？Hado...
springboot集成hbase
09-17
本示例示springboot集成hbase的一个工具，用户下载后，只需要更改HBaseUtil类中的配置为自己的hbase服务器上的相关配置及更改resources下hbase.keytab和krb5.conf文件为自己服务器上的文件即可使用
Springboot整合HBase——大数据技术之HBase2.x
qq_43842093的博客
02-15 2677
Apache HBase 是以hdfs为数据存储的，一种分布式、可扩展的noSql数据库。是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。HBase使用与BigTable（BigTable是一个稀疏的、分布式的、持久化的多维排序map）非常相似的数据模型。用户将数据行存储在带标签的表中。数据行具有可排序的键和任意数量的列。该表存储稀疏，因此如果用户喜欢，同一表中的行可以具有疯狂变化的列。
SpringBoot集成Hbase
最新发布
saonian0929的博客
07-05 654
1、Springboot整合HBase数据库* 2、java.io.FileNotFoundException HADOOP_HOME and hadoop.home.dir are unset解决 3、2、java.net.ConnectException: Connection refused: no further information 解决
springboot-hbase
07-04
springboot连接hbase工程示例。服务端采用微服务框架springboot，是要phoenix连接hbase
Spring Boot 整合 HBase
Java搜索工程技术栈
05-29 6148
一、HBase 介绍 HBase是一个分布式的、面向列的开源数据库，Hadoop 数据库。搭建基于 Hadoop 和 ZK 。 历史是基于 Google 的 Bigtable 、Google 文件系统等论文。HBase 在Hadoop 之上提供了类似于 Bigtable 的能力。 HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。 HBase 特性： 大：一个表可以有数十亿
springboot集成Hbase
经验分享
09-26 3111
前提：hbase版本是1.2.6，详情看 1、添加maven <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>2.2.3</version> <exclusions>
基于springboot+netty+mybatis+hbase+kafka实现的socket server+源代码+文档说明
11-28
- [ ] socket server接收到返回的数据后，分别写入到hbase数据库和kafka队列中 - [ ] 最后调用websocket server，往所有跟它建立的客户端发送接收到的数据 ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能...
基于Flink+SpringBoot+Hbase的商品实时推荐系统源码+全部资料齐全
05-13
基于Flink+SpringBoot+Hbase的商品实时推荐系统源码+全部资料齐全 flink统计商品热度，放入redis缓存，分析日志信息，将画像标签和实时记录放入Hbase在用户发起推荐请求后，根据用户画像重排序热度榜，并结合协同...
springboot集成phoenix+hbase
10-26
而Phoenix是一个开源的SQL层，它构建在HBase之上，提供了高性能的数据库查询能力。本示例将详细解释如何将Spring Boot与Phoenix和HBase集成，以创建一个完整的数据访问解决方案。 首先，我们需要在Spring Boot项目...
springboot 集成 phoenix+hbase整合，完整demo
03-21
springboot 集成 phoenix+hbase整合，完整demo。 springboot集成phoenix+hbase 完整demo！！！！！！！ springboot phoenix hbase
基于springboot集成hbase过程解析
08-25
主要介绍了基于springboot集成hbase过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springBoot_hbase_phoenix_mybatis:spring boot 使用mybatis连接phoenix使用hbase
05-09
springBoot_hbase_phoenix_mybatis spring boot 使用mybatis连接phoenix使用hbase ##当前版本： phoenix：4.13.1-HBase-1.2 （与hbase服务器phoenix版本一致） spring boot:2.0.2.RELEASE ##注意：无法与swagger2集成：swagger2的guava包不能低于18.0 ##使用注意事项： 1.（必要设置）配置本地HADOOP_HOME环境变量，在windows10时需要重启服务器 2.（必要设置）配置hosthome C:\Windows\System32\drivers\etc下的hosts里面添加与zookeeper一致的hosthome设置,添加： 10.122.22.8 blsdh014 10.122.22.9 blsdh017
HBase+SpringBoot实战分布式文件存储
12-04
HBase+SpringBoot实战分布式文件存储 资源永久有效哦
springboot整合hbase资源.zip
05-26
解压后包含三个资源，分别是hadoop.dll、hadoop-2.7.3.zip、winutils.exe。对应springboot整合hbase文章中解决windows系统下项目启动不了的问题。
Java SpringBoot 连接 Hbase Demo
07-26
Java SpringBoot 连接 Hbase Demo 创建表 插入数据 列族 列 查询：全表、数据过滤 删除数据 删除表 Hbase 集群搭建：https://blog.csdn.net/weixin_42176639/article/details/131796472
SpringBoot使用Hbase
lmchhh的博客
04-15 2565
以前都是在非Spring环境下使用Hbase的，一开始会出现：当服务使用时间过久，某些会使用hbase的接口调用次数过多的时候，会报【已超过最大的连接数】，只能每一次调用接口后最后一行加上释放连接。（以前的做法每次调用都要在代码里手动获取一个连接）这次将释放连接都集成在操作服务类的实现方法中，避免了开发接口可能遗漏的错误，可能不会再出现这个问题。init()方法实现在初始化连接池的时候创建默认数值的连接。这里没有使用懒加载模式，减少启动后第一次访问时访问时间过长。ok，现在就可以操作使用了。
springboot + hbase 框架
07-28
同时，Spring Boot还提供了多种方式来操作HBase，例如原生Java API、Apache HBase REST API、HBase Shell等。 使用Spring Boot+HBase可以实现很多应用场景，例如电商网站的订单管理、社交媒体的用户关系图谱、日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值