ElasticSearch

最新推荐文章于 2024-04-27 18:15:40 发布
最新推荐文章于 2024-04-27 18:15:40 发布
阅读量156 收藏
点赞数
分类专栏： 笔记 文章标签： elasticsearch java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42790527/article/details/120454009
版权

简介

Elasticsearch是一个基于Lucene的搜索服务器，他提供了一个分布式全文搜索引擎，基于restful web接口。

Elasticsearch是用Java语言开发的，基于Apache协议的开源项目，是目前最受欢迎的企业搜索引擎。Elasticsearch广泛运用于云计算中，能够达到实时搜索，具有稳定，可靠，快速的特点。

安装

Elasticsearch，Kibana，IKAnalyzer中文分词器。版本要一致

相关概念

  1. Never Realation（近实时）：Elasticsearch是一个近乎实时的搜索平台，这意味着从索引文档到可搜索文档之间只有轻微的延迟（通常是一秒钟）。
  2. Cluster（集群）：集群是一个或多个节点的集合，它们一起保存整个数据，并提供所有节点的联合索引和搜索功能。每个集群都有自己的唯一集群名称，节点通过名称加入集群。
  3. Node（节点）：节点是指属于集群的单个Elasticsearch实例，存储数据并参与集群的索引的搜索功能。可以将节点配置为按集群名称加入特定集群，默认情况下，每个节点都设置为加入一个名为elasticsearch的集群。
  4. Index（索引）：索引是一些具有相似特征的文档集合，类似于Mysql中数据库的概念。
  5. Type（类型）：类型是索引的逻辑类别分区，通常，为具有一组公共字段的文档类型，类似Mysql中表的概念。（在ES6及之后的版本，一个索引只能包含一个类型，ES7中标记为过时的，ES8中将移除Type）。
  6. Document（文档）：文档是可被搜索的基本信息单位，以JSON格式表示，类似于Mysql中的行。
  7. Shards（分片）：当索引存储大量数据时，可能会超出当个节点的硬件设置，为了解决这个问题，ES提供了将索引细分为分片的概念。分片机制赋予了索引水平扩容的能力、并允许跨分片分发和并行化操作，从而提高性能和吞吐量。
  8. Replicas（副本）：在可能出现故障的网络的环境中，需要有一个故障切换机制，ES提供了将索引的分片复制为一个或多个副本的功能，副本在某些节点失效的情况下提供高可用性。

集群状态查看

  1. 查看集群健康状态
GET /_cat/health?v
  1. 查看节点状态
GET /_cat/nodes?v
  1. 查看所有索引信息
GET /_cat/indices?v

索引操作

  1. 创建索引并查看
PUT /customer GET /_cat/indices?v
  1. 删除索引
DELETE /customer

类型操作

  • 查看文档的类型
GET /bank/_mapping

{
  "bank": {
    "mappings": {
      "account": {
        "properties": {
          "account_number": {
            "type": "long"
          },
          "address": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "age": {
            "type": "long"
          },
          "balance": {
            "type": "long"
          },
          "city": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "email": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "employer": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "firstname": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "gender": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "lastname": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "state": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }
  }
}

文档操作

  1. 在索引中添加文档
PUT /customer/doc/1GET
{
    "name":"yanghao"
}

{
  "_index": "customer",
  "_type": "doc",
  "_id": "1",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 3,
  "_primary_term": 1
}
  1. 查看索引中的文档
GET /customer/doc/1

{
  "_index": "customer",
  "_type": "doc",
  "_id": "1",
  "_version": 2,
  "found": true,
  "_source": {
    "name": "yanghao"
  }
}
  1. 修改索引中的文档
POST /customer/doc/1/_update
{
    "doc":{"name":"yanghao dashuaige"}
}

{
  "_index": "customer",
  "_type": "doc",
  "_id": "1",
  "_version": 2,
  "result": "updated",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 4,
  "_primary_term": 1
}
  1. 删除索引中的文档
DELETE /customer/doc/1

{
  "_index": "customer",
  "_type": "doc",
  "_id": "1",
  "_version": 3,
  "result": "deleted",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 2,
  "_primary_term": 1
}
  1. 对索引中的文档执行批量操作
POST /customer/doc/_bulk
{"index":{"_id":"1"}}
{"name":"xiaohong"}
{"index":{"_id":"2"}}
{"name":"xiaoming"}

{
  "took": 45,
  "errors": false,
  "items": [
    {
      "index": {
        "_index": "customer",
        "_type": "doc",
        "_id": "1",
        "_version": 3,
        "result": "updated",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 5,
        "_primary_term": 1,
        "status": 200
      }
    },
    {
      "index": {
        "_index": "customer",
        "_type": "doc",
        "_id": "2",
        "_version": 1,
        "result": "created",
        "_shards": {
          "total": 2,
          "successful": 1,
          "failed": 0
        },
        "_seq_no": 0,
        "_primary_term": 1,
        "status": 201
      }
    }
  ]
}

数据搜索

查询表达式（Query DSL）是一种非常灵活又富有表现力的查询语言，ES使用它可以以简单的JSON接口来实现丰富的搜索功能。

数据准备

  1. 首先导入测试数据，数据结构如下/
{
    "account_number": 0,
    "balance": 16623,
    "firstname": "Bradshaw",
    "lastname": "Mckenzie",
    "age": 29,
    "gender": "F",
    "address": "244 Columbus Place",
    "employer": "Euron",
    "email": "bradshawmckenzie@euron.com",
    "city": "Hobucken",
    "state": "CO"
}
  1. 然后使用批量操作来导入数据（使用Kibana的Dev Tools操作）
POST /bank/account/_bulk
{
  "index": {
    "_id": "1"
  }
}
{
  "account_number": 1,
  "balance": 39225,
  "firstname": "Amber",
  "lastname": "Duke",
  "age": 32,
  "gender": "M",
  "address": "880 Holmes Lane",
  "employer": "Pyrami",
  "email": "amberduke@pyrami.com",
  "city": "Brogan",
  "state": "IL"
}
......省略若干条数据
  1. 导入完成查看索引信息，可以发现bank索引中已经创建了1000条文档

搜索入门

  1. 最简单的搜索
    GET /bank/_search { "query":{ "match_all":{} } }
  2. 分页搜索
GET /bank/_search
{
    "query":{ "match_all":{} },
    "from":0,
    "size":10
}
  1. 搜索排序，使用sort
GET /bank/_search
{
    "query":{ "match_all":{} },
    "sort":{"balance":{"order":"desc"}} #按照balance字段降序
}
  1. 搜索并返回指定字段内容，使用_source 表示
GET /bank/_search
{
    "query":{ "match_all":{} },
    "_source":["account_number","balance"] #只返回account_number，balance字段
}

条件搜索

  1. 条件搜索，使用match表示匹配条件
GET /bank/_search
{
    "query":{
        "match":{
            "account_number":20
        }
    }
}
  1. 文本类型字段的条件搜索，对比上一条可以发现，对于数字类型的字段进行的是精确匹配，而对于文本使用的是模糊匹配
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "_source": [
    "address",
    "account_number"
  ]
}
  1. 短语匹配搜索，使用match_phrase
GET /bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill lane"
    }
  }
}

组合搜索

  1. 组合搜索，使用bool来进行组合，must表示必须同时满足
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
      #同时包含mill lane
        { "match": { "address": "mill" } },
        { "match": { "address": "lane" } }
      ]
    }
  }
}
  1. 组合搜索，使用should，表示只要满足其中一个
GET /bank/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "address": "mill" } },
        { "match": { "address": "lane" } }
      ]
    }
  }
}
  1. 组合搜索，must_not表示必须同时不满足
GET /bank/_search
{
  "query": {
    "bool": {
      "must_not": [
        { "match": { "address": "mill" } },
        { "match": { "address": "lane" } }
      ]
    }
  }
}
  1. 组合搜索，组合must和must_not
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "age": "40" } }
      ],
      "must_not": [
        { "match": { "state": "ID" } }
      ]
    }
  }
}

搜索聚合

  1. 对搜索结果进行聚合，使用aggs表示，类似于Mysql中的group by ，例如对state字段进行聚合，统计出不同state的文档数量。
GET /bank/_search
{
    "size":0,
    "aggs":{
        "group_by_state":{
            "terms":{
                "field":"state.keyword"
            }
        }
    }
}
  1. 嵌套聚合，例如对state进行聚合，统计出不同state的文档数量，再统计出blance的平均值。
GET /bank/_search
{
  "size": 0,
  "aggs": {
    "group_by_age": {
      "terms": {
        "field": "state.keyword"
      }
    },
    "avg_blance": {
      "avg": {
        "field": "age"
      }
    }
  }
}
  1. 对聚合结果进行排序，例如按balance的平均值降序排序
GET /bank/_search
{
  "size": 0,
  "aggs": {
    "group_by_state": {
      "terms": {
        "field": "state.keyword",
        "order": {
          "average_balance": "desc"
        }
      },
      "aggs": {
        "average_balance": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}
  1. 按字段的范围进行分段聚合，例如分段范围为age字段的[20,30] [30,40] [40,50]，之后按gender统计文档个数和balance的平均值。
GET /bank/_search
{
    "size": 0,
    "aggs": {
        "group_by_age": {
            "range": {
                "field": "age",
                "ranges": [
                    {
                        "from": 20,
                        "to": 30
                    },
                    {
                        "from": 30,
                        "to": 40
                    },
                    {
                        "from": 40,
                        "to": 50
                    }
                ]
            },
            "aggs": {
                "group_by_gender": {
                    "terms": {
                        "field": "gender.keyword"
                    },
                    "aggs": {
                        "average_balance": {
                            "avg": {
                                "field": "balance"
                            }
                        }
                    }
                }
            }
        }
    }
}

Spring Boot整合ElasticSearch

使用ElasticSearch-Rest-Client对elasticsearch进行操作

引入依赖：

<dependency>  
    <groupId>org.elasticsearch.client</groupId>  
    <artifactId>elasticsearch-rest-high-level-client</artifactId>  
    <version>7.9.0</version>
</dependency>

因为SpringBoot管理了elasticsearch的依赖版本，所以我们需要指定一下elasticsearch的版本与其一致：

<properties>  
    <elasticsearch.version>7.9.0</elasticsearch.version>
</properties>

然后编写一个配置类，向容器中注册一个操作elasticsearch的组件：

/**
 * @author : yh
 * @date : 2021/8/30 20:35
 */
@Component
@Getter
@Setter
@ConfigurationProperties(prefix = "elasticsearch")
public class EsHostConfig {

    private String[] hostArr;
}

/**
 * 定义RestClient Bean
 *
 * @author : yh
 * @date : 2021/8/30 20:32
 */
@Configuration
public class EsRestClientConfig {

    @Autowired
    private EsHostConfig esHostConfig;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        String[] hostArr = esHostConfig.getHostArr();
        int size = hostArr.length;
        HttpHost[] httpHostArr = new HttpHost[size];
        for (int i = 0; i < size; i++) {
            String[] split = hostArr[i].split(":");
            httpHostArr[i] = new HttpHost(split[0], Integer.parseInt(split[1]), "http");
        }
        return new RestHighLevelClient(RestClient.builder(httpHostArr));
    }
}

接下来我们就可以通过它操作 elasticsearch 了：

@Autowired
private RestHighLevelClient client;

@Data
class User {
    private String name;    
    private Integer age;    
    private String gender;
}
@Test
public void index() throws IOException {    
    IndexRequest indexRequest = new IndexRequest("users");    
    indexRequest.id("1");    
    // indexRequest.source("name","zhangsan","age",20,"gender","男");    
    User user = new User();    
    user.setName("zhangsan");    
    user.setAge(20);    
    user.setGender("男");    
    String json = JSON.toJSONString(user);    
    indexRequest.source(json, XContentType.JSON);    
    // 执行保存操作    
    IndexResponse index = client.index(indexRequest, RequestOptions.DEFAULT);    
    // 响应数据    
    System.out.println(index);
}

RestHighLevelClient提供了非常多的方式用于保存数据，但比较常用的是通过json数据直接保存，首先需要指定索引， IndexRequest indexRequest = new IndexRequest("users"); 指定了users索引，然后指定数据id，接着指定数据值，最后使用client执行保存操作，然后可以拿到响应数据。

elasticsearch的其它简单操作，诸如：更新、删除等，都只需要转换一下调用方法即可，如更新操作，就需要使用client调用update方法，接下来我们看看Java程序该如何实现较为复杂的检索操作。

比如现在想聚合出年龄的分布情况，并求出每个年龄分布人群的平均薪资，就应该这样进行编写：

@Test
    public void aggSearch() throws Exception {
        //创建搜索request
        SearchRequest searchRequest = new SearchRequest("bank");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询条件
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        //统计各个年龄的平均工资
        searchSourceBuilder.aggregation(AggregationBuilders.terms("ageAgg").field("age").subAggregation(AggregationBuilders.avg("balanceAvgAgg").field("balance")));
        //所有人平均工资
        searchSourceBuilder.aggregation(AggregationBuilders.avg("allBalanceAvgAgg").field("balance"));
        //构建request
        SearchRequest request = searchRequest.source(searchSourceBuilder);
        //search
        SearchResponse searchResponse = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        //Aggregations aggregations = searchResponse.getAggregations();
        //Aggregation接口有很多实现类  Avg（平均值）
//        Avg avg = aggregations.get("balanceAgg");
//        System.out.println(avg.getValue());
        Aggregations aggregations = searchResponse.getAggregations();
        Terms ageAgg = aggregations.get("ageAgg");
        List<? extends Terms.Bucket> buckets = ageAgg.getBuckets();
        for (Terms.Bucket bucket : buckets) {//只查出了10条数据
            System.out.println("年龄:" + bucket.getKey());
            System.out.println("人数:" + bucket.getDocCount());
            Avg avg = bucket.getAggregations().get("balanceAvgAgg");
            System.out.println("平均工资:" + avg.getValue());
            System.out.println("=================================");
        }
        Avg avg = aggregations.get("allBalanceAvgAgg");
        System.out.println("所有人平均工资:" + avg.getValue());
    }
  • 最终输出结果
年龄:31
人数:61
平均工资:28312.918032786885
=================================
年龄:39
人数:60
平均工资:25269.583333333332
=================================
年龄:26
人数:59
平均工资:23194.813559322032
=================================
年龄:32
人数:52
平均工资:23951.346153846152
=================================
年龄:35
人数:52
平均工资:22136.69230769231
=================================
年龄:36
人数:52
平均工资:22174.71153846154
=================================
年龄:22
人数:51
平均工资:24731.07843137255
=================================
年龄:28
人数:51
平均工资:28273.882352941175
=================================
年龄:33
人数:50
平均工资:25093.94
=================================
年龄:34
人数:49
平均工资:26809.95918367347
=================================
所有人平均工资:25714.837
yh_124
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
es-head Elasticsearch的可视化操作插件
12-19
es-head是一个针对Elasticsearch的可视化操作插件。它提供了一个便捷的操作工具，可以连接Elasticsearch搜索引擎，并提供可视化的操作页面，对Elasticsearch进行各种设置和数据检索功能的管理。 es-head 插件可以在...
es docker 部署 elasticsearch.yml
03-19
docker run --name elasticsearch7.16.3 -p 127.0.0.1:9200:9200 -p 127.0.0.1:9300:9300 -e "discovery.type=single-node" -v /Users/xingyue/Home/xingyue/学习/工程化/es/elasticsearch.yml:/usr/share/elastic...
SpringBoot 整合 Elasticsearch8.0（最新API——Java API Client for Elasticsearch）—— 2、文档操作
m0_51976820的博客
04-10 3449
SpringBoot 整合 Elasticsearch8.0（最新API——Java API Client for Elasticsearch）—— 2、文档操作
Elastic stack 技术栈学习（十一）—— 京东项目实战
qq_44886213的博客
03-16 3780
一、项目搭建 1.1 新建Module 在上一篇博客使用的empty project里新建一个module。 选spring框架。 命名。（我需要该java版本为8） 选依赖。 finish。 删一下用不到的文件。 1.2 添加依赖、添加静态资源等准备工作 仿照上次测试api使用的spring-es-api模块，把改动的地方直接搬过来。 Elastic stack技术栈学习（九）—— SpringBoot集成ES_玛丽莲茼蒿的博客-CSDN博...
【翻译】Elasticsearch Java API Client 8.13.2 （第四章-使用 Java API 客户端）
最新发布
qq_49444793的博客
04-27 1165
Java API 客户端提供了多种索引数据的方法：您可以提供将自动映射到 JSON 的应用程序对象，也可以提供原始 JSON 数据。在下面的示例中，我们运行一个聚合，为名称与用户提供的文本匹配的产品从产品索引创建价格直方图。要创建此请求，可以方便地为主请求使用构建器对象，并为每个操作使用流畅的 DSL。如果您是 Elasticsearch 的新手，请务必阅读 Elasticsearch 的快速入门，其中提供了很好的介绍。在下面的示例中，我们使用产品的 SKU 作为索引中的文档标识符，在。
ElasticSearch入门学习笔记（三）SpringBoot整合篇
javaScript1997的博客
11-21 1466
一、项目所需 1.1导入依赖 <properties> <java.version>1.8</java.version> <!-- 统一版本 --> <elasticsearch.version>7.6.1</elasticsearch.version> </properties> 导入elasticsearch <dependency> <groupId>org.s
ES BulkRequest 写入索引数据失败排查和解决
小杨互联网
08-18 5529
1，查看我们的索引mapping有没有问题，是不是索引的数据格式导致我们数据写入不进去，基本上百分之九十就是这个问题，但是我们的并不是。我们的日期格式在es是yyyymmdd hhmmss格式但是这里是个时间蹉格式，肯定就不对了，但是你会说我jsonfamart也不行吗？这样也不行，我序列化的时候tostring不行吗，答案是不行的，只有在序列化的时候转换一下。问题场景：1，使用BulkRequest写入索引数据不生效，接口正常返回，索引没有数据。这个错就很明显了我们的时间格式不对对不对，咋解决呢？...
elasticsearch批量导入问题
wsrzsfgst的博客
07-26 709
【代码】elasticsearch批量导入问题。
ElasticSearch高级操作
凉茶铺的博客
04-22 1107
介绍了ElasticSearch的高级操作（使用java代码操作）
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战)
04-18
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战),包含了小狂神讲的东西，特别适合新手学习，笔记保存下来可以多看看。好记性不如烂笔头哦~，ElasticSearch，简称es，es是一个...
elasticSearch(ES)最新版 ik分词插件7.10 elasticsearch-analysis-ik-7.10.0
11-20
elasticSearch(ES) 最新版ik分词插件7.10 elasticsearch-analysis-ik-7.10.0
es-dedupe:用于从Elasticsearch删除重复文档的工具
05-05
ES重迭 用于删除按某些唯一字段（例如--field Uuid ）分组的重复文档的工具。 删除过程包括两个阶段： 汇总查询查找具有相同field值且至少出现2次的文档。 此类文档的一份副本留在ES中，其他副本则通过批量API删除...
es-operator：用于Elasticsearch的Kubernetes运算符
02-04
ES-Operator已通过Elasticsearch 6.x和7.0测试。 这个怎么运作 该操作员通过管理称为ElasticsearchDataSets （EDS）的自定义资源来工作。 它们基本上是StatefulSets的一个薄包装。 一个EDS代表一组普通的Elastic...
ElasticSearch官方测试数据
09-14
ElasticSearch官方测试数据
windows版本ES7.17.3中文分词器elasticsearch-analysis-ik-7.17.3 .zip
02-05
用于elasticsearch7.17.3这个版本的ik中文分词器，考虑到官网有时网络不稳定下载不下来，这里特意上传，方便大家使用； 目录结构如下： config -- 文件夹 plugin-security.policy plugin-descriptor.properties ...
elasticsearch-7.17.6及对应版本IK分词
02-19
elasticsearch-7.17.6及对应版本IK分词 适合人群：elasticsearch初学者 Elasticsearch 是位于 Elastic Stack 核心的分布式搜索和分析引擎。Logstash 和 Beats 有助于收集、聚合和丰富您的数据并将其存储在 Elastic...
ElasticSearch API for JAVA 学习笔记
热门推荐
准提童子的专栏
08-31 1万+
本篇学习笔记来源于ES官方网站的指导文档：ES JAVA API Client Client是一个类，通过这个类可以实现对ES集群的各种操作：Index, Get, Delete , Search，以及对ES集群的管理任务。 Client的构造需要基于TransportClient TransportClient TransportClient可以远程连接ES集群，通过一个传输模块，但是
踩坑日志之elasticSearch
qq_39397165的博客
01-16 277
前言上周六马上就下班了，正兴高采烈的想着下班吃什么呢！突然QA找到我，说我们的DB与es无法同步数据了，真是令人头皮发秃，好不容易休一天，啊啊啊，难受呀，没办法，还是赶紧找bug吧。下面...
Elasticsearch es Mapping
05-26
Elasticsearch Mapping 是指索引（index）中的字段映射（mapping），它定义了文档中每个字段的数据类型和如何存储数据。Mapping 是 Elasticsearch 中非常重要的概念，因为它定义了如何解析和索引文档。 在 Elasticsearch 中，Mapping 分为两种类型：静态 Mapping 和动态 Mapping。 静态 Mapping 是在创建索引时定义的，它指定了所有字段的数据类型和属性。一旦创建了索引，静态 Mapping 就不能再更改。如果想要更改 Mapping，就需要重新创建索引，这会导致数据丢失。 动态 Mapping 是在索引文档时自动创建的，它会根据文档中的字段自动推断数据类型和属性。如果 Elasticsearch 发现一个新的字段，它会自动将其添加到 Mapping 中，并根据字段的数据类型进行设置。 Mapping 有助于优化搜索性能和提高搜索准确性。正确定义 Mapping 可以使 Elasticsearch 更好地理解文档中的数据，从而更好地执行搜索操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

yh_124

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

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

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

打赏作者

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

抵扣说明：

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

余额充值