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

最新推荐文章于 2022-04-23 08:16:20 发布
最新推荐文章于 2022-04-23 08:16:20 发布
阅读量7.7k 收藏 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)));
            }

        }
    }



}

 

健康平安的活着
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hbase 按时刻查询_Hbase查询工具类，根据时间查询数据
weixin_39560066的博客
12-28 1792
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数据读取优化_HBase读写优化
weixin_39928003的博客
12-19 112
一个系统上线之后，开发和调优将一直贯穿系统的生命周期中，HBase也不列外。这里学习下HBase的调优Hbase查询优化作为NoSQL数据库，增删改查是其最基本的功能，其中查询是最常用的一项。设置Scan缓存HBase中Scan查询可以设置缓存，方法是setCaching()，这样可以有效的减少服务端与客户端的交互，更有效的提升扫描查询的性能。/*** Set the number of rows...
Hbase查询工具类，根据时间查询数据
chongzhusong1067的博客
06-11 1663
1，需求：已知空气监测数据在hbase中存储，要求按照时间，查询citycode为110000（北京）一个月的数据，数据为每日的监测数据 ID ,CITYCODE,SO2 ,CO,NO2 ,O3, PM10,PM2_5,AQI,MEASURE, TIMEPOINT 131100000201...
hbase时间范围分页查询优化实践
weixin_44883450的博客
01-18 3133
生产情况 生产情况介绍 汽车故障码明细数据量大（PB级），明细数据存储在hbase中，早期产品的需求主要是根据查询某车某天的故障情况，所以rowkey的设计规则是：tuid+日期+控制器+故障码编号+时间戳，这样，相安无事。现在需求是，查指定TUID的某段时间的明细数据，时间跨度不超过7天，查询条件精确到秒，接口返回时间不超过1秒。 方案设计 初始方案是，由于无法保障数据在同一个resion中，所以不能用Hbase原生的PageFilter进行过滤scan,考虑构建FilterList, 采用startRo
Java中Hbase查询,复杂,条件范围,时间范围,精确查询等等
weixin_45380326的博客
04-28 8940
java中Hbase各种查询 根据列族名,key,范围查询等 网上看到很多Hbase查询,没找到一个相对全面的，这里我来总结一下吧 声明下面conn是什么 public static Connection conn; static{ Configuration conf = HBaseConfiguration.create(); conf.set("hbase.roo...
hbase用于查询客户端工具
03-22
HBase是一种分布式、基于列族的NoSQL数据库，它在大数据领域中扮演着重要的角色，尤其是在需要实时查询大规模数据集时。HBase以其高吞吐量、低延迟和水平扩展能力而闻名，常用于存储非结构化和半结构化数据。在HBase...
Hbase行键设计（rowkey）实现多条件查询
01-27
在HBase中，行键（RowKey）的设计是至关重要的，因为它直接影响到数据的存取效率和查询性能。HBase是一种分布式、列式存储的NoSQL数据库，它以Key-Value的形式存储数据，并且主要依赖RowKey进行快速定位。由于HBase...
HBase高性能复杂条件查询引擎
02-21
TedYu对“查询决策器”表示了关心，他指出类似的组件同时也是Phoenix,Impala用于支持SQL查询的核心组件，但是这类组件很难引入到HBase中，因为HBase专注于byte[]的操作。对此，方案在设计时避开了“SQL解析”和“在...
hbase分页查询实现.pdf
07-14
HBase分页查询实现 HBase作为一个NoSQL数据库，具有高性能、高可扩展性和高可靠性等特点，但是在查询方面却存在一些限制，例如不支持分页查询。这就使得开发者需要自己实现分页查询功能。本文将讲解如何使用Java...
hbase java api 访问 查询、分页
11-24
在HBase这个分布式列式数据库中，Java API是开发者常用的一种接口来操作HBase，包括创建表、插入数据、查询数据以及实现分页等操作。本文将深入探讨如何使用HBase Java API进行数据访问和分页查询。 首先，我们要...
HBase中的时空查询
03-20
HBase中的时空查询
实验三：熟悉常用的HBase操作
05-05
总的来说，实验三旨在使你熟悉HBase的基本操作，包括使用Shell命令和Java API。掌握这些技能后，你将能够更有效地在大数据环境中管理和操作数据。在实际工作中，HBase常用于实时查询和大数据分析，是许多大型互联网...
robotframework通过phoenix查询Hbase数据
10-13
robotframework自动化测试时，用到查询Hbase数据，没找到适合的库，自己写了个自定义关键字，基于python27的环境，里面关键字只涉及到查询语句，并有环境配置搭建及运用关键字说明，在实际中也经常遇到，分享出来，...
大数据实验三-HBase编程实践
04-03
一．实验内容 HBase编程实践： 1）在Hadoop基础上安装HBase； 2）使用Shell命令（create:创建表 ...三．实验过程截图及说明 1、安装HBase （1）解压HBase文件到/usr/local目录下，并将目录改名为hbase：
elasticsearch+hbase海量数据查询
最新发布
06-26
elasticsearch+hbase海量数据查询,支持千万数据秒回查询 一、ElasticSearch和Hbase ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch...
HBase RowKey 设计与查询实践
张普的专栏
04-23 677
RowKey 设计HBase 作为一款分布式的NoSQL数据库，数据的分布根据rowKey range方式来划分，每个Region 存储了一定范围rowKey 的数据， 数据的读写通常情况下需要指定rowKey 来定位到具体的Region 与 RegionServer， 如果大量的请求根据rowKey都打到同一个Region或者很少的Region上，那么这些Region就...
HBase 数据库设计之 RowKey
qq_57063581的博客
04-19 6285
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 1189
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
时序数据库InfluxDB学习笔记
ClownG的博客
10-10 1241
时序数据库介绍和使用 1. 基础 1.1 关于时序数据的定义内容 时间序列数据(Time Series Data, TSD),从定义上来说,就是一串按照时间维度索引的数据.这一串数据描述了某个被测量的主题在一个时间范围内的每个时间点上的测量值. 对时序数据进行建模的话，会包含三个重要部分，分别是：主体，时间点和测量值。套用这套模型，你会发现你在日常工作生活中，无时无刻不在接触着这类数据。 如果你是一个股民，某只股票的股价就是一类时序数据，其记录着每个时间点该股票的股价。 如果你是一个运维人员，监控数.
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、付费专栏及课程。

余额充值