Hbase 的弊端 按时间段范围查询（三）

最新推荐文章于 2024-08-27 00:42:19 发布
最新推荐文章于 2024-08-27 00:42:19 发布
阅读量7.8k 收藏 19
点赞数 3
分类专栏： 大数据 hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011066470/article/details/98180569
版权

假设：

Rowkey设计为：

rowkey=分区号(userId的最后一位+补充0,组成两位数)-注册时间的时间戳(13位)-u+userId(按千万量计算，加前缀u，共6位)

现在要查询出时间段:1564647622838 到1564647622938 这个时间段的数据

#方案一：采用过滤器  无法单纯通过这个时间段查询数据

#方案二：设置startRow，endRow

 startRow="70-1564647622838-u000000"，endRow="80-1564647622938-u1000000";

不太满足要求，80分区中时间段小于1564647622838数据也能查询出来

#方案三：分区查询再累加

70区域这个时间段的数据：  

startRow="70-1564647622838-u000000"，endRow="70-1564647622938-u1000000";

80区域这个时间段的数据：  

startRow="80-1564647622838-u000000"，endRow="80-1564647622938-u1000000";

最后这个两个区域70,80都是这个时间段的结果累加起来。

下面是前面两篇博文的完整代码：

package com.meboth.hive.connection.hbase.createPartition;

import com.meboth.hive.connection.hbase.hbase.HbaseUtil;
import com.meboth.hive.connection.hbase.utils.DateUtil;
import com.meboth.hive.connection.hbase.utils.HbaseConnectionUtils;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.util.*;

/**
 * @className CreateHbasePartitionTable
 * @Description TODO
 * @Author liujianfu
 * @Date 2019/7/13 16:40
 * @Version 1.0
 **/

public class CreateHbasePartitionTable {
    private  final static Logger log= Logger.getLogger(String.valueOf(CreateHbasePartitionTable.class));
    public static void main(String args[])throws IOException{

       //createIndexTsble();//索引表
       // createInfoTable();//信息表
        /*************查询 *******************/
        /*
        String startRow="70-u000";
        String endRow="90-u100";
        String tableNameIndex=  "hb_yonghu_index";
        Table tableIndex=HbaseConnectionUtils.getInstance().getTable(tableNameIndex);
       scanByRangeQuery(tableIndex,startRow,endRow);//范围查询
       */

        /**
        scanByRegexFilter(tableIndex, "u073"); //正则查询
         **/

        /**
         String rowKey="90-u100";
        scanByRowKeyFilter(tableIndex,rowKey);//rowkey查询
         **/
        Table table=HbaseConnectionUtils.getInstance().getTable("hb_yonghu");
        String beginStr="70-1564647622838-u000000";
        String endStr="80-1564647622938-u1000000";
       // scanByPrefixQuery(table,"70");

       //scanByContainsFilter(table,"","1564647622836");//时间查询

       scanByRangeTimeQuery(table,beginStr,endStr);//时间范围查询;80-0000000-XXX到80-1564647622938的数据也能查询到
       // 80分区比70分区大，即80分区的所有数据均能查询出来。
        //要求要查询：时间段:1564647622838 到1564647622938 这个时间段的数据
       //  startRow="70-1564647622838-u000000"，endRow="80-1564647622938-u1000000";不太满足要求，80分区中时间段小于1564647622838数据也能查询出来
       // 解决办法：分区查询再累加；70区域这个时间段的数据：  startRow="70-1564647622838-u000000"，endRow="70-1564647622938-u1000000";
        //                         80区域这个时间段的数据：  startRow="80-1564647622838-u000000"，endRow="80-1564647622938-u1000000";
        //                最后将结果累加起来



    }

    /**
     * 创建索引表
     */
    public static void createIndexTsble(){
        String tableNameIndex=  "hb_yonghu_index";
        String familyArray[]={"index-rw"};
        initUserTable(tableNameIndex, familyArray,true);
        Table tableIndex=HbaseConnectionUtils.getInstance().getTable( tableNameIndex);
        batchPutIndex(tableIndex);//索引表
    }

    /**
     * 创建信息表
     */
    public static void createInfoTable(){
        String tableName=  "hb_yonghu";
        String familyArray[]={"index-rw"};
        initUserTable(tableName, familyArray,true);
        Table table=HbaseConnectionUtils.getInstance().getTable( tableName);
        batchPut(table);//信息表
    }
    public static void initUserTable(String tableName,String familyArray[],boolean partionFlag){
        List<String> list=new ArrayList<String>();
        try {
            Admin hadmin = HbaseConnectionUtils.getInstance().getConnection().getAdmin();
            TableName tm = TableName.valueOf(tableName);
            if (!hadmin.tableExists(TableName.valueOf(tableName))) {
                HTableDescriptor hTableDescriptor = new HTableDescriptor(tm);
                for(String colFa:familyArray){
                    HColumnDescriptor family = new HColumnDescriptor(colFa);
                    family.setMaxVersions(1);
                    hTableDescriptor.addFamily(family);
                }
                if(partionFlag){
                    hadmin.createTable(hTableDescriptor, getSplitKeys());
                }
                else {
                    hadmin.createTable(hTableDescriptor);//不分区
                }
                hadmin.close();
            }
            else {
                log.info("................新建表:"+tableName+"已存在..........................");
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        log.info("................................................create hbase table "+tableName+" successful..........");
    }
    public static  byte[][] getSplitKeys() {
        String[] keys = new String[] {"10|", "20|", "30|", "40|", "50|", "60|", "70|", "80|", "90|" };
        byte[][] splitKeys = new byte[keys.length][];
        TreeSet<byte[]> rows = new TreeSet<byte[]>(Bytes.BYTES_COMPARATOR);//升序排序
        for (int i = 0; i < keys.length; i++) {
            rows.add(Bytes.toBytes(keys[i]));
        }
        Iterator<byte[]> rowKeyIter = rows.iterator();
        int i=0;
        while (rowKeyIter.hasNext()) {
            byte[] tempRow = rowKeyIter.next();
            rowKeyIter.remove();
            splitKeys[i] = tempRow;
            i++;
        }
        return splitKeys;
    }
    /**
     提前创建预分区。划分10个区域，预计100数据量，每个分区10
     *      *用户id小于10的都划分在“00”
     *      *用户id大于10且小于20的都划分在“10区域”
     *     依次类推.....
     *     rowkey的策略:
     *     分区编号(根据用户id所在划分的分区编号获得，见上面解释)+"-u"+u.getUserId();
     */
    public  static void batchPutIndex(Table hTable) {
        List<Put> list = new ArrayList<Put>();
        for (int i = 1; i <= 100; i++) {
            String regionNo="00";
           regionNo= getRegionNo(i,regionNo);
            String k=i+"";
            if(k.length()<3){
                StringBuffer sb=new StringBuffer();
                for(int m=0;m<3-k.length();m++){
                    sb.append("0");
                }
                k=sb.toString()+k;
            }
            byte[] rowkey = Bytes.toBytes(regionNo +"-u"+k);
            Put put = new Put(rowkey);
            put.addColumn("index-rw".getBytes(), "info".getBytes(), Bytes.toBytes("zs" + i));
            list.add(put);
        }
        try {
            hTable.put(list);
        } catch (IOException e) {
            e.printStackTrace();
        }
        list.clear();
        log.info("添加数据成功..........................");
    }
    public static String getRegionNo(int i,String regionNo){
        if(i<10){
            regionNo="00";
        }
        else if(i>=10&&i<20){
            regionNo="10";
        }
        else if(i>=20&&i<30){
            regionNo="20";
        }
        else if(i>=30&&i<40){
            regionNo="30";
        }
        else if(i>=50&&i<60){
            regionNo="40";
        }
        else if(i>=50&&i<60){
            regionNo="50";
        }
        else if(i>=60&&i<70){
            regionNo="60";
        }
        else if(i>=70&&i<80){
            regionNo="70";
        }
        else if(i>=80&&i<90){
            regionNo="80";
        }
        else{
            regionNo="90";
        }
        return regionNo;
    }
    /**
     * #创建表，提前创建预分区。划分10个区域
     * 用户id末位为0的都划分在“10|”
     *用户id末位为1的都划分在“10|-20|”
     *用户id末位为2的都划分在“20|-30|”
     *
     * #设计rowkey
     * rowkey=分区号(userId的最后一位+补充0,组成两位数)-注册时间的时间戳(13位)-u+userId(按千万量计算，加前缀u，共9位)
     * rowkey的长度=2+1+13+1+9=26位
     * @param hTable
     */
    public  static void batchPut(Table hTable) {
        List<Put> list = new ArrayList<Put>();
        for (int i = 1; i <= 10000; i++) {
              String k=i+"";
              if(k.length()<6){
                  StringBuffer sb=new StringBuffer();
                  for(int m=0;m<6-k.length();m++){
                      sb.append("0");
                  }
                  k=sb.toString()+k;
              }
              String n=k.substring(k.length()-1);
              n=n+"0";//分区号(userId的最后一位+补充0,组成两位数)
            byte[] rowkey = Bytes.toBytes(n +  "-" +System.currentTimeMillis()+"-u"+k);//分区号(userId的最后一位+补充0,组成两位数)
            Put put = new Put(rowkey);
            put.addColumn("index-rw".getBytes(), "info".getBytes(), Bytes.toBytes("zs" + i));
            list.add(put);
        }
        try {
            hTable.put(list);
        } catch (IOException e) {
            e.printStackTrace();
        }
        list.clear();
        log.info("添加数据成功..........................");

    }
    private static String getRandomNumber(){

        String ranStr = Math.random()+"";

        int pointIndex = ranStr.indexOf(".");

        return ranStr.substring(pointIndex+1, pointIndex+3);

    }
    /**
     * scan 设置查询条件的模糊查询
     * @param hTable
     * @throws IOException
     */
    private static void scanRecordByParam(Table hTable,String startRow) throws IOException {
        Scan scan = new Scan();
        //scan.addColumn(Bytes.toBytes("cf"),Bytes.toBytes("name"));
        scan.setStartRow(Bytes.toBytes("90-000000-1563011905980"));
        scan.setStopRow(Bytes.toBytes("90-009939-1563011905981"));
        Filter filter2 = new RowFilter(CompareFilter.CompareOp.GREATER,new RegexStringComparator(".*-1563011905970"));//90-009979
        Filter filter3 = new RowFilter(CompareFilter.CompareOp.LESS,new RegexStringComparator(".*-1563011905981"));//90-009979
       // Filter mFilter = new PrefixFilter(Bytes.toBytes("90-009829"));//通过用户id查询
        Filter isf=new InclusiveStopFilter(Bytes.toBytes("80-009839-1563011905979"));//OK包含了扫描的上限在结果之内
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
       filterList.addFilter(filter2);
        filterList.addFilter(filter3);
        List<Long> list = new ArrayList<Long>();
        list.add(1563011905970L);
        list.add(1563011905981L);
        TimestampsFilter filter = new TimestampsFilter(list);
     //  scan.setFilter(filterList);
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
              //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }

        }
    }



    /**
     * scan 设置时间范围查询
     * @param hTable
     * @throws IOException
     */
    private static void scanByRangeQuery(Table hTable,String startRow,String endRow) throws IOException {
        Scan scan = new Scan();
        scan.setStartRow(Bytes.toBytes(startRow));//范围查询
        scan.setStopRow(Bytes.toBytes(endRow));
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }
        }
    }
    /**
     * scan 设置时间范围查询
     * @param hTable
     * @throws IOException
     */
    private static void scanByRangeTimeQuery(Table hTable,String startRow,String endRow) throws IOException {
        Scan scan = new Scan();
        scan.setStartRow(Bytes.toBytes(startRow));//范围查询
        scan.setStopRow(Bytes.toBytes(endRow));
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }
        }
    }
    /**
     * scan 前缀过滤器
     * @param hTable
     * @throws IOException
     */
    private static void scanByPrefixQuery(Table hTable,String prefix) throws IOException {
        Scan scan = new Scan();
        Filter filter = new PrefixFilter(Bytes.toBytes(prefix));
        scan.setFilter(filter);
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }
        }
    }
    /**
     * scan 正则过滤器，根据用户id查询用户
     * 提取rowkey以01结尾数据
     * Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator(".*01$"));
     * 提取rowkey以包含201407的数据
     * Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL,new SubstringComparator("201407"));
     * 提取rowkey以123开头的数据
     * Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL,new BinaryPrefixComparator("123".getBytes()));
     * @param hTable
     * @throws IOException
     */
    private static void scanByRegexFilter(Table hTable,String userId) throws IOException {
        Scan scan = new Scan();
        Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator(".*-"+userId));//查询uid
        scan.setFilter(filter);
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }

        }
    }
    /**
     * scan 包含过滤器
     * @param hTable
     * @throws IOException
     */
    private static void scanByContainsFilter(Table hTable,String startRow,String param) throws IOException {
        Scan scan = new Scan();
        Filter filter = new RowFilter(CompareFilter.CompareOp.NO_OP,new SubstringComparator(param));
        scan.setFilter(filter);
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }

        }
    }
    /**
     * scan 通过rowkey过滤器进行查看
     * @param hTable
     * @throws IOException
     */
    private static void scanByRowKeyFilter(Table hTable,String rowKey) throws IOException {
        Scan scan = new Scan();
        Filter filter=new RowFilter(CompareFilter.CompareOp.GREATER_OR_EQUAL,new BinaryComparator(Bytes.toBytes(rowKey)));//OK筛选出匹配的所有的行
        scan.setFilter(filter);
        ResultScanner scanner = hTable.getScanner(scan);
        for (Result result : scanner) {
            System.out.println("rowKey:"+new String(result.getRow()));
            for (Cell cell : result.rawCells()) {
                //  System.out.println("列族:"+new String(CellUtil.cloneFamily(cell))+ " 列:"+new String(CellUtil.cloneQualifier(cell))+ " 值:"+new String(CellUtil.cloneValue(cell)));
            }

        }
    }



}

 

健康平安的活着
关注
专栏目录
hbase 按时刻查询_Hbase查询工具类，根据时间查询数据
weixin_39560066的博客
12-28 1850
1，需求：已知空气监测数据在hbase中存储，要求按照时间，查询citycode为110000(北京)一个月的数据，数据为每日的监测数据ID ,CITYCODE,SO2 ,CO,NO2 ,O3, PM10,PM2_5,AQI,MEASURE, TIMEPOINT13110000020141120, 110000,31,3.939,141,8,368,301,351,6,2014-11-20511...
HBase
helloworld999999的博客
01-21 3701
一、初始HBase 1.1 HBase简介 1.1.1 HBase是什么 HBase是Goole的BigTable论文而来，是一个分布式海量列示非关系型数据库系统，可以提供超大规模数据集的实时随机读写。 认识HBase列存储 如下是MySql存储机制，空值字段浪费存储空间 如果是列存储的话： 列存储的优点： 1.减少存储空间的占用。 ...
HBase中的时空查询
03-20
HBase中的时空查询
hbase时间范围分页查询优化实践
weixin_44883450的博客
01-18 3243
生产情况 生产情况介绍 汽车故障码明细数据量大（PB级），明细数据存储在hbase中，早期产品的需求主要是根据查询某车某天的故障情况，所以rowkey的设计规则是：tuid+日期+控制器+故障码编号+时间戳，这样，相安无事。现在需求是，查指定TUID的某段时间的明细数据，时间跨度不超过7天，查询条件精确到秒，接口返回时间不超过1秒。 方案设计 初始方案是，由于无法保障数据在同一个resion中，所以不能用Hbase原生的PageFilter进行过滤scan,考虑构建FilterList, 采用startRo
了解Hbase，只看这一篇足以
最新发布
qq_27740127的博客
08-27 2736
文章目录1、关于HBase1.1、Hbase是什么？1.2、HBase的数据结构1.3、HBase的基础架构1.4、HBase适用场景2.HBase安装2.1、实验环境与前置软件2.2、安装Zookeeper2.3、安装HBase2.4、搭建HBase集群模式3、HBase基础操作3.1、基础指令3.1.1、使用HBase的客户端3.1.2、基础的表操作3.1.3、数据操作3.2、HBase的数据结构4、HBase原理4.1、HBase文件读写框架4.2、HBase写数据流程4.3、HBase读数据流程4.
hbase数据读取优化_HBase读写优化
weixin_39928003的博客
12-19 132
一个系统上线之后，开发和调优将一直贯穿系统的生命周期中，HBase也不列外。这里学习下HBase的调优Hbase查询优化作为NoSQL数据库，增删改查是其最基本的功能，其中查询是最常用的一项。设置Scan缓存HBase中Scan查询可以设置缓存，方法是setCaching()，这样可以有效的减少服务端与客户端的交互，更有效的提升扫描查询的性能。/*** Set the number of rows...
Hbase查询工具类，根据时间查询数据
chongzhusong1067的博客
06-11 1695
1，需求：已知空气监测数据在hbase中存储，要求按照时间，查询citycode为110000（北京）一个月的数据，数据为每日的监测数据 ID ,CITYCODE,SO2 ,CO,NO2 ,O3, PM10,PM2_5,AQI,MEASURE, TIMEPOINT 131100000201...
亿流量大考（4）：自研ES+HBase+纯内存的高性能毫秒级查询引擎
石杉的架构笔记
08-05 1046
这篇文章继续来聊一下百亿级别的海量数据场景下还要支撑每秒十万级别的高并发查询，这个架构该如何演进和设计？
Hbase倾斜优化实践
天道不一定酬勤，但天道只会酬勤
09-22 861
Hbase 作为一个分布式的、多版本的开源 KV 数据库，面对大数据也能提供随机的、实时的读写性能。那么，性能如此强大的 Hbase，内部的数据存储结构是怎样设计的呐？基于其存储结构，其读写过程又是怎样的呐？难道 Hbase 就没有弊端了吗？在实践中我们如何去应用 Hbase？接下来我们将一步一步揭开这些问题的面纱。
HBase架构——详解
hujieliang123的博客
03-01 3222
HBase详解 HBase读写流程 HBase架构
内含面试|一文搞懂HBase的基本原理
lt_xiaodou的博客
08-30 460
在HBase中，一个表可以有多个列族，一个列族在物理上是存储在一起的，一个列族会对应一个store，在store的内部会存在一个MemStore，其作用并不是为了提升读写速度，而是为了对RowKey进行排序。我们知道，HBase的数据是存储在HDFS上的，而HDFS是不支持修改的，HBase为了按RowKey进行排序，首先会将数据写入MemStore，数据会先在Memstore中整理成LSM树，最后再刷写到HFile上。总之一句话： Memstore的实现目的不是加速数据写入或读取，而是维持数据结构。...
Java中Hbase查询,复杂,条件范围,时间范围,精确查询等等
weixin_45380326的博客
04-28 9270
java中Hbase各种查询 根据列族名,key,范围查询等 网上看到很多Hbase查询,没找到一个相对全面的，这里我来总结一下吧 声明下面conn是什么 public static Connection conn; static{ Configuration conf = HBaseConfiguration.create(); conf.set("hbase.roo...
Java实现 hbase时间段查询模糊匹配
weixin_42376589的博客
07-10 66
Java实现hbase时间段查询模糊匹配教程 作为一名经验丰富的开发者，我将帮助你学习如何在Java中实现hbase时间段查询模糊匹配。下面将分步骤地介绍整个过程，并附上相应的代码和解释。 流程概述 为了帮助你更好地理解，我将整个过程分为几个步骤，并使用表格展示每个步骤需要做什么。 步骤 操作 1 准备hba...
HBase RowKey 设计与查询实践
张普的专栏
04-23 702
RowKey 设计HBase 作为一款分布式的NoSQL数据库，数据的分布根据rowKey range方式来划分，每个Region 存储了一定范围rowKey 的数据， 数据的读写通常情况下需要指定rowKey 来定位到具体的Region 与 RegionServer， 如果大量的请求根据rowKey都打到同一个Region或者很少的Region上，那么这些Region就...
HBase 数据库设计之 RowKey
qq_57063581的博客
04-19 6517
package step1; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.*; import org.apache.hadoop.hbase.ut.
Hbase 某个时间段的多条记录存在一个rowkey中
hfhaozai12的博客
01-12 1210
Case Study - Log Data and Timeseries Data on Steroids This effectively is the OpenTSDB approach. What OpenTSDB does is re-write data and pack rows into columns for certain time-periods. For a det
Hbase的Rowkey设计
《@书山有径%》的博客
12-13 932
Hbase的Rowkey设计
时序数据库InfluxDB学习笔记
ClownG的博客
10-10 1296
时序数据库介绍和使用 1. 基础 1.1 关于时序数据的定义内容 时间序列数据(Time Series Data, TSD),从定义上来说,就是一串按照时间维度索引的数据.这一串数据描述了某个被测量的主题在一个时间范围内的每个时间点上的测量值. 对时序数据进行建模的话，会包含三个重要部分，分别是：主体，时间点和测量值。套用这套模型，你会发现你在日常工作生活中，无时无刻不在接触着这类数据。 如果你是一个股民，某只股票的股价就是一类时序数据，其记录着每个时间点该股票的股价。 如果你是一个运维人员，监控数.
hbase集群集成ntp时间同步
loopeng1的博客
01-13 3254
1. 前言 由于最近搭建的大数据集群多次自动关闭,检查发现是各几点时间不一致导致   2. 流程 --在各个节点安装ntp # yum -y install ntp   --所有节点设置时区, 中国所用时区为 # timedatectl set-timezone Asia/Shanghai   --在master节点更改ntp.conf文件,设置server为其自身,再新增r
Java hbase 表根据时间戳范围进行查询
06-12
在Java中，可以使用HBase API进行表根据时间戳范围进行查询。下面是一个简单的示例代码： ```java import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.hadoop....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值