Java使用ElasticSearch 7.x以上客户端 常用API

已于 2022-07-15 10:17:14 修改
阅读量1.2k 收藏 5
点赞数
文章标签： elasticsearch java 搜索引擎
于 2022-07-15 10:12:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42511655/article/details/125798023
版权
依赖
		<dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.1.2</version>
            <exclusions>
                <exclusion>
                    <groupId>jakarta.json</groupId>
                    <artifactId>jakarta.json-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>
创建客户端
try {
            RestClientTransport restClientTransport;
            if (elasticConfig==null){
                RestClient build = RestClient.builder(new HttpHost("localhost",9200)).build();
                restClientTransport = new RestClientTransport(build, new JacksonJsonpMapper());
            }else{
                if (StringUtils.hasText(elasticConfig.getUsername())&&StringUtils.hasText(elasticConfig.getPassword())){
                    // 创建用户名密码认证
                    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                    credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials(elasticConfig.getUsername(), elasticConfig.getPassword()));
                    RestClient build = RestClient.builder(new HttpHost(elasticConfig.getHost(),elasticConfig.getPort())).setHttpClientConfigCallback(k->k.setDefaultCredentialsProvider(credentialsProvider)).build();
                    restClientTransport = new RestClientTransport(build, new JacksonJsonpMapper());
                }else{
                    RestClient build = RestClient.builder(new HttpHost(elasticConfig.getHost(),elasticConfig.getPort())).build();
                    restClientTransport = new RestClientTransport(build, new JacksonJsonpMapper());
                }
            }
            return new ElasticsearchClient(restClientTransport);
        }catch (Exception e){
            log.error("ElasticUtils-elasticJavaClient",e);
            return null;
        }

elasticConfig 是我自定义的一个类

@Data
public class ElasticConfig {
    private String host;
    private Integer port;
    private String username;
    private String password;
    private String index;
}
创建索引
 /**
     * 创建索引
     * @param client ES客户端
     * @param indexName 索引名称
     */
    public static boolean createIndex(ElasticsearchClient client,String indexName){
        //定义文档属性
        Map<String, Property> propertyMap = new HashMap<>();
        propertyMap.put("id",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("name",new Property(new TextProperty.Builder().analyzer("ik_max_word").searchAnalyzer("ik_smart").build()));
        propertyMap.put("path",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("url",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("md5",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("size",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("dir",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("extendName",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("source",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("isDelete",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("createTime",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("updateTime",new Property(new KeywordProperty.Builder().build()));
        propertyMap.put("content",new Property(new TextProperty.Builder().build()));
        propertyMap.put("hitTime",new Property(new TextProperty.Builder().build()));
        // 设置索引的文档类型映射
        TypeMapping typeMapping = new TypeMapping.Builder()
                .properties(propertyMap)
                .build();
        CreateIndexRequest request = new CreateIndexRequest.Builder()
                .index(indexName)
                .mappings(typeMapping)
                .build();
        try {
            CreateIndexResponse createIndexResponse = client.indices().create(request);
            Boolean acknowledged = createIndexResponse.acknowledged();
            return acknowledged != null && acknowledged;
        }catch (IOException e){
            log.error("ElasticUtils-createIndex::{}",e.getMessage(),e);
            return false;
        }
    }

Map<String, Property> propertyMap 定义文档属性 对应的是以前的Mapping
TypeMapping typeMapping = new TypeMapping.Builder() 设置Mapping
CreateIndexRequest request = new CreateIndexRequest.Builder() 新建一个 “创建索引”的请求构造器
index: 索引名称
client.indices().create(request): 发送创建索引请求

删除索引
    /**
     * 删除索引
     * @param client ES客户端
     * @param indexName 索引名称
     */
    public static boolean delIndex(ElasticsearchClient client,String indexName){
        try {
            DeleteIndexResponse deleteIndexResponse = client.indices().delete(d -> d.index(indexName));
            return deleteIndexResponse.acknowledged();
        }catch (IOException e){
            log.error("ElasticUtils-delIndex::{}",e.getMessage(),e);
            return false;
        }
    }
添加文档
    /**
     * 添加文档
     * @param client ES客户端
     * @param document 文档
     * @return boolean
     */
    public static boolean addDoc(ElasticsearchClient client, FileDocument document,ElasticConfig elasticConfig){
        IndexRequest<FileDocument> request = new IndexRequest.Builder<FileDocument>()
                .index(elasticConfig.getIndex())
                // 设置文档id
                .id(document.getId()+"")
                // 设置文档
                .document(document)
                // 刷新
                .refresh(Refresh.True)
                .build();
        try {
            IndexResponse response = client.index(request);
            System.out.println(response.result().jsonValue());
            return response.result()!=null;
        }catch (IOException e){
            log.error("ElasticUtils-addDoc::{}",e.getMessage(),e);
            return false;
        }
    }
批量添加文档
public static boolean addBatchDoc(ElasticsearchClient client,String indexName, List<FileDocument> list){
        List<BulkOperation> operations = new ArrayList<>();
        for (FileDocument item : list) {
            IndexOperation<FileDocument> indexOperation = new IndexOperation.Builder<FileDocument>()
                    .index(indexName)
                    .id(item.getId().toString())
                    .document(item)
                    .build();
            BulkOperation bulk = new BulkOperation.Builder()
                    .index(indexOperation)
                    .build();
            operations.add(bulk);
        }
        BulkRequest request = new BulkRequest.Builder()
                .index(indexName)
                .operations(operations)
                .build();
        try {
            BulkResponse bulk = client.bulk(request);
            for (BulkResponseItem item : bulk.items()) {
                System.out.println(item.result());
            }
            return bulk.items().size()>0;
        }catch (IOException e){
            log.error("ElasticUtils-addDoc::{}",e.getMessage(),e);
            return false;
        }
    }
判断文档是否存在
    public static boolean existDoc(ElasticsearchClient client,String indexName,String id){
        ExistsRequest request = new ExistsRequest.Builder()
                .index(indexName)
                .id(id)
                .build();
        try {
            BooleanResponse exists = client.exists(request);
            return exists.value();
        }catch (IOException e){
            log.error("ElasticUtils-existDoc::{}",e.getMessage(),e);
            return false;
        }
    }
根据id查询文档
    public static FileDocument searchDoc(ElasticsearchClient client,String indexName,String id){
        GetRequest request = new GetRequest.Builder()
                .index(indexName)
                .id(id)
                .build();
        try {
            GetResponse<FileDocument> fileDocumentGetResponse = client.get(request, FileDocument.class);
            return fileDocumentGetResponse.source();
        }catch (IOException e){
            log.error("ElasticUtils-searchDoc::{}",e.getMessage(),e);
            return null;
        }
    }
复杂查询
public static PageResult<FileDocument> searchDoc(Integer pageNum, Integer pageSize,ElasticsearchClient client,String indexName,String keyword,String path,Boolean isDelete,String startTime,String endTime){
        //检查es是否有这个索引
        if (!ElasticUtils.existsIndex(client,indexName)) {
            return null;
        }
        PageResult<FileDocument> pageResult = new PageResult<>();
        List<FileDocument> list = new ArrayList<>();
        BoolQuery.Builder boolQueryBuilder = new BoolQuery.Builder();
        if (StringUtils.hasText(keyword)){
            Query fuzzyQuery1 = FuzzyQuery.of(f -> f.field("name").value(keyword))._toQuery();
            Query matchQuery1 = MatchQuery.of(m -> m.field("name").query(keyword).boost(2f))._toQuery();
            BoolQuery boolQuery1 = new BoolQuery.Builder()
                    .should(fuzzyQuery1)
                    .should(matchQuery1)
                    .build();
            Query fuzzyQuery2 = FuzzyQuery.of(f -> f.field("content").value(keyword))._toQuery();
            Query matchQuery2 = MatchQuery.of(m -> m.field("content").query(keyword).boost(2f))._toQuery();
            BoolQuery boolQuery2 = new BoolQuery.Builder()
                    .should(fuzzyQuery2)
                    .should(matchQuery2)
                    .build();
            BoolQuery boolQuery3 = new BoolQuery.Builder()
                    .should(boolQuery1._toQuery())
                    .should(boolQuery2._toQuery())
                    .build();
            boolQueryBuilder.must(boolQuery3._toQuery());
        }else{
            boolQueryBuilder.must(q->q.matchAll(new MatchAllQuery.Builder().build()));
        }
        BoolQuery.Builder boolQuery4Builder = new BoolQuery.Builder();
        boolQuery4Builder.must(q->q.term(t->t.field("isDelete").value(isDelete)));
        if (StringUtils.hasText(path)){
            boolQuery4Builder.must(q->q.term(t->t.field("dir").value(path)));
        }
        if (StringUtils.hasText(startTime)){
            RangeQuery rangeQuery = new RangeQuery.Builder()
                    .field("updateTime")
                    .gte(JsonData.of(startTime))
                    .build();
            boolQuery4Builder.must(rangeQuery._toQuery());
        }
        if (StringUtils.hasText(endTime)){
            RangeQuery rangeQuery = new RangeQuery.Builder()
                    .field("updateTime")
                    .lte(JsonData.of(endTime))
                    .build();
            boolQuery4Builder.must(rangeQuery._toQuery());
        }
        BoolQuery boolQuery4 = boolQuery4Builder.build();
        boolQueryBuilder.must(boolQuery4._toQuery());
        BoolQuery boolQuery = boolQueryBuilder.build();
        Query query = boolQuery._toQuery();
        SearchRequest.Builder requestBuilder = new SearchRequest.Builder();
        requestBuilder.index(indexName);
        //设置排序
        SortOptions fieldSort = new SortOptions.Builder().field(k->k.field("updateTime").order(SortOrder.Desc)).build();
        requestBuilder.sort(fieldSort);
        if (pageNum!=null&&pageSize!=null&&pageNum>0&&pageSize>0){
            requestBuilder.from((pageNum-1)*pageSize).size(pageSize);
        }
        requestBuilder.query(query);
        SearchRequest request = requestBuilder.source(k->k.filter(f->f.excludes("content"))).build();
        try {
            SearchResponse<FileDocument> search = client.search(request, FileDocument.class);
            if (search!=null&&search.hits()!=null&&search.hits().total()!=null){
                if (search.hits().hits().size()>0) {
                    for (Hit<FileDocument> hit : search.hits().hits()) {
                        list.add(hit.source());
                    }
                    pageResult.setData(list);
                    pageResult.setTotal(search.hits().total().value());
                }
            }
            pageResult.setCode(200);
        }catch (IOException e){
            e.printStackTrace();
            return null;
        }
        return pageResult;

PageResult: 是自定义的分页结果类
这里使用到了许多查询的条件 主要就是一个个查询构造器
具体怎么使用我这里不赘述 主要是给一个参考。
该方法的功能就是：根据关键字模糊查询文档的“name”属性和“content”属性并且根据isDelete请求查询文档的“isDelete”属性并且根据“dir”精确查询文档的”dir“属性,区间查询createTime和updateTime之间的数据 lt表示小于 gt表示大于，然后根据updateTime排序，最后的结果去掉content属性。
文档类

public class FileDocument {
/**文档主键*/
private Long id;
/**文件名称*/
private String name;
/**文件路径*/
private String path;
/**文件url*/
private String url;
/**文件md5*/
private String md5;
/**文件大小*/
private Long size;
/**文件夹id*/
private Long dir
/**文件后缀名*/
private String extendName;
/**文件服务器*/
private String source;
/**文件是否已删除*/
private Boolean isDelete;
/**文件创建时间*/
private String createTime;
/**文件更新时间*/
private String updateTime;
/**文件内容*/
private String content;
/**文件查询命中时间*/
private String hitTime;
}
删除文档
    /**
     * 删除文档
     * @param client ES客户端
     * @param index 索引名称
     * @param id 文档id
     * @return boolean
     */
    public static boolean delDoc(ElasticsearchClient client,String index,String id){
        DeleteRequest request = new DeleteRequest.Builder()
                .index(index)
                .id(id)
                .build();
        try {
            DeleteResponse delete = client.delete(request);
            System.out.println(delete.result().jsonValue());
            return delete.result()!=null;
        }catch (IOException e){
            log.error("ElasticUtils-delDoc::{}",e.getMessage(),e);
            return false;
        }
    }
批量删除文档
/**
     * 批量删除文档
     * @param client ES客户端
     * @param ids 文档id列表
     * @param elasticConfig ES配置信息
     * @return 操作结果
     */
    public static boolean delDoc(ElasticsearchClient client,List<String> ids,ElasticConfig elasticConfig){
        try {
            List<BulkOperation> operations = new ArrayList<>();
            if (!CollectionUtils.isEmpty(ids)){
                for (String id : ids) {
                    DeleteOperation deleteOperation = new DeleteOperation.Builder()
                            .index(elasticConfig.getIndex())
                            .id(id)
                            .build();
                    BulkOperation operation = new BulkOperation.Builder()
                            .delete(deleteOperation)
                            .build();
                    operations.add(operation);
                }
                BulkRequest request = new BulkRequest.Builder()
                        .index(elasticConfig.getIndex())
                        .operations(operations)
                        .refresh(Refresh.True)
                        .build();
                BulkResponse bulkResponse = client.bulk(request);
                return !CollectionUtils.isEmpty(bulkResponse.items());
            }
            return true;
        }catch (IOException e){
            log.error("ElasticUtils-delDoc::{}",e.getMessage(),e);
            return false;
        }
    }
批量更新文档
/**
     * 更新文档
     * @param client ES客户端
     * @param ids 列表ids
     * @param documents 用于替换的结果
     * @return 修改结果
     */
    public static boolean updateDoc(ElasticsearchClient client,
                                    List<String> ids,
                                    List<FileDocument> documents,
                                    ElasticConfig elasticConfig){
        try {
            List<BulkOperation> operations = new ArrayList<>();
            Map<String, List<FileDocument>> documentsMap = documents.stream().collect(Collectors.groupingBy(k->k.getId().toString()));
            for (String id : ids) {
                List<FileDocument> update = documentsMap.get(id);
                if (!CollectionUtils.isEmpty(update)){
                    UpdateAction<FileDocument,FileDocument> updateAction = new UpdateAction.Builder<FileDocument,FileDocument>()
                            .doc(update.get(0))
                            .build();
                    UpdateOperation<FileDocument,FileDocument> updateOperation = new UpdateOperation.Builder<FileDocument,FileDocument>()
                            .index(elasticConfig.getIndex())
                            .action(updateAction)
                            .id(id)
                            .build();
                    BulkOperation bulk = new BulkOperation.Builder()
                            .update(updateOperation)
                            .build();
                    operations.add(bulk);
                }
            }
            BulkRequest request = new BulkRequest.Builder()
                    .index(elasticConfig.getIndex())
                    .operations(operations)
                    .build();
            BulkResponse bulkResponse = client.bulk(request);
            return !CollectionUtils.isEmpty(bulkResponse.items());
        } catch (IOException e){
            log.error("ElasticUtils-updateDoc::{}",e.getMessage(),e);
            throw new ServiceException("修改ES文档失败!");
        }
    }

更新单个文档 和之前的差不多 这里忽略了。这里是全部替换，下面的是选择属性修改

批量更新文档
/**
     * 更新文档
     * @param client ES客户端
     * @param ids 列表ids
     * @param map 要修改的map
     * @return 修改结果
     */
    public static boolean updateDoc(ElasticsearchClient client,
                                    List<String> ids,
                                    Map<String,Map<String,Object>> map,
                                    ElasticConfig elasticConfig){
        try {
            List<BulkOperation> operations = new ArrayList<>();
            for (String id : ids) {
                Map<String,Object> updateMap = map.get(id);
                if (MapUtils.isNotEmpty(updateMap)){
                    UpdateAction<FileDocument,Map<String,Object>> updateAction = new UpdateAction.Builder<FileDocument,Map<String,Object>>()
                            .doc(updateMap)
                            .build();
                    UpdateOperation<FileDocument,Map<String,Object>> updateOperation = new UpdateOperation.Builder<FileDocument,Map<String,Object>>()
                            .index(elasticConfig.getIndex())
                            .action(updateAction)
                            .id(id)
                            .build();
                    BulkOperation bulk = new BulkOperation.Builder()
                            .update(updateOperation)
                            .build();
                    operations.add(bulk);
                }
            }
            BulkRequest request = new BulkRequest.Builder()
                    .index(elasticConfig.getIndex())
                    .operations(operations)
                    .refresh(Refresh.True)
                    .build();
            BulkResponse bulkResponse = client.bulk(request);
            return !CollectionUtils.isEmpty(bulkResponse.items());
        } catch (IOException e){
            log.error("ElasticUtils-updateDoc::{}",e.getMessage(),e);
            throw new ServiceException("修改ES文档失败!");
        }
    }
春树待樱甚良
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ElasticSearch Java API 中文文档
01-04
ElasticSearch Java API 中文文档 ElasticSearch Java API 中文文档
ElasticSearch7.x基于Java API 快照备份和恢复
m0_67393295的博客
03-25 1244
快照备份 1. 配置es环境 我这里用的是windowns版本的，在es官网下载压缩包 https://www.elastic.co/cn/downloads/elasticsearch 解压后在connfig找到elasticsearch.yml进行以下配置修改 服务名称 cluster.name: my-application 节点名称 node.name: node-1 快照本地路径 path.repo: [E:/es/data] 地址network.host: localhost 端口 http.
ElasticSearch的JavaAPI
weixin_48319193的博客
06-27 446
elasticSearch的JavaApi
ElasticSearch7.0 Java High Level Client使用教程（一：简单查询）
weixin_42473019的博客
05-21 1545
本文将演示如何使用ES提供的Java高级包来查询数据，首先API其实就是在底层构建一条DSL查询语句，所以我们首先看一下这条语句: GET test*/_search { "timeout": "60s", "query": { "bool": { "must": [ { "terms": { "status.keyword": [ "301", "302"
elasticsearch7.1 Java API-索引、创建文档
gloamer的博客
09-01 1227
在咱们写创建索引，删除索引之前需要在咱们测试类中提前做好准备，第一是引入咱们的客户端（client），每次执行完都要将client释放资源，所以咱们可以用junit的After注解，在执行完方法后释放资源.over 废话不多说，直接上代码。 准备 引入客户端（client） /** * 日志记录 */ private static final Logger logger= LoggerFactory.getLogger(El...
【ElasticSearch】java操作ElasticSearch 7.x
来日浅谈的博客
12-27 3671
【ElasticSearch】java操作ElasticSearch 7.x1. 导入依赖2. 操作索引3. 操作文档3.1 新增文档3.2 删除文档3.3 修改文档3.4 批量增，删，改文档3.5 查询文档3.5.1 基本查询3.5.2 复杂查询3.5.3 分页查询3.5.4 查询结果高亮显示 ElasticSearch7.x中不在建议使用transport，并且将在8.0彻底淘汰。 所以我们需要使用7.x推荐使用的RestHighLevelClient来操作ElasticSearch。 在springb
ElasticSearch7 java API ------Search API
weixin_43354959的博客
12-11 257
java 全文检索_使用Elasticsearch7 java api实现pdf全文检索
weixin_35280108的博客
02-15 1167
前提:pdf的内容是文字形式而不是图片形式！一.方法Elasticsearch实现pdf的全文检索,原理是将pdf转换为Base64,然后提取pdf的文字内容然后将其存储起来.Elasticsearch已有相关Api提供,也给出了例子.链接如下:我们来解读以下//定制一个管道,用于将Base64转换为文字形式PUT _ingest/pipeline/attachment{"description"...
Elasticsearch7.x常用API
jonssonyan
01-06 1574
索引操作 创建索引 index 创建索引后设置 Mapping 注意：在 ES 7.X 之后 删除了映射类型 参见 ES 官方说明：https://www.elastic.co/guide/en/elasticsearch/reference/7.x/removal-of-types.html 一般碰到报错:”Types cannot be provided in put mapping requests, unless the include_type_name parameter is set t
elasticsearch学习3：elasticsearch7.1.6 java api
zhaofuqiangmycomm的博客
01-14 1072
package com.thinkgem.jeesite.util.elasticsearch; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import com.thinkgem.jeesite.common.mapper.JsonMa.
elasticsearch java操作的api实例
09-29
包含所因的索引建立、删除、查看，批量创建索引；搜索Query、过滤器 、分组高亮显示；以及创建Mapping
elasticsearch java操作的api实例
04-20
包含所因的索引建立、删除、查看，批量创建索引；搜索Query、过滤器 、分组高亮显示；以及创建Mapping
Elasticsearch-Java-client-api:Elasticsearch的java客户端使用示例
05-11
Elasticsearch的java客户端使用示例 工程说明： 一. es-hrest-client-src工程： Elasticsearch的高级别的REST客户端使用示例 二、es-java-client-src工程： Elasticsearch的TransportClient客户端使用示例 注意：...
elasticsearch-http:在Java中使用HTTP API的Elasticsearch客户端
05-14
一个与传输客户端相似但使用HTTP的elasticsearch客户端库。 客户端的输入与传输客户端相似，因此您可以重复使用构建器。 返回的对象不同，并且基于返回的JSON。 这不是完全可以生产的，也不是生产证明的，缺少某些...
Elastic7.x语法版本操作手册
11-22
Elasticsearch 基础操作 2.1.1HTTP 操作 1）创建索引 2）查看所有索引 3）查看单个索引 4）删除索引 4）删除索引 2.1.1.2文档操作 1）创建文档 2）查看文档 3）修改文档 4）修改字段 5）删除文档 6）条件删除文档 ...
esrest:ElasticSearch REST API 的简单直接的 Java 客户端
07-10
这是 Elasticsearch REST API 的简单、直接的 Java 客户端。关于这个小项目如果你发现了这个项目，你可能知道 Jest：Elasticsearch 唯一基于 Java 的 REST 客户端。 我对 Jest 的工作方式并不满意。 EsREST 有许多...
ElasticSearch面试题
最新发布
weixin_53676834的博客
04-29 790
ElasticSearch是一个强大的分布式搜索引擎。它有个核心技术叫做倒排索引，可以帮助我们从海量数据中快速的找到所需要的内容，实现海量数据的搜素、分析和运算，响应时间通常很短。（聚合）ElasticSearch支持跨语言，它对外暴露的是Restful接口，不同的编程语言都可以通过HTTP请求与ElasticSearch进行交互。
bitbake ERROR:No space left on device or exceeds fs.inotify.max_user_watches?
qq_40734815的博客
04-25 233
bitbake ERROR:No space left on device or exceeds fs.inotify.max_user_watches? 解决方法及原因
linux常用非基础命令/操作
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
04-23 409
本篇用于总结蒟蒻博主在使用linux系统的过程中会经常用到但老实记不住的一些非基础命令和操作，方便遗忘时查阅。
elasticsearch java客户端使用
09-02
这只是一个简单的示例，Elasticsearch Java 客户端提供了丰富的 API，可用于执行各种操作，如索引文档、更新文档、删除文档等。你可以参考 Elasticsearch Java 客户端的官方文档来了解更多信息：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值