真实项目 Hbase操作表 进行获取数据

已于 2022-03-19 15:12:45 修改
阅读量2.4k 收藏 2
点赞数 2
分类专栏： HBase Work java学习 文章标签： hbase big data zookeeper
于 2021-12-16 13:25:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gps666666/article/details/121972542
版权
java学习 同时被 3 个专栏收录
68 篇文章 0 订阅
订阅专栏
Work
24 篇文章 0 订阅
订阅专栏
HBase
6 篇文章 0 订阅
订阅专栏 
package com.newegg.modesty.service;

import com.newegg.modesty.config.AutoPartsConfig;
import com.newegg.modesty.hbase.HbaseOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author Modesty.P.Gao
 * @version 1.0
 * @description: TODO
 * @date 2021/12/10 9:43
 */
@Service
public class AuroPartsService {

    @Autowired
    private AutoPartsConfig config;

    public void startJob(){
        HbaseOperation hbase=new HbaseOperation(config.getHbaseHost(),config.getHbaseTable());
        hbase.initConnect();
        hbase.scanTable();
    }

}


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>HbaseDemoWork</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>logback-classic</artifactId>
                    <groupId>ch.qos.logback</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.0-cdh5.9.3</version>
            <exclusions>
                <exclusion>
                    <artifactId>jdk.tools</artifactId>
                    <groupId>jdk.tools</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>servlet-api</artifactId>
                    <groupId>javax.servlet</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package com.newegg.modesty.constant;

/**
 * @author Modesty.P.Gao
 * @version 1.0
 * @description: TODO
 * @date 2021/12/10 9:05
 */
public class Constant {
    private Constant(){

    }

    public static final String NAME_COUNT = "NameCount";
    public static final String PHONE_COUNT = "PhoneCount";
    public static final String AGE_COUNT = "AgeCount";
    public static final String EMAIL_COUNT = "EmailCount";

    public static final String FAMILY_INFO = "information";
    public static final String FAMILY_CONTACT = "contact";
    public static final String COLUMN_AGE = "age";
    public static final String COLUMN_NAME = "name";
    public static final String COLUMN_PHONE = "phone";
    public static final String COLUMN_EMAIL = "email";


}


package com.newegg.modesty.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @author Modesty.P.Gao
 * @version 1.0
 * @description: TODO
 * @date 2021/12/10 9:00
 */
@Configuration
public class AutoPartsConfig {

    @Value("${hbase.hosts}")
    private  String hbaseHost;

    @Value("${hbase.table}")
    private  String hbaseTable;

    public String getHbaseHost() {
        return hbaseHost;
    }

    public void setHbaseHost(String hbaseHost) {
        this.hbaseHost = hbaseHost;
    }

    public String getHbaseTable() {
        return hbaseTable;
    }

    public void setHbaseTable(String hbaseTable) {
        this.hbaseTable = hbaseTable;
    }
}


package com.newegg.modesty.hbase;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.newegg.modesty.constant.Constant;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HRegionInfo;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;


import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author Modesty.P.Gao
 * @version 1.0
 * @description: TODO
 * @date 2021/12/10 9:42
 */
public class HbaseOperation {

    private static final Logger LOGGER = LoggerFactory.getLogger(HbaseOperation.class);
    private Connection connection;
    private String hbaseHost;
    private String hbaseTable;
    private ExecutorService executorService = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MINUTES, new LinkedBlockingQueue<>(1024));

    public HbaseOperation(String hbaseHost, String hbaseTable) {
        this.hbaseHost = hbaseHost;
        this.hbaseTable = hbaseTable;
    }

    public void initConnect() {
        Configuration baseConf = HBaseConfiguration.create();
        baseConf.set("hbase.zookeeper.quorum", hbaseHost);
        try {
            connection = initConnect(connection, baseConf);
        } catch (IOException e) {
            LOGGER.error("connect hbase has error", e);
        }
    }

    private Connection initConnect(Connection connection, Configuration configuration) throws IOException {
        if (Objects.nonNull(configuration) && Objects.nonNull(connection)) {
            connection.close();
        }
        connection = ConnectionFactory.createConnection(configuration);
        return connection;

    }

    public ConcurrentHashMap<String, AtomicInteger> scanTable() {
        Table table = null;
        LOGGER.info("begin to run hbase data");
        TableName tableName = TableName.valueOf(this.hbaseTable);
        try {
            table = connection.getTable(tableName);
            List<HRegionInfo> regionInfoList = connection.getAdmin().getTableRegions(tableName);
            LOGGER.info("fetch table regionInfoList:{}", regionInfoList);
            if (Objects.nonNull(regionInfoList) && !CollectionUtils.isEmpty(regionInfoList)) {
                return scanMultipleRegions(table, regionInfoList);
            }
        } catch (IOException e) {
            LOGGER.info("scan table has error,", e);
        } finally {
            if (Objects.nonNull(table)) {
                try {
                    table.close();
                } catch (IOException e) {
                    LOGGER.info("table close has error,", e);
                }
            }
        }
        return new ConcurrentHashMap<>();
    }

    private ConcurrentHashMap<String, AtomicInteger> scanMultipleRegions(final Table table, List<HRegionInfo> regionInfoList) {
        LOGGER.info("start run multiple region function.");
        ConcurrentHashMap<String, AtomicInteger> result = new ConcurrentHashMap<>();
        result.put(Constant.NAME_COUNT, new AtomicInteger(0));
        result.put(Constant.PHONE_COUNT, new AtomicInteger(0));
        result.put(Constant.AGE_COUNT, new AtomicInteger(0));
        result.put(Constant.EMAIL_COUNT, new AtomicInteger(0));
        Map<String, Future<?>> futureMap = new LinkedHashMap<>();
        for (HRegionInfo hRegionInfo : regionInfoList) {
            Future<?> f = executorService.submit(() -> scanTableByRegion(hRegionInfo, result, table));
            futureMap.put(hRegionInfo.getRegionNameAsString(), f);
        }
        if (!CollectionUtils.isEmpty(futureMap)) {
            for (Map.Entry<String, Future<?>> entry : futureMap.entrySet()) {
                Future<?> future = futureMap.get(entry.getKey());
                try {
                    LOGGER.info("start to wait region result:[{}]", entry.getKey());
                    future.get();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    LOGGER.info("wait thread pool has error.", e);
                    Thread.currentThread().interrupt();
                }
            }
            LOGGER.info("end to scan table");
        }
        print("End result", result);
        return result;
    }

    private void print(String message, ConcurrentHashMap<String, AtomicInteger> resultMap) {
        LOGGER.info(message + ", nameCount:{}, phoneCount:{}, ageCount:{}, emailCount:{}", resultMap.get(Constant.NAME_COUNT),
                resultMap.get(Constant.PHONE_COUNT), resultMap.get(Constant.AGE_COUNT), resultMap.get(Constant.EMAIL_COUNT));
    }

    private void scanTableByRegion(HRegionInfo hRegionInfo, ConcurrentHashMap<String, AtomicInteger> resultMap, Table finalTable) {
        LOGGER.info("start to scan region:[{}]", Objects.nonNull(hRegionInfo) ? hRegionInfo.getRegionNameAsString() : "all");
        long start = System.currentTimeMillis();
        String regionName = "all";
        Scan scan = new Scan();

        try {

            if (Objects.nonNull(hRegionInfo)) {
                regionName = hRegionInfo.getRegionNameAsString();
                LOGGER.info("region [{}] start:{}, end:{}", regionName,
                        Bytes.toString(hRegionInfo.getStartKey()), Bytes.toString(hRegionInfo.getEndKey()));
                scan.setStartRow(hRegionInfo.getStartKey());
                scan.setStopRow(hRegionInfo.getEndKey());
            }

            scan.setCaching(5000);

            ResultScanner results = finalTable.getScanner(scan);
            long rowCount = 0;
            long itemCount = 0;
            for (Result result : results) {
                transFormResult(result, resultMap);
                rowCount++;
                if (rowCount % 5000 == 0) {

                    // sleep
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    print(new String(result.getRow()), resultMap);
                }
            }

            LOGGER.info("end to scan region:[{}], row sum is {},hbase item sum is {}, used time {} s.",
                    regionName, rowCount, itemCount,
                    (System.currentTimeMillis() - start) / 1000);

        } catch (IOException e) {
            LOGGER.info("search table has error,", e);
            Thread.currentThread().interrupt();
        }
    }

    private void transFormResult(Result result, ConcurrentHashMap<String, AtomicInteger> resultMap) {

        try {
            byte[] infoNames = result.getValue(Constant.FAMILY_INFO.getBytes(StandardCharsets.UTF_8), Constant.COLUMN_NAME.getBytes(StandardCharsets.UTF_8));
            byte[] infoAge = result.getValue(Constant.FAMILY_INFO.getBytes(StandardCharsets.UTF_8), Constant.COLUMN_AGE.getBytes(StandardCharsets.UTF_8));
            byte[] contPhones = result.getValue(Constant.FAMILY_CONTACT.getBytes(StandardCharsets.UTF_8), Constant.COLUMN_PHONE.getBytes(StandardCharsets.UTF_8));
            byte[] contEmail = result.getValue(Constant.FAMILY_CONTACT.getBytes(StandardCharsets.UTF_8), Constant.COLUMN_EMAIL.getBytes(StandardCharsets.UTF_8));


            if (!Objects.isNull(infoNames)) {
                String data = new String(infoNames, StandardCharsets.UTF_8);
//                JSONArray array = JSON.parseArray(data)
                if (data.length() > 0) {
                    // Add cart count
                    resultMap.get(Constant.NAME_COUNT).addAndGet(1);
                }
            }

            if (!Objects.isNull(infoAge)) {
                String data = new String(infoAge, StandardCharsets.UTF_8);
//                JSONArray array = JSON.parseArray(data)
                if (data.length() > 0) {
                    // Add cart count
                    resultMap.get(Constant.AGE_COUNT).addAndGet(1);

                }
            }
            if (!Objects.isNull(contPhones)) {
                String data = new String(contPhones, StandardCharsets.UTF_8);
//                JSONArray array = JSON.parseArray(data)
                if (data.length() > 0) {
                    // Add cart count
                    resultMap.get(Constant.PHONE_COUNT).addAndGet(1);

                }
            }
            if (!Objects.isNull(contEmail)) {
                String data = new String(contEmail, StandardCharsets.UTF_8);
//                JSONArray array = JSON.parseArray(data)
                if (data.length() > 0) {
                    // Add cart count
                    System.out.println(data);
                    resultMap.get(Constant.EMAIL_COUNT).addAndGet(1);

                }
            }


        } catch (Exception e) {
            LOGGER.info("Analysis row[{}] error.", new String(result.getRow()));
        }
    }
}

注释

package com.newegg.modesty.hbase;

import com.newegg.modesty.Config.Config;
import com.newegg.modesty.property.Prop;
import org.apache.commons.configuration.ConfigurationFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HRegionInfo;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author Modesty.P.Gao
 * @version 1.0
 * @description: TODO
 * @date 2021/12/14 13:49
 */
public class HbaseJob {
    //开启log日志
    private static final Logger LOGGER = LoggerFactory.getLogger(HbaseJob.class);
    //获取hbase的连接对象
    private Connection connection;
    //hbase相关的地址
    private String hbaseHost;
    //hbase相关的表
    private String hbaseTable;
    //开始线程池
    private ExecutorService executorService = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MINUTES, new LinkedBlockingDeque<>(1024));

    /**
     * 构造方法
     *
     * @param hbaseHost
     * @param hbaseTable
     */
    public HbaseJob(String hbaseHost, String hbaseTable) {
        this.hbaseHost = hbaseHost;
        this.hbaseTable = hbaseTable;
    }

    /**
     * 获取hbase相关的属性
     */
    public void initConnect() {
        //获取hbase相关的配置对象
        Configuration configuration = HBaseConfiguration.create();
        //设置相关集群地址
        configuration.set("hbase.zookeeper.quorum", hbaseHost);
        try {
            //进行连接方法的调用
            connection = initConnect(connection, configuration);
        } catch (IOException e) {

            LOGGER.error("connect has a error" + e);
        }
    }


    /**
     * 连接方法
     *
     * @param connection
     * @param configuration
     * @return
     */
    private Connection initConnect(Connection connection, Configuration configuration) throws IOException {
        //判断连接的对象是否存在，存在则关闭，否则则创建一个新的连接对象
        if (Objects.nonNull(configuration) && Objects.nonNull(connection)) {
            connection.close();
        }
        return ConnectionFactory.createConnection();
    }

    public HashMap<String, AtomicInteger> scanTable() {
        Table table = null;
        LOGGER.info("start rub hbase data");
        //hbase 获取需要进行扫描的表名称
        TableName tableName = TableName.valueOf(hbaseTable);
        //用连接的hbase的连接对象，去操作这个需要进行扫描的表
        try {
            //通过表名得到这个表对象
            table = connection.getTable(tableName);
            //去得到这个表的内容
            List<HRegionInfo> regionsInfoList = connection.getAdmin().getTableRegions(tableName);
            LOGGER.info("regionsInfoList:{}", regionsInfoList);
            //判断扫描的表 内容是否为空
            if (!CollectionUtils.isEmpty(regionsInfoList)) {
                //不是空的话，继续深入表中去得到数据
                return scanMultipleRegions(table, regionsInfoList);
            }
        } catch (IOException e) {
            LOGGER.error("scan table has error" + e);
        } finally {
            //最后释放表对象资源
            if (Objects.nonNull(table)) {
                try {
                    table.close();
                } catch (IOException e) {
                    LOGGER.error("table close has error" + e);
                }
            }
        }
        //如果执行到这 还没有return，那么返回一个空集合
        return new HashMap<>();
    }

    /**
     * 去扫描整张表，去获取数据。
     *
     * @param table
     * @param regionsInfoList
     * @return
     */
    private HashMap<String, AtomicInteger> scanMultipleRegions(Table table, List<HRegionInfo> regionsInfoList) {
        LOGGER.info("start scan multiple table");
        HashMap<String, AtomicInteger> result = new HashMap<>();
        //因为是用线程池来完成，考虑到并发去读取，这里使用原子类来保证数据的统一。
        result.put(Prop.COLUMN_NAME, new AtomicInteger(0));
        result.put(Prop.COLUMN_AGE, new AtomicInteger(0));
        result.put(Prop.COLUMN_PHONE, new AtomicInteger(0));
        //这里用LinkedHashMap的目的是：保证插入map中的数据是有序插入（先扫描就在前面）以便后续的打印或者日志查询。
        Map<String, Future<?>> futureMap = new LinkedHashMap<>();
        //把整个表拆分开，去使用线程去完成各行的数据，
        for (HRegionInfo hRegionInfo : regionsInfoList) {
            //返回的f 是每一个线程是否完成这次的Task
            Future<?> f = executorService.submit(() -> scanTableByRegion(hRegionInfo, result, table));
            //以这里用一个map集合去收集这些信息，以便后续的日志打印。
            futureMap.put(hRegionInfo.getRegionNameAsString(), f);
        }
        if (!CollectionUtils.isEmpty(futureMap)) {
            for (Map.Entry<String, Future<?>> entry : futureMap.entrySet()) {
                Future<?> future = futureMap.get(entry.getKey());
                LOGGER.info("start to  region result:[{}]", entry.getKey());
                try {
                    future.get();
                } catch (Exception e) {
                    LOGGER.error("region result has error", e);
                    Thread.currentThread().interrupt();
                }
            }
            LOGGER.info("end to scan table");
        }
        print("End result", result);
        return result;
    }

    private void print(String message, HashMap<String, AtomicInteger> resultMap) {
        LOGGER.info(message + ", nameCount:{}, phoneCount:{}, emailCount{},ageCount:{}", resultMap.get(Prop.COUNT_NAME),
                resultMap.get(Prop.COLUMN_PHONE), resultMap.get(Prop.COUNT_EMAIL), resultMap.get(Prop.COUNT_AGE));
    }

    /**
     * 这里其实每个线程去负责一个区域（最少数据的话，可以看做是每一行的扫描）
     *
     * @param hRegionInfo
     * @param resultMap
     * @param table
     */
    private void scanTableByRegion(HRegionInfo hRegionInfo, HashMap<String, AtomicInteger> resultMap, Table table) {
        LOGGER.info("start to scan region:[{}]", Objects.nonNull(hRegionInfo) ? hRegionInfo.getRegionNameAsString() : "all");
        //获取开始的当前时间
        long start = System.currentTimeMillis();
        //默认的区域是 代表全表
        String regionName = "all";
        //创建扫描对象
        Scan scan = new Scan();

        if (Objects.nonNull(hRegionInfo)) {
            //得到每一个区域的名称。
            regionName = hRegionInfo.getRegionNameAsString();
            LOGGER.info("region[{}] start{},end{}", regionName, Bytes.toString(hRegionInfo.getStartKey()), Bytes.toString(hRegionInfo.getEndKey()));
            scan.setStartRow(hRegionInfo.getStartKey());
            scan.setStopRow(hRegionInfo.getEndKey());
        }
        //这个是针对行，代表有多个数据再去提交一下，提高性能。但是会浪费空间，  采用的是空间换取时间。
        scan.setCaching(100);

        try {    //进行表的扫描 得到这个区域的结果
            ResultScanner results = table.getScanner(scan);
            //将这个区域的数据进行遍历，去得到这行 每个数据
            for (Result result : results) {
                transFormResult(result, resultMap);
            }
        } catch (IOException e) {
            LOGGER.error("table scan has error" + e);
        }
    }

    /**
     * 得到每一行的 每个数据 ，进行操作。
     *
     * @param result
     * @param resultMap
     */
    private void transFormResult(Result result, HashMap<String, AtomicInteger> resultMap) {
        try {
            //这个方法 传入参数是：family的名称和列的名称，用UTF_8的格式返回。得到一个Byte[]数组
            byte[] infoNames = result.getValue(Prop.FAMILY_INFO.getBytes(StandardCharsets.UTF_8), Prop.COLUMN_NAME.getBytes(StandardCharsets.UTF_8));
            byte[] infoAge = result.getValue(Prop.FAMILY_INFO.getBytes(StandardCharsets.UTF_8), Prop.COLUMN_AGE.getBytes(StandardCharsets.UTF_8));
            byte[] ConPhone = result.getValue(Prop.FAMILY_CONST.getBytes(StandardCharsets.UTF_8), Prop.COLUMN_PHONE.getBytes(StandardCharsets.UTF_8));
            byte[] ConEmail = result.getValue(Prop.FAMILY_CONST.getBytes(StandardCharsets.UTF_8), Prop.COLUMN_EMAIL.getBytes(StandardCharsets.UTF_8));

            //得到这些数组后，进行判断
            if (Objects.nonNull(infoNames)) {
                //将这个数组转为UTF_8格式的String类型。
                String data = new String(infoNames, StandardCharsets.UTF_8);
                if (data.length() > 0) {
                    //如果有数据的话，去增加1
                    resultMap.get(Prop.COUNT_NAME).addAndGet(1);
                }
            }
            if (Objects.nonNull(infoAge)) {
                //将这个数组转为UTF_8格式的String类型。
                String data = new String(infoAge, StandardCharsets.UTF_8);
                if (data.length() > 0) {
                    //如果有数据的话，去增加1
                    resultMap.get(Prop.COUNT_AGE).addAndGet(1);
                }
            }
            if (Objects.nonNull(ConPhone)) {
                //将这个数组转为UTF_8格式的String类型。
                String data = new String(ConPhone, StandardCharsets.UTF_8);
                if (data.length() > 0) {
                    //如果有数据的话，去增加1
                    resultMap.get(Prop.COUNT_PHONE).addAndGet(1);
                }
            }
            if (Objects.nonNull(ConEmail)) {
                //将这个数组转为UTF_8格式的String类型。
                String data = new String(ConEmail, StandardCharsets.UTF_8);
                if (data.length() > 0) {
                    //如果有数据的话，去增加1
                    resultMap.get(Prop.COUNT_EMAIL).addAndGet(1);
                }
            }
        } catch (Exception e) {

            LOGGER.error("add data has error" + e);
        }
    }
}
小高求学之路
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
获取元数据表hbase meta和用户表信息.png
09-01
该脑图是介绍获取元数据表hbase meta和用户表信息，请贡献给大家下载！
大数据学习之Hbase shell的基本操作
11-23 1913
　　HBase的命令行工具，最简单的接口，适合HBase管理使用，可以使用shell命令来查询HBase中数据的详细情况。安装完HBase之后，启动hadoop集群(利用hdfs存储)，启动zookeeper，使用start-hbase.sh命令开启hbase服务，最后在shell中执行hbase shell就可以进入命令行界面 　　Habse shell的help对语法的介绍很全,hbase shell 的操作分为 10类，j本文只介绍前4类常用的，分别是：gerneral,ddl,namespace,
大数据学习——第三章第2关：创建表
weixin_57127999的博客
05-09 362
大数据学习——第三章第2关：创建表
HBase读取流程详解
晓晓的天空
03-05 1489
HBase读取流程详解
hbase获取表信息_HBase读写流程
weixin_42474164的博客
01-30 782
前言：对于一个数据库来说，想学会它的底层原理，就一定要熟悉它的读写过程，因为数据库最常见的操作就是读和写前面我们已经把数据模型和架构各自击破，本篇将通过读写流程将学过的知识串一遍，做到融汇贯通本篇目标：1.掌握读写流程的主要过程2.思考读写过程中所涉及原理与细节01读数据流程先来看下读取数据的流程：HBase读流程我把读流程划分为2大步7小步：1.获取目标Region位置1)Client...
gohbase的使用
学习小记
08-21 3128
goHbase库的使用 import库： import ( "context" "errors" "fmt" "github.com/jeanphorn/log4go" "github.com/tsuna/gohbase" "github.com/tsuna/gohbase/hrpc" "io" ) 数据结构： type HBHelper struct { Hbase...
从HBASE中读取数据，MR进行分析处理输出
weixin_43087634的博客
12-08 1415
从HBASE中读取数据，继承的是TableMapper，不是Mapper，map端主要是从HBASE上获取数据，然后进行输出，输出类型自己可以随意定义。 代码如下： package HbaseMR; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; import org.apache.had...
hbase 获取表对象的方法_获取数据基本途径及抽样方法，正确分清考察对象是抽取样本的关键...
weixin_35692838的博客
01-15 279
【考试要求】1.知道获取数据的基本途径；2.了解总体、样本、样本容量的概念，了解数据的随机性；3.了解简单随机抽样的含义及其解决问题的过程，掌握两种简单随机抽样方法：抽签法和随机数法；4.了解分层随机抽样的特点和适用范围，了解分层随机抽样的必要性，掌握各层样本量比例分配的方法.【知识梳理】1.获取数据的基本途径获取数据的基本途径包括：统计报表和年鉴、社会调查、试验设计、普查和抽样、互联网等.(1)...
hbase 获取表对象的方法_VBA中怎么操作工作表，认识Worksheets对象的方法
weixin_31622725的博客
01-26 346
上一章给大家分享了关于Application对的属性Workbooks的使用方法并举例子，今天就给大家继续分享一下关于Worksheet的使用和举例子。Worksheet和Worksheets的关系Worksheet就表示一张工作表，Worksheets表示很多的工作表。下面是对工作表的操作：1. 新建工作表：新建工作表需要使用Worksheets对象的方法Add,这个方法分为带参数的和不带参数的...
HBase数据模型解析和基本的表设计分析
02-24
最近在学习HBase的使用，并仔细阅读了一篇官方推荐的博客，在这里就以一边翻译一边总结的方式和大家一起梳理一下HBase的数据模型和基本的表设计思路。HBase是一个开源可伸缩的针对海量数据存储的分布式nosql数据库，...
python操作 hbase 数据的方法
12-23
在工程中设置中，找到project interpreter， 在相应的工程下，找到package，然后选择 “+” 添加， 搜索 hbase-thrift (Python client for HBase Thrift interface),然后安装包。 安装服务器端thrift。 参考官网，...
通用MapReduce程序复制HBase表数据
12-16
编写MR程序，让其可以适合大部分的HBase表数据导入到HBase表数据。其中包括可以设置版本数、可以设置输入表的列导入设置(选取其中某几列)、可以设置输出表的列导出设置(选取其中某几列)。 原始表test1数据如下： 每...
java代码将mysql表数据导入HBase表
最新发布
03-14
java代码将mysql表数据导入HBase表 + 样例mysql表和数据 + HBase表创建
java导出hbase表数据_将HBase中的表的数据进行wordCount输出到hdfs上
weixin_35998791的博客
02-25 288
将hbase中的表userinfo2中的key值和value值进行wordcount，然后输出到hdfs上，输出的要求是输出到0711文件夹，然后按照首字符进行文件夹的分割。建表数据mapreduce程序map程序packagecom.hadoop.mapreduce.test.map;importjava.io.IOException;importorg.apache.hadoop.hba...
HBase shell操作，看这一篇就够了
热门推荐
石榴姐yyds
03-02 1万+
1.基本操作 1 进入 HBase客户端的命令 hbase shell 2.查看帮助命令 help 3.查看当前数据库有哪些表 list 2.表的基本操作 1.创建表 hbase(main):006:0> create 'student','infor' 2.插入数据到表 hbase(main):008:0> put 'student','1001',...
HBase 通过“表名”和“列族”获取该列族下的所有数据
onway_goahead的博客
10-28 2481
/** * 浏览表中某一列(族)的数据。 * 如果该列族有若干列限定符，就列出每个列限定符代表的列的数据； * 如果列名以“columnFamily:column”形式给出，只需列出该列的数据。 * @param tableName 表名 * @param column 列名 */ public static void scanColumn(String tableName, String column) throws IOExc...
快速统计hbase中某张表中数据条数
weixin_33670786的博客
02-28 5485
2019独角兽企业重金招聘Python工程师标准>>> ...
HBase API 之 表数据操作
哈
03-10 1280
相关博客 win10安装hadoop3.1.2 HBase集群中原有数据： 第一步：创建Maven项目，导入依赖 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version...
hbase获取表内全部数据
05-18
要获取HBase表内的全部数据，可以使用HBase Shell或者Java API。 使用HBase Shell： 1. 打开HBase Shell：`hbase shell` 2. 选择要查看的表：`scan 'table_name'` 这将返回表中的所有行和列族以及它们的值。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小高求学之路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值