Springboot 项目中的HBASE 文件配置

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

1.properties 文件配置

#Hbase
spring.data.hbase.quorum=tdh-node1,tdh-node2,tdh-node3
spring.data.hbase.client-port=2181
spring.data.hbase.node-parent=/hyperbase1
spring.data.hbase.master-principal=hbase/_HOST@TDH
spring.data.hbase.region-server-principal=hbase/_HOST@TDH
spring.data.hbase.hbase-authentication=kerberos
spring.data.hbase.hadoop-authentication=kerberos

#Hbase 的img表信息
hbase.table.name=ocr_info
hbase.family.name=f1
hbase.column.name=s_img

#tdh security
tdh.security.krb5.path=/teis/teis-web/security/krb5.conf
tdh.security.admin.path=/teis/teis-web/security/keytab

2.加载配置文件的配置到配置类中

package com.cfcc.bigdata.base.config.hbase;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.data.hbase")
public class HbaseProperties {

    private String quorum;

    private String rootDir;

    private String nodeParent;

    private String clientPort;

    private String masterPrincipal;

    private String regionServerPrincipal;

    private String hbaseAuthentication;

    private String hadoopAuthentication;


    public String getQuorum() {
        return quorum;
    }

    public void setQuorum(String quorum) {
        this.quorum = quorum;
    }


    public String getNodeParent() {
        return nodeParent;
    }

    public void setNodeParent(String nodeParent) {
        this.nodeParent = nodeParent;
    }


    public String getRootDir() {
        return rootDir;
    }

    public void setRootDir(String rootDir) {
        this.rootDir = rootDir;
    }

    public String getClientPort() {
        return clientPort;
    }

    public void setClientPort(String clientPort) {
        this.clientPort = clientPort;
    }

    public String getMasterPrincipal() {
        return masterPrincipal;
    }

    public void setMasterPrincipal(String masterPrincipal) {
        this.masterPrincipal = masterPrincipal;
    }

    public String getRegionServerPrincipal() {
        return regionServerPrincipal;
    }

    public void setRegionServerPrincipal(String regionServerPrincipal) {
        this.regionServerPrincipal = regionServerPrincipal;
    }

    public String getHbaseAuthentication() {
        return hbaseAuthentication;
    }

    public void setHbaseAuthentication(String hbaseAuthentication) {
        this.hbaseAuthentication = hbaseAuthentication;
    }

    public String getHadoopAuthentication() {
        return hadoopAuthentication;
    }

    public void setHadoopAuthentication(String hadoopAuthentication) {
        this.hadoopAuthentication = hadoopAuthentication;
    }
}

3.配置HBASE

package com.cfcc.bigdata.base.config.hbase;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.security.UserGroupInformation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;

import java.io.IOException;
/**
* gzy
*/
@org.springframework.context.annotation.Configuration
@EnableConfigurationProperties(HbaseProperties.class)
@ConditionalOnClass(HbaseUtil.class)
public class HbaseAutoConfiguration {

    //hbase 使用zookeeper的地址
    private static final String HBASE_QUORUM = "hbase.zookeeper.quorum";
    private static final String HBASE_ZNODE_PARENT = "zookeeper.znode.parent";
    //客户端连接端口
    private static final String HBASE_ZOOKEPER_CLIENTPORT= "hbase.zookeeper.property.clientPort";
    //master的kerberos认证的主体名称
    private static final String HBASE_MASTER_PRINCIPAL="hbase.master.kerberos.principal";
    //regionserver的kerberos认证的主体名称
    private static final String HBASE_REGIONSERVER_PRINCIPAL="hbase.regionserver.kerberos.principal";
    //hbase 集群安全认证机制，目前的版本只支持kerberos安全认证
    private static final String HBASE_AUTHENTICATION="hbase.security.authentication";
    //hadoop 集群安全认证机制，目前的版本只支持kerberos安全认证
    private static final String HADOOP_AUTHENTICATION="hadoop.security.authentication";

    @Autowired
    private HbaseProperties hbaseProperties;
    @Autowired
    private Environment env;

    @Bean(name ="configuration")
    public Configuration hbaseConfiguration() throws IOException {

        String  krb5Path = env.getProperty("tdh.security.krb5.path");
        String adminPath = env.getProperty("tdh.security.admin.path");

        Configuration configuration = HBaseConfiguration.create();
        configuration.set(HBASE_QUORUM, hbaseProperties.getQuorum());
        configuration.set(HBASE_ZOOKEPER_CLIENTPORT, hbaseProperties.getClientPort());
        configuration.set(HBASE_ZNODE_PARENT, hbaseProperties.getNodeParent());
        configuration.set(HBASE_MASTER_PRINCIPAL, hbaseProperties.getMasterPrincipal());
        configuration.set(HBASE_REGIONSERVER_PRINCIPAL,     
                          hbaseProperties.getRegionServerPrincipal());
        configuration.set(HBASE_AUTHENTICATION, 
                          hbaseProperties.getHbaseAuthentication());
        configuration.set(HADOOP_AUTHENTICATION, 
                          hbaseProperties.getHadoopAuthentication());

        System.setProperty("java.security.krb5.conf",krb5Path );
        UserGroupInformation.setConfiguration(configuration);
        UserGroupInformation.loginUserFromKeytab("admin@TDHTEST", adminPath);  //配置kerberos　keytab 路径
        return configuration;
    }
}

4.封装HBASE操作工具类

package com.cfcc.bigdata.base.config.hbase;

import com.cfcc.bigdata.common.base.exception.HbaseSystemException;
import com.cfcc.bigdata.common.spring.SpringContextHolder;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;
import org.apache.hadoop.conf.Configuration;
import org.springframework.util.Assert;
import org.springframework.util.StopWatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.NavigableMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* @author gzy
* @version : 1.0
* @date : 2019/5/27 0027
*/

@DependsOn("springContextHolder")
@Component
public class HbaseUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(HbaseUtil.class);

    private static Configuration configuration =  SpringContextHolder.getBean("configuration");
    private static ExecutorService pool = Executors.newScheduledThreadPool(20);
    private static Connection connection = null;
    private static HbaseUtil instance = null;
    private static  Admin admin = null;


    private HbaseUtil() {
        if (connection == null) {
            try {
                connection = ConnectionFactory.createConnection(configuration, pool);
                admin = connection.getAdmin();

            } catch (IOException e) {
                LOGGER.error("HbaseTemplate init error:" + e.getMessage(), e);
            }
        }
    }

    public static synchronized HbaseUtil getInstance() {
        if (instance == null) {
            instance = new HbaseUtil();
        }

        return instance;
    }

    /**
     * 判断表是否存在
     * @param tableName
     * @return true 存在　false 不存在
     * @throws IOException
     */
    public  boolean isTableExist(String tableName) throws IOException {

        TableName name = TableName.valueOf(tableName);

        return admin.tableExists(name);
    }

    /**
     * 删除表
     * @param tableName
     * @throws IOException
     */
    public  void dropTable(String tableName) throws IOException{

        TableName name = TableName.valueOf(tableName);

        if(isTableExist(tableName)){
            admin.disableTable(name);
            admin.deleteTable(name);
            LOGGER.info("表 {} 删除成功！", tableName);
        }else{
            LOGGER.error("表 {} 不存在！" ,tableName );
        }
    }


    /**
     * 创建表（tableName 表名; family 列族列表）
     * @param tableName
     * @param familys
     * @throws IOException
     */
    public  void createTable(String tableName, String[] familys) throws IOException {

        TableName name = TableName.valueOf(tableName);
        if (admin.tableExists(name)) {
            LOGGER.error("create table error! this table {} already exists!", tableName);
        } else {

            HTableDescriptor descr = new HTableDescriptor(name);
            for (String family : familys) {
                descr.addFamily(new HColumnDescriptor(family)); //添加列族
            }
            admin.createTable(descr); //建表
            LOGGER.info( "table {} created successfully!", tableName);
        }
    }



    public  byte[] getFileBytes(String path) throws IOException {
        Assert.notNull(path, "file path must not be null");
        FileInputStream fis = new FileInputStream(new File(path));// 新建一个FileInputStream对象
        byte[] b = new byte[fis.available()];// 新建一个字节数组
        fis.read(b);// 将文件中的内容读取到字节数组中
        fis.close();
        return b;
    }

    /**
     * 插入记录（单行单列族-多列多值）
     *
     * @param tableName         表名
     * @param row               行名
     * @param columnFamilys     列族名
     * @param columns           列名（数组）
     * @param values            值（数组）（且需要和列一一对应）
     */
    public void insertRecords(String tableName, String row, String columnFamilys, String[] columns, String[] values) throws IOException {
        Assert.notNull(tableName, "tableName must not be null");
        Assert.notNull(row, "rowkey must not be null");
        Assert.notNull(columnFamilys, "columnFamilys must not be null");

        TableName name = TableName.valueOf(tableName);
        Table table = null;

        StopWatch sw = new StopWatch();
        sw.start();

        try {
            table = connection.getTable(name);
            Put put = new Put(Bytes.toBytes(row));
            for (int i = 0; i < columns.length; i++) {
                put.addColumn(Bytes.toBytes(columnFamilys), Bytes.toBytes(columns[i]), Bytes.toBytes(values[i]));
                table.put(put);
            }
        } catch (Throwable throwable) {
            throw new HbaseSystemException(throwable);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (IOException e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }

    }

    /**
     * 插入记录（单行单列族-单列单值）
     *
     * @param tableName         表名
     * @param row               行名
     * @param columnFamily      列族名
     * @param column            列名
     * @param value             值
     */
    public void insertOneRecord(String tableName, String row, String columnFamily, String column, byte[] value) throws IOException {
        Assert.notNull(tableName, "tableName must not be null");
        Assert.notNull(row, "rowkey must not be null");
        Assert.notNull(columnFamily, "columnFamilys must not be null");

        TableName name = TableName.valueOf(tableName);
        Table table = null;

        StopWatch sw = new StopWatch();
        sw.start();

        try {
            table = connection.getTable(name);

            Put put = new Put(Bytes.toBytes(row));
            put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), value);
            table.put(put);
        } catch (Throwable throwable) {
            throw new HbaseSystemException(throwable);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (IOException e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }
    }

    /**
     * 批量插入数据
     * mutations 插入的值　Put p = new Put(Bytes.toBytes("row"));　list.add(p);
     * @param tableName
     *
     * @throws IOException
     */
    public void batchInsertRecord(String tableName, List<Mutation> mutations) throws IOException {

        Assert.notNull(tableName, "tableName must not be null");

        StopWatch sw = new StopWatch();
        sw.start();
        BufferedMutator mutator = null;

        try {
            BufferedMutatorParams mutatorParams = new BufferedMutatorParams(TableName.valueOf(tableName));
            mutator = connection.getBufferedMutator(mutatorParams.writeBufferSize(3 * 1024 * 1024));
            mutator.mutate(mutations); //
        } catch (Exception e){
            sw.stop();
            throw new HbaseSystemException(e);
        }finally {
            if (null != mutator) {
                try {
                    mutator.flush();
                    mutator.close();
                    sw.stop();
                } catch (IOException e) {
                    LOGGER.error("hbase mutator资源释放失败");
                }
            }

        }


    }
    
    /**
      * 删除一行记录
      *
      * @param tablename         表名
      * @param rowkey            行名
      */
    public void deleteRow(String tablename, String rowkey) throws IOException {
        Assert.notNull(tablename, "tableName must not be null");
        Assert.notNull(rowkey, "rowkey must not be null");

        TableName name = TableName.valueOf(tablename);
        StopWatch sw = new StopWatch();
        sw.start();
        Table table = null;
        try {
            table = connection.getTable(name);
            Delete d = new Delete(rowkey.getBytes());
            table.delete(d);
        } catch (Exception e) {
            throw new HbaseSystemException(e);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (IOException e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }


    }

    /**
     * 查找一行记录
     *
     * @param tablename         表名
     * @param rowKey            行名
     */
    public String selectRow(String tablename, String rowKey) throws IOException {

        Assert.notNull(tablename, "tableName must not be null");
        Assert.notNull(rowKey, "rowkey must not be null");
        String record = "";
        TableName name=TableName.valueOf(tablename);
        StopWatch sw = new StopWatch();
        sw.start();
        Table table = null;
        try {
            table = connection.getTable(name);
            Get g = new Get(rowKey.getBytes());
            Result rs = table.get(g);
            NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> map = rs.getMap();
            for (Cell cell : rs.rawCells()) {
                StringBuffer stringBuffer = new StringBuffer().append(Bytes.toString(cell.getRow())).append("\t")
                        .append(Bytes.toString(cell.getFamily())).append("\t")
                        .append(Bytes.toString(cell.getQualifier())).append("\t")
                        .append(Bytes.toString(cell.getValue())).append("\n");
                String str = stringBuffer.toString();
                record += str;
            }
            return record;
        } catch (IOException e) {
            throw new HbaseSystemException(e);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (Exception e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }

    }

    /**
     * 查找单行单列族单列记录
     *
     * @param tablename         表名
     * @param rowKey            行名
     * @param columnFamily      列族名
     * @param column            列名
     * @return
     */
    public  String selectValue(String tablename, String rowKey, String columnFamily, String column) throws IOException {
        TableName name=TableName.valueOf(tablename);
        Table table = null;
        StopWatch sw = new StopWatch();
        sw.start();
        try {
            table = connection.getTable(name);
            Get g = new Get(rowKey.getBytes());
            g.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column));
            Result rs = table.get(g);
            return Bytes.toString(rs.value());
        } catch (Exception e) {
            throw new HbaseSystemException(e);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (Exception e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }
    }

    /**
     * 查找单行单列族单列记录 主要用于查询流式文件
     *
     * @param tablename         表名
     * @param rowKey            行名
     * @param columnFamily      列族名
     * @param column            列名
     * @return
     */
    public  byte[] selectValueAsBytes(String tablename, String rowKey, String columnFamily, String column) throws IOException {
        TableName name=TableName.valueOf(tablename);
        Table table = null;
        StopWatch sw = new StopWatch();
        sw.start();
        try {
            table = connection.getTable(name);
            Get g = new Get(rowKey.getBytes());
            g.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column));
            Result rs = table.get(g);
            return rs.value();
        } catch (Exception e) {
            throw new HbaseSystemException(e);
        } finally {
            if (null != table) {
                try {
                    table.close();
                    sw.stop();
                } catch (Exception e) {
                    LOGGER.error("hbase资源释放失败");
                }
            }
        }
    }

    /**
     * 查询表中所有行（Scan方式）
     *
     * @param tablename
     * @return
     */
    public String scanAllRecord(String tablename) throws IOException {
        String record = "";
        TableName name=TableName.valueOf(tablename);
        Table table = connection.getTable(name);
        Scan scan = new Scan();
        ResultScanner scanner = table.getScanner(scan);
        try {
            for(Result result : scanner){
                for (Cell cell : result.rawCells()) {
                    StringBuffer stringBuffer = new StringBuffer().append(Bytes.toString(cell.getRow())).append("\t")
                            .append(Bytes.toString(cell.getFamily())).append("\t")
                            .append(Bytes.toString(cell.getQualifier())).append("\t")
                            .append(Bytes.toString(cell.getValue())).append("\n");
                    String str = stringBuffer.toString();
                    record += str;
                }
            }
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }

        return record;
    }

    /**
     * 根据rowkey关键字查询报告记录
     *
     * @param tablename
     * @param rowKeyword
     * @return
     */
    public <T> List<T> scanReportDataByRowKeyword(String tablename, String rowKeyword) throws IOException {
        ArrayList<T> list = new ArrayList<>();

        Table table = connection.getTable(TableName.valueOf(tablename));
        Scan scan = new Scan();

        //添加行键过滤器，根据关键字匹配
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(rowKeyword));
        scan.setFilter(rowFilter);

        ResultScanner scanner = table.getScanner(scan);
        try {
            for (Result result : scanner) {
                //TODO 此处根据业务来自定义实现
                list.add(null);
            }
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }

        return list;
    }

    /**
     * 根据rowkey关键字和时间戳范围查询报告记录
     *
     * @param tablename
     * @param rowKeyword
     * @return
     */
    public <T> List<T> scanReportDataByRowKeywordTimestamp(String tablename, String rowKeyword, Long minStamp, Long maxStamp) throws IOException {
        ArrayList<T> list = new ArrayList<>();

        Table table = connection.getTable(TableName.valueOf(tablename));
        Scan scan = new Scan();
        //添加scan的时间范围
        scan.setTimeRange(minStamp, maxStamp);

        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(rowKeyword));
        scan.setFilter(rowFilter);

        ResultScanner scanner = table.getScanner(scan);
        try {
            for (Result result : scanner) {
                //TODO 此处根据业务来自定义实现
                list.add(null);
            }
        } finally {
            if (scanner != null) {
                scanner.close();
            }
        }
        return list;
    }
}

独行客-编码爱好者
关注
专栏目录
springboot-集成hbase
子龙修仙的博客
04-13 2999
修改pom.xml 添加依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-hadoop</artifactId> <version>2.5.0.RELEASE</version&...
spring-boot-starter-hbase:Spring Boot Starter HBase的
05-09
项目介绍 自定义的spring-boot的hbase starter，为hbase的query和更新等操作提供简易的api并集成spring-boot的auto configuration 版本 本项目版本 hbase版本 1.0.0 hbase1.1.2 打包 修改相关的maven私服地址 gradle clean install 使用方式 依赖 compile "org.banyan.spring.boot:spring-boot-starter-hbase:1.0.0" 集成 在spring-boot项目的application.properties文件中加入spring.data.hbase.quorum,spring.data.hbase.rootDir,spring.data.hbase.nodeParent配置项，并赋予正确的值 使用 query 将上述配置项赋予正确的值 d
springboot集成hbase
09-17
本示例示springboot集成hbase的一个工具，用户下载后，只需要更改HBaseUtil类中的配置为自己的hbase服务器上的相关配置及更改resources下hbase.keytab和krb5.conf文件为自己服务器上的文件即可使用
SpringBoot使用Hbase
lmchhh的博客
04-15 2617
以前都是在非Spring环境下使用Hbase的，一开始会出现：当服务使用时间过久，某些会使用hbase的接口调用次数过多的时候，会报【已超过最大的连接数】，只能每一次调用接口后最后一行加上释放连接。（以前的做法每次调用都要在代码里手动获取一个连接）这次将释放连接都集成在操作服务类的实现方法中，避免了开发接口可能遗漏的错误，可能不会再出现这个问题。init()方法实现在初始化连接池的时候创建默认数值的连接。这里没有使用懒加载模式，减少启动后第一次访问时访问时间过长。ok，现在就可以操作使用了。
Springboot整合HBase
青春不散场的专栏
08-31 2823
Data。
springboot集成Hbase
经验分享
09-26 3128
前提：hbase版本是1.2.6，详情看 1、添加maven <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId> <version>2.2.3</version> <exclusions>
Springboot整合HBase——大数据技术之HBase2.x
qq_43842093的博客
02-15 2841
Apache HBase 是以hdfs为数据存储的，一种分布式、可扩展的noSql数据库。是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。HBase使用与BigTable（BigTable是一个稀疏的、分布式的、持久化的多维排序map）非常相似的数据模型。用户将数据行存储在带标签的表中。数据行具有可排序的键和任意数量的列。该表存储稀疏，因此如果用户喜欢，同一表中的行可以具有疯狂变化的列。
基于springboot集成hbase过程解析
08-25
SpringBoot集成HBase是当前大数据处理和存储解决方案中的一种常见组合。HBase是基于Hadoop的分布式、可扩展的NoSQL数据库，能够存储大量的结构化和非结构化数据。SpringBoot则是一个基于Java的现代Web框架，提供了...
springboot集成phoenix+hbase
10-26
首先，我们需要在Spring Boot项目中添加相应的依赖。对于Spring Boot，我们需要包含`spring-boot-starter-web`来启用web服务；对于Phoenix，我们需要添加`phoenix-core`和`phoenix-queryserver-client`依赖，以便...
springboot-hbase
07-04
在SpringBoot项目中，我们可以通过Spring Data JPA或自定义Repository来访问数据库，但HBase并不支持JPA，因此我们将借助Phoenix，它是Apache HBase的SQL层，允许我们通过SQL语句与HBase进行交互。 1. **环境准备**...
java springboot3 集成hbase配置
04-21
首先，您需要添加HBase的依赖项，然后在application.yml文件中添加HBase的配置信息，包括HBase的ZooKeeper地址和端口号等。接下来，您可以使用HBaseTemplate和HBaseAdmin等类来访问和管理HBase数据。具体的配置和...
spring-boot-starter-hbase自定义的spring-boot的hbasestarter
08-07
自定义的spring-boot的hbase starter，为hbase的query和更新等操作提供简易的api并集成spring-boot的auto configuration
springboot hbase
写bug的小哥哥
12-16 3112
1.添加依赖 <hbase.version>2.2.4</hbase.version> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-shaded-client</artifactId> <version>${hbase.version}</ve
Spring Boot 整合 HBase
Java搜索工程技术栈
05-29 6176
一、HBase 介绍 HBase是一个分布式的、面向列的开源数据库，Hadoop 数据库。搭建基于 Hadoop 和 ZK 。 历史是基于 Google 的 Bigtable 、Google 文件系统等论文。HBase 在Hadoop 之上提供了类似于 Bigtable 的能力。 HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。 HBase 特性： 大：一个表可以有数十亿
springboot+Kerberos连接Hbase
u011165335的博客
09-07 2235
上一篇简单记录了springboot+Kerberos认证+连接hadoop+hive 地址: https://blog.csdn.net/u011165335/article/details/108344732 这次记录一下java如何连接Hbase; 查看用户列表：cat /etc/passwd 注意:谁认证,那么当前的用户就是谁 比如,你用appuser.keytab认证,那么当前hbase用户就是appuser 你用hbase.keytab认证,那么当前hbase用户就是hbase 所以要注意用谁来
SpringBoot操作hbase
qq_43842093的博客
06-23 4505
1，添加依赖（客户端版本和 HBase 版本需要保持一致，否则可能会遇到不兼容的问题。） 2，yml配置 3，代码段（配置类，获取配置） 4,实体类 5，操作（service） 6，controller层（这里只是简单调用查看）...
SpringBoot 集成 HBase
TechnicianWang的博客
05-05 1711
【代码】SpringBoot 集成 HBase。
SpringBoot集成Hbase
最新发布
saonian0929的博客
07-05 828
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 解决
Spring Boot HBase入门
weixin_42073629的博客
04-28 612
一、HBase 简介和应用场景 1.1 HBase 是什么？ HBase 是什么？HBase 是在 Hadoop 分布式文件系统（简称：HDFS）之上的分布式面向列的数据库。而且是 2007 最初原型，历史悠久。 那追根究底，Hadoop 是什么？Hadoop是一个分布式环境存储并处理大数据。Hadoop 使用 MapReduce 算法统计分析大数据。这时候不得不说下 Google 的著名的...
springboot集成hbase配置类
04-20
很高兴回答你关于 SpringBoot 集成 HBase 配置类的问题。你可以在 Spring Boot 中通过配置 Hadoop Configuration 和 HBase Configuration 实现 HBase 的连接和数据读写。你需要在 Spring Boot 的配置文件中指定 HBase 的 Zookeeper 地址和端口号，例如：hbase.zookeeper.quorum=127.0.0.1:2181。同时，你还需要配置 HBase 的 Client 和 Connection，可以通过 Spring Boot 提供的 HBaseTemplate 和 ConnectionFactory 来实现。希望这个回答能对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

独行客-编码爱好者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值