Elasticsearch java API (18)Aggregations 聚合 Bucket

最新推荐文章于 2024-08-13 07:03:26 发布
最新推荐文章于 2024-08-13 07:03:26 发布
阅读量1.9w 收藏 11
点赞数 2
分类专栏： Elasticsearch java 文章标签： java api elasticsearch 搜索引擎 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012116196/article/details/51790016
版权

桶聚合编辑

全球聚合编辑

下面是如何使用 Global Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilders
    .global("agg")
    .subAggregation(AggregationBuilders.terms("genders").field("gender"));

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.global.Global;

// sr is here your SearchResponse object
Global agg = sr.getAggregations().get("agg");
agg.getDocCount(); // Doc coun

过滤器聚合编辑

下面是如何使用 Filters Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilders
    .filter("agg")
    .filter(QueryBuilders.termQuery("gender", "male"));

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.filter.Filter;

// sr is here your SearchResponse object
Filter agg = sr.getAggregations().get("agg");
agg.getDocCount(); // Doc count

过滤器聚合编辑

下面是如何使用Filters Aggregation与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
    AggregationBuilders
        .filters("agg")
            .filter("men", QueryBuilders.termQuery("gender", "male"))
            .filter("women", QueryBuilders.termQuery("gender", "female"));

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.filters.Filters

// sr is here your SearchResponse object
Filters agg = sr.getAggregations().get("agg");

// For each entry
for (Filters.Bucket entry : agg.getBuckets()) {
    String key = entry.getKeyAsString();            // bucket key
    long docCount = entry.getDocCount();            // Doc count
    logger.info("key [{}], doc_count [{}]", key, docCount);
}

这将主要生产: 
key [men], doc_count [4982]
key [women], doc_count [5018]

下面是如何使用Missing Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilders.missing("agg").field("gender");

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.missing.Missing;

// sr is here your SearchResponse object
Missing agg = sr.getAggregations().get("agg");
agg.getDocCount(); // Doc count

嵌套式聚合编辑

下面是如何使用Nested Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilders
    .nested("agg")
    .path("resellers");

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.nested.Nested;

// sr is here your SearchResponse object
Nested agg = sr.getAggregations().get("agg");
agg.getDocCount(); // Doc count

反向嵌套式聚合编辑

下面是如何使用Reverse Nested Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
    AggregationBuilders
        .nested("agg").path("resellers")
        .subAggregation(
                AggregationBuilders
                        .terms("name").field("resellers.name")
                        .subAggregation(
                                AggregationBuilders
                                        .reverseNested("reseller_to_product")
                        )
        );

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.nested.Nested;
import org.elasticsearch.search.aggregations.bucket.nested.ReverseNested;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;

// sr is here your SearchResponse object
Nested agg = sr.getAggregations().get("agg");
Terms name = agg.getAggregations().get("name");
for (Terms.Bucket bucket : name.getBuckets()) {
    ReverseNested resellerToProduct = bucket.getAggregations().get("reseller_to_product");
    resellerToProduct.getDocCount(); // Doc count
}

下面是如何使用Children Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
    AggregationBuilders
        .children("agg")
        .childType("reseller");

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.children.Children;

// sr is here your SearchResponse object
Children agg = sr.getAggregations().get("agg");
agg.getDocCount(); // Doc count

从聚合编辑

下面是如何使用Terms Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilders
    .terms("genders")
    .field("gender");

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.terms.Terms;

// sr is here your SearchResponse object
Terms genders = sr.getAggregations().get("genders");

// For each entry
for (Terms.Bucket entry : genders.getBuckets()) {
    entry.getKey();      // Term
    entry.getDocCount(); // Doc count
}

订单编辑

订购他们的桶 doc_count在一个提升的方式:

AggregationBuilders
    .terms("genders")
    .field("gender")
    .order(Terms.Order.count(true))

下令桶按字母顺序的条款以升序的方式: 
AggregationBuilders
    .terms("genders")
    .field("gender")
    .order(Terms.Order.term(true))

订购的桶单值指标sub-aggregation(被聚合的名字): 
AggregationBuilders
    .terms("genders")
    .field("gender")
    .order(Terms.Order.aggregation("avg_height", false))
    .subAggregation(
        AggregationBuilders.avg("avg_height").field("height")
    )

重要术语的聚合编辑

下面是如何使用重要术语的聚合与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .significantTerms("significant_countries")
                .field("address.country");

// Let say you search for men only
SearchResponse sr = client.prepareSearch()
        .setQuery(QueryBuilders.termQuery("gender", "male"))
        .addAggregation(aggregation)
        .get();

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.significant.SignificantTerms;


// sr is here your SearchResponse object
SignificantTerms agg = sr.getAggregations().get("significant_countries");

// For each entry
for (SignificantTerms.Bucket entry : agg.getBuckets()) {
    entry.getKey();      // Term
    entry.getDocCount(); // Doc count
}

聚合范围编辑

下面是如何使用Range Aggregation与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .range("agg")
                .field("height")
                .addUnboundedTo(1.0f)               // from -infinity to 1.0 (excluded)
                .addRange(1.0f, 1.5f)               // from 1.0 to 1.5 (excluded)
                .addUnboundedFrom(1.5f);            // from 1.5 to +infinity

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.range.Range;

// sr is here your SearchResponse object
Range agg = sr.getAggregations().get("agg");

// For each entry
for (Range.Bucket entry : agg.getBuckets()) {
    String key = entry.getKeyAsString();             // Range as key
    Number from = (Number) entry.getFrom();          // Bucket from
    Number to = (Number) entry.getTo();              // Bucket to
    long docCount = entry.getDocCount();    // Doc count

    logger.info("key [{}], from [{}], to [{}], doc_count [{}]", key, from, to, docCount);
}

基本上这将产生第一个例子: 
key [*-1.0], from [-Infinity], to [1.0], doc_count [9]
key [1.0-1.5], from [1.0], to [1.5], doc_count [21]
key [1.5-*], from [1.5], to [Infinity], doc_count [20]

日期范围聚合编辑

下面是如何使用Date Range Aggregation与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .dateRange("agg")
                .field("dateOfBirth")
                .format("yyyy")
                .addUnboundedTo("1950")    // from -infinity to 1950 (excluded)
                .addRange("1950", "1960")  // from 1950 to 1960 (excluded)
                .addUnboundedFrom("1960"); // from 1960 to +infinity

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.range.Range;

// sr is here your SearchResponse object
Range agg = sr.getAggregations().get("agg");

// For each entry
for (Range.Bucket entry : agg.getBuckets()) {
    String key = entry.getKeyAsString();                // Date range as key
    DateTime fromAsDate = (DateTime) entry.getFrom();   // Date bucket from as a Date
    DateTime toAsDate = (DateTime) entry.getTo();       // Date bucket to as a Date
    long docCount = entry.getDocCount();                // Doc count

    logger.info("key [{}], from [{}], to [{}], doc_count [{}]", key, fromAsDate, toAsDate, docCount);
}

这将主要生产: 
key [*-1950], from [null], to [1950-01-01T00:00:00.000Z], doc_count [8]
key [1950-1960], from [1950-01-01T00:00:00.000Z], to [1960-01-01T00:00:00.000Z], doc_count [5]
key [1960-*], from [1960-01-01T00:00:00.000Z], to [null], doc_count [37]

Ip范围聚合编辑

下面是如何使用Ip范围聚合与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .ipRange("agg")
                .field("ip")
                .addUnboundedTo("192.168.1.0")             // from -infinity to 192.168.1.0 (excluded)
                .addRange("192.168.1.0", "192.168.2.0")    // from 192.168.1.0 to 192.168.2.0 (excluded)
                .addUnboundedFrom("192.168.2.0");          // from 192.168.2.0 to +infinity

注意,您还可以使用ip面具范围: 
AggregationBuilder aggregation =
        AggregationBuilders
                .ipRange("agg")
                .field("ip")
                .addMaskRange("192.168.0.0/32")
                .addMaskRange("192.168.0.0/24")
                .addMaskRange("192.168.0.0/16");

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.range.Range;

// sr is here your SearchResponse object
Range agg = sr.getAggregations().get("agg");

// For each entry
for (Range.Bucket entry : agg.getBuckets()) {
    String key = entry.getKeyAsString();            // Ip range as key
    String fromAsString = entry.getFromAsString();  // Ip bucket from as a String
    String toAsString = entry.getToAsString();      // Ip bucket to as a String
    long docCount = entry.getDocCount();            // Doc count

    logger.info("key [{}], from [{}], to [{}], doc_count [{}]", key, fromAsString, toAsString, docCount);
}

基本上这将产生第一个例子: 
key [*-192.168.1.0], from [null], to [192.168.1.0], doc_count [13]
key [192.168.1.0-192.168.2.0], from [192.168.1.0], to [192.168.2.0], doc_count [14]
key [192.168.2.0-*], from [192.168.2.0], to [null], doc_count [23]

和第二个(使用Ip面具): 
key [192.168.0.0/32], from [192.168.0.0], to [192.168.0.1], doc_count [0]
key [192.168.0.0/24], from [192.168.0.0], to [192.168.1.0], doc_count [13]
key [192.168.0.0/16], from [192.168.0.0], to [192.169.0.0], doc_count [50]

直方图聚合编辑

下面是如何使用 Histogram Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .histogram("agg")
                .field("height")
                .interval(1);

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;

// sr is here your SearchResponse object
Histogram agg = sr.getAggregations().get("agg");

// For each entry
for (Histogram.Bucket entry : agg.getBuckets()) {
    Long key = (Long) entry.getKey();       // Key
    long docCount = entry.getDocCount();    // Doc count

    logger.info("key [{}], doc_count [{}]", key, docCount);
}

日期直方图聚合编辑

下面是如何使用Date Histogram Aggregation 与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .dateHistogram("agg")
                .field("dateOfBirth")
                .interval(DateHistogramInterval.YEAR);

如果你想设置一个10天的时间间隔: 
AggregationBuilder aggregation =
        AggregationBuilders
                .dateHistogram("agg")
                .field("dateOfBirth")
                .interval(DateHistogramInterval.days(10));

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.histogram.Histogram

// sr is here your SearchResponse object
Histogram agg = sr.getAggregations().get("agg");

// For each entry
for (Histogram.Bucket entry : agg.getBuckets()) {
    DateTime key = (DateTime) entry.getKey();    // Key
    String keyAsString = entry.getKeyAsString(); // Key as String
    long docCount = entry.getDocCount();         // Doc count

    logger.info("key [{}], date [{}], doc_count [{}]", keyAsString, key.getYear(), docCount);
}

基本上这将产生第一个例子: 
key [1942-01-01T00:00:00.000Z], date [1942], doc_count [1]
key [1945-01-01T00:00:00.000Z], date [1945], doc_count [1]
key [1946-01-01T00:00:00.000Z], date [1946], doc_count [1]
...
key [2005-01-01T00:00:00.000Z], date [2005], doc_count [1]
key [2007-01-01T00:00:00.000Z], date [2007], doc_count [2]
key [2008-01-01T00:00:00.000Z], date [2008], doc_count [3]

地理距离聚合编辑

下面是如何使用 Geo Distance Aggregation与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .geoDistance("agg")
                .field("address.location")
                .point(new GeoPoint(48.84237171118314,2.33320027692004))
                .unit(DistanceUnit.KILOMETERS)
                .addUnboundedTo(3.0)
                .addRange(3.0, 10.0)
                .addRange(10.0, 500.0);

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.range.Range;

// sr is here your SearchResponse object
Range agg = sr.getAggregations().get("agg");

// For each entry
for (Range.Bucket entry : agg.getBuckets()) {
    String key = entry.getKeyAsString();    // key as String
    Number from = (Number) entry.getFrom(); // bucket from value
    Number to = (Number) entry.getTo();     // bucket to value
    long docCount = entry.getDocCount();    // Doc count

    logger.info("key [{}], from [{}], to [{}], doc_count [{}]", key, from, to, docCount);
}

这将主要生产: 
key [*-3.0], from [0.0], to [3.0], doc_count [161]
key [3.0-10.0], from [3.0], to [10.0], doc_count [460]
key [10.0-500.0], from [10.0], to [500.0], doc_count [4925]

地理散列网格聚合编辑

下面是如何使用 Geo Hash Grid Aggregation与Java API。

准备聚合请求编辑

这里有一个例子关于如何创建聚合的要求:

AggregationBuilder aggregation =
        AggregationBuilders
                .geohashGrid("agg")
                .field("address.location")
                .precision(4);

使用聚合反应编辑

导入聚合定义类:

import org.elasticsearch.search.aggregations.bucket.geogrid.GeoHashGrid;

// sr is here your SearchResponse object
GeoHashGrid agg = sr.getAggregations().get("agg");

// For each entry
for (GeoHashGrid.Bucket entry : agg.getBuckets()) {
    String keyAsString = entry.getKeyAsString(); // key as String
    GeoPoint key = (GeoPoint) entry.getKey();    // key as geo point
    long docCount = entry.getDocCount();         // Doc count

    logger.info("key [{}], point {}, doc_count [{}]", keyAsString, key, docCount);
}

这将主要生产: 
key [gbqu], point [47.197265625, -1.58203125], doc_count [1282]
key [gbvn], point [50.361328125, -4.04296875], doc_count [1248]
key [u1j0], point [50.712890625, 7.20703125], doc_count [1156]
key [u0j2], point [45.087890625, 7.55859375], doc_count [1138]
...


thunder࿐
关注
专栏目录
ES java客户端中关于BucketSortPipelineAggregationBuilder的问题
疏影横斜水清浅
01-20 3633
es 聚合后进行分页（非标准分页，涉及到es底层的检索方式） es 桶聚合后排序介绍见ES指南介绍 // kibana对聚合后的数据 GET /_search { "query": { "bool": { "filter": [ { "match": { "question": "好的" } }, { "range": { "c
UnmappedTerms cannot be cast to org.elasticsearch.search.aggregations.bucket.terms.StringTerms
weixin_45935960的博客
03-22 2133
问题 java.lang.ClassCastException: org.elasticsearch.search.aggregations.bucket.terms.UnmappedTerms cannot be cast to org.elasticsearch.search.aggregations.bucket.terms.StringTerms 原因 不能转化为StringTerms for (Map.Entry<String, Aggregation> entry :
Elasticsearch Java API(十一)--聚合(aggregations)
1.02^365=1377.41
02-21 1万+
Elasticsearch分析聚合介绍了分析聚合的REST命令，这篇博客介绍一下如何使用Java API。一、准备数据测试数据请参考我的上一篇博客:Elasticsearch分析聚合。二、需求查询title中包含关键字”程序”的文档，统计查询按编程语言分组，统计每组的文档数量。三、REST命令行REST命令行如下，有三部分，query查询所有title中包含关键词程序的文档，size指定返回结果中文
Elasticsearch 桶（Bucket）聚合详解及示例
最新发布
一起coding，一起嗨。
08-13 436
Elasticsearch 桶（Bucket）聚合详解及示例
Elasticsearch java API Aggregations 聚合 Bucket
Felix_阳的博客
03-04 4467
桶聚合编辑 全球聚合编辑 下面是如何使用 Global Aggregation 与Java API。 准备聚合请求编辑 这里有一个例子关于如何创建聚合的要求: AggregationBuilders .global("agg") .subAggregation(AggregationBuilders.terms("genders").field("ge...
Elasticsearch 5.x Java api Aggregations(聚合)
Zsigner的博客
04-24 818
转自:https://blog.csdn.net/wf787283810/article/details/79035988 Ealsticsearch 5.x Java API聚合string类型的时候，会报错（json的错），则需要在聚合的string类型字段的后面添加.keyword , 虽然使用watch查看聚合的es json的时候会出现以下报错，但是不会影响结果。 { “er...
Java 实现Elasticsearch Aggregations 统计buckets中key的个数
xcl119xcl的专栏
10-17 1578
统计访问超5000的ulr有多少个(sum的最大值会小于等于size，因此size的预估很重要) GET /logstash-2018.03.27/_search? { "size": 0, "aggs": { "all_terms": { "terms": { "field": "url_regex", ...
ElasticSearch Java API 中文文档
01-04
标签《ES Java API 中文文档》强调了文档的内容属性，它属于ElasticSearch的一个重要组成部分，即用Java语言进行数据交互和操作的应用程序接口部分。 从部分内容中可以提取出以下知识点： 1. **Transport Client**...
ElasticSearch 的 聚合（Aggregations）-javaAPI示例
weixin_34292287的博客
05-29 6478
2019独角兽企业重金招聘Python工程师标准>>> ...
java操作es聚合操作并显示其他字段_ElasticSearch Aggregations使用总结详解
weixin_35931648的博客
12-23 4054
1.单字段情况下聚合假设只需要对一个字段聚合，比如b字段，b字段是keyword类型，需要考虑的情况最为简单，当要对b字段聚合时语句很好写，如下即可{"from": 0,"size": 0,"query": {"bool": {"must": [{"bool": {"should": [{"terms": {"field_a": ["1", "2", "3"],"boost": 1.0}}, {"...
ElasticSearch：aggregations 聚合详解
qq_41063182的博客
10-12 8870
概念 ElasticSearch 中聚合的概念，通俗的讲就是将一些数据按照一些条件去统计一些信息，比如统计房间有多少，根据价格区间统计酒店数量这些功能。 官网的解释：聚合可以进行各种组合以构建复杂的数据汇总。可以看作是在一组文档上建立分析信息的工作单元，统计一些文档集。聚合可以将一些独立的功能单元可以被混合在一起来满足你的需求，是一种单独的语法。 kibana的可视化看板就是非常经典的聚合功能的体现。 聚合 ElasticSearch 中有许多不同类型的聚合，每种聚合都有自己的目的和输出，大致有四种基本类
Elasticsearch--javaAPI---桶聚合
lucasmaluping的专栏
11-07 371
1、terms聚合 import cn.hadron.es.AggregationUtil; import org.elasticsearch.search.aggregations.bucket.terms.Terms; public class AggregationDemo { public static void main(String[] args) { Agg...
Java操作elasticSearch复杂查询以及解析数据
Phor的博客
11-05 3750
Java操作elasticSearch复杂查询以及解析数据 es的银行测试库，看一个Kibana操作 然后用java检索解析这个数据 #聚合搜索 address 中包含 mill 的所有人的年龄分布以及平均薪资 GET bank/_search { "query":{ "match": { "address": "mill" } }, "aggs": { "ageAgg": { "terms": { "field": "age",
Elasticsearch学习---聚合查询之Bucket Aggregations
自律使我自由
06-16 502
前言
java之学习记录 9 - 2 - kibana之聚合aggregations
dear_zx的博客
03-27 623
聚合可以让我们极其方便的实现对数据的统计、分析。例如： 什么品牌的手机最受欢迎？ 这些手机的平均价格、最高价格、最低价格？ 这些手机每月的销售情况如何？ 实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。 1 基本概念 Elasticsearch中的聚合，包含多种类型，最常用的两种，一个叫 桶 ，一个叫 度量： 桶（bucket） 类似于 group by 桶的作用，是按照某种方式对数据进行分组，每一组数据在ES中称为一个 桶 ，例如我们根据国
平铺es聚合的数据
一路向前
09-03 1079
平铺RestHighLevelClient请求到的es聚合的数据 目录 处理思路： 代码： 1，值的处理 2，获取值： 3，结果： 总结： 使用Java请求es聚合数据，使用RestHighLevelClient 进行es聚合请求查询，获取到了数据，从例子中，可以看出数据也是不断嵌套的，如果平铺数据呢？ 处理思路： 在处理值的时候，跟处理参数的时候相似。先处理简单的，再处理复杂的，逐层解析。把常见的例子都请求一遍，比如terms请求的时候，可能有字符型，有数值型的。 range.
JAVA解析ES聚合查询数据结构aggregations关键字
Remember__Peng的博客
07-23 5638
在项目开发中, 有需求需要解析ES的聚合查询结果, 但是没找到有相关内容, 就自己写了一个解析逻辑, 下面贴上代码, 各位复制即可. ES聚合查询结果示例 [各位可以看看是不是你们目前需要解析的场景]: { "took" : 1, "timed_out" : false, "_shards" : { "total" : 15, "successful" : 15, "skipped" : 0, "failed" : 0 }, "hits" : {
ElasticSearch6.x 基于SpringBoot 实现ElasticSearch之分组统计查询
zhouzhiwengang的专栏
07-26 5286
AggregationUtil.java中添加如下方法， /** * 分组统计 * @param index 索引 * @param field 文档属性 * @return */ public Terms terms(String index,String field){ String name = "ter...
【ElasticSearch实战】——java操作ES基本查询在项目中应用
热门推荐
Jack 架构师之路
10-24 17万+
引言 最近小编负责的一个语音质检 项目中用到了ES，下面结合实例代码分享一下java操作ES查用的查询写法。 关于es的基本操作，例如新建索引、查询封装类，请参考前面博客：【ElasticSearch实战】——封装java操作es基础架构 1、ES在项目中的位置 2、项目查询需求 从上面查询条件来看，其中包括了精确查询，模糊查询及时间范围查询等，这些...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值