ES8的Java API client 8.0 简单示例操作 Elasticsearch

于 2024-09-28 16:54:52 发布
阅读量321 收藏
点赞数 1
文章标签： java elasticsearch 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73363097/article/details/142617941
版权

1.加入依赖

      <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.12.2</version>
        </dependency>

2.配置类



@Slf4j
@Configuration
public class ElasticSearchConfig {
    @Value("${elasticsearch.hosts}")
    private String hosts;
    @Value("${elasticsearch.port}")
    private int port;
    @Value("${elasticsearch.username}")
    private String username;
    @Value("${elasticsearch.password}")
    private String password;
    @Value("${elasticsearch.apikey:''}")
    private String apikey;

    /**
     * 单节点没密码连接
     *
     * @return
     */
    @Bean
    public ElasticsearchClient elasticsearchClient() {
        String[] servers = hosts.split(",");
        int len = servers.length;
        if (0 == len) {
            log.error("ElasticsearchClient 配置错误!");
        }
        ElasticsearchTransport transport = null;
        // 不是集群时
        if (1 == len) {
            // 无账号、密码
            if (StringUtils.isEmpty(username) && StringUtils.isEmpty(password)) {
                RestClient client = RestClient.builder(new HttpHost(servers[0], port, "http"))
                        .setHttpClientConfigCallback(httpClientBuilder
                                ->httpClientBuilder.setDefaultHeaders(
                                        Collections.singletonList(new BasicHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString())))
                                .addInterceptorLast((HttpResponseInterceptor) (response, context)
                                        -> response.addHeader("X-Elastic-Product", "Elasticsearch")))
                        .build();
                transport = new RestClientTransport(client, new JacksonJsonpMapper());
            } else {
                // 账号密码的配置
                final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
                // 自签证书的设置，并且还包含了账号密码
                RestClientBuilder.HttpClientConfigCallback callback = httpAsyncClientBuilder -> httpAsyncClientBuilder
                        .setDefaultCredentialsProvider(credentialsProvider)
                        .addInterceptorLast(
                                (HttpResponseInterceptor)
                                        (response, context) ->
                                                response.addHeader("X-Elastic-Product", "Elasticsearch"));

                RestClient client = RestClient.builder(new HttpHost(servers[0], port, "http"))
                        .setHttpClientConfigCallback(callback)
                        .build();
                transport = new RestClientTransport(client, new JacksonJsonpMapper());
            }
        } else {
            // 集群时无账号、密码
            if (StringUtils.isEmpty(username) && StringUtils.isEmpty(password)) {
                transport = getElasticsearchTransport(toHttpHost());
            } else {
                transport = getElasticsearchTransport(username, password, toHttpHost());
            }
        }
        return new ElasticsearchClient(transport);
    }


    private HttpHost[] toHttpHost() {
        if (hosts.split(",").length == 0) {
            throw new RuntimeException("invalid elasticsearch configuration");
        }
        String[] hostArray = hosts.split(",");
        HttpHost[] httpHosts = new HttpHost[hostArray.length];
        HttpHost httpHost;
        for (int i = 0; i < hostArray.length; i++) {
            String[] strings = hostArray[i].split(":");
            httpHost = new HttpHost(strings[0], Integer.parseInt(strings[1]), "http");
            httpHosts[i] = httpHost;
        }
        return httpHosts;
    }

    private static ElasticsearchTransport getElasticsearchTransport(String username, String password, HttpHost... hosts) {
        // 账号密码的配置
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));

        // 自签证书的设置，并且还包含了账号密码
        RestClientBuilder.HttpClientConfigCallback callback = httpAsyncClientBuilder -> httpAsyncClientBuilder
                .setSSLContext(buildSSLContext())
                .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                .setDefaultCredentialsProvider(credentialsProvider)
                .setDefaultHeaders(
                        Stream.of(new BasicHeader(
                                HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString())).collect(toList())
                ).addInterceptorLast(
                        (HttpResponseInterceptor)
                                (response, context) ->
                                        response.addHeader("X-Elastic-Product", "Elasticsearch"))
                .addInterceptorLast((HttpResponseInterceptor) (response, context)
                        -> response.addHeader("X-Elastic-Product", "Elasticsearch"));
        // 用builder创建RestClient对象
        RestClient client = RestClient
                .builder(hosts)
                .setHttpClientConfigCallback(callback)
                .build();

        return new RestClientTransport(client, new JacksonJsonpMapper());
    }

    private static ElasticsearchTransport getElasticsearchTransport(HttpHost... hosts) {
        // 用builder创建RestClient对象
        RestClient client = RestClient
                .builder(hosts)
                .build();

        return new RestClientTransport(client, new JacksonJsonpMapper());
    }

    private static SSLContext buildSSLContext() {
        ClassPathResource resource = new ClassPathResource("es01.crt");
        SSLContext sslContext = null;
        try {
            CertificateFactory factory = CertificateFactory.getInstance("X.509");
            Certificate trustedCa;
            try (InputStream is = resource.getInputStream()) {
                trustedCa = factory.generateCertificate(is);
            }
            KeyStore trustStore = KeyStore.getInstance("pkcs12");
            trustStore.load(null, null);
            trustStore.setCertificateEntry("ca", trustedCa);
            SSLContextBuilder sslContextBuilder = SSLContexts.custom().loadTrustMaterial(trustStore, null);
            sslContext = sslContextBuilder.build();
        } catch (CertificateException | IOException | KeyStoreException | NoSuchAlgorithmException |
                 KeyManagementException e) {
            log.error("ES连接认证失败", e);
        }
        return sslContext;
    }
}

3.相关api

前提：

注入ElasticsearchClient

@Autowired
private ElasticsearchClient client;

3.1 创建索引

 public void createIndex() throws IOException {
        ElasticsearchIndicesClient indices = client.indices();
        //是否存在
        //1.lambda
        boolean isExit = indices.exists(req -> req.index("ttt")).value();
        //2.builder,of
        ExistsRequest existsRequestOf = ExistsRequest.of(req -> req.index("ttt"));
        ExistsRequest existsRequest = new ExistsRequest.Builder().index("ttt").build();
        boolean builderExist = indices.exists(existsRequest).value();
        if (isExit){
            log.info("已经存在ttt");
        }else {
            //1.lambda
            boolean isSuccess = indices.create(req -> req.index("ttt")).acknowledged();
            //2.builder,of
            CreateIndexRequest createIndexRequestOf = CreateIndexRequest.of(req -> req.index("ttt"));
            CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder().index("ttt").build();
            boolean buildIsSuccess = indices.create(createIndexRequest).acknowledged();
            if (isSuccess){
                log.info("创建成功");
            }else {
                log.info("创建失败");
            }
        }
    }

3.2 删除索引

public void deleteIndex() throws IOException {
        //1.lambda
        boolean isSuccess = client.indices().delete(req -> req.index("ttt")).acknowledged();
        //2.builder,of
        DeleteIndexRequest deleteRequestOf = DeleteIndexRequest.of(req -> req.index("ttt"));
        DeleteIndexRequest deleteRequest = new DeleteIndexRequest.Builder().index("ttt").build();
        boolean buildDeleteRequest = client.indices().delete(deleteRequest).acknowledged();
    }

3.3查询索引

 public void queryIndex() throws IOException {
        //1.lambda
        //查询单个
        Map<String, IndexState> tttIndex = client.indices().get(req -> req.index("ttt")).result();
        //查询索引
        Set<String> all = client.indices().get(req -> req.index("*")).result().keySet();
        //2.builder
        GetIndexRequest getIndexRequestOf = GetIndexRequest.of(req -> req.index("ttt"));
        GetIndexRequest getIndexRequest = new GetIndexRequest.Builder().index("ttt").build();
        Map<String, IndexState> result = client.indices().get(getIndexRequest).result();
    }

3.4 插入文档

 public void addDoc() throws IOException {
        Goods goods = new Goods("3212334","华为mate60", 9999.0);

        //1.lambda
        client.index(i->i
                .index("goods")
                .id(goods.getSku())
                .document(goods));
        //2.builder-of
        IndexRequest<Goods> addIndexRequestOf = IndexRequest.of(t -> t.id(goods.getSku()).document(goods).index("goods"));
        IndexRequest<Goods> addIndexRequest = new IndexRequest<>.Builder()
                .index("goods")
                .id(goods.getSku())
                .document(goods).build();
        IndexResponse index = client.index(addIndexRequest);

    }

3.5 批量插入文档

public void addBatchDoc() throws IOException {

        List<Goods> goodsList = List.of(new Goods("1","手机",999.0));
        BulkRequest.Builder br = new BulkRequest.Builder();
        for (Goods goods : goodsList) {
            br.operations(op->op.
                    index(idx->idx.index("goods")
                            .id(goods.getSku())
                            .document(goods)));
        }
        BulkResponse result = client.bulk(br.build());
        // Log errors, if any
        if (result.errors()) {
            log.error("Bulk had errors");
            for (BulkResponseItem item: result.items()) {
                if (item.error() != null) {
                    log.error(item.error().reason());
                }
            }
        }
    }

3.6查询文档

public void queryDoc() throws IOException {
        //1.lambda
        GetResponse<Goods> response = client.get(g ->  g
                        .index("goods")
                        .id("00000")
                , Goods.class);
        //2.builder,of
        GetRequest request = GetRequest.of(g -> g.index("goods").id("00000"));

        GetRequest ofRequest = new GetRequest.Builder().index("goods").id("00000").build();


        GetResponse<Goods> response1 = client.get(request, Goods.class);
        if (response.found()){
            Goods source = response.source();
            System.out.println(source);
        }
    }

3.7修改文档

 public void updateDoc() throws IOException {
        //全量
        Goods goods = new Goods("1","2",3.0);
        UpdateResponse<Goods> update = client.update(u -> u
                        .doc(goods)
                        .id(goods.getSku())
                , Goods.class);
        //of
        UpdateRequest<Object, Object> of = UpdateRequest.of(u -> u.id(goods.getSku()).doc(goods));
        UpdateResponse<Object> update1 = client.update(of, Goods.class);
    }

3.8删除文档

   */
    public void deleteDoc() throws IOException {
        DeleteResponse goods = client.delete(d -> d
                .index("goods")
                .id("0000"));

        //of
        DeleteRequest deleteRequest = DeleteRequest.of(d -> d.index("goods").id("0000"));
        client.delete(deleteRequest);
    }

3.9 DSL 匹配查询

public void query() throws IOException {
        String text = "华为mate60";
        SearchResponse<Goods> response = client.search(s -> s
                        .index("goods")
                        .query(q -> q
                                .match(m -> m
                                        .field("name")
                                        .query(text))
                        )
                , Goods.class);

        //of
        SearchRequest request = SearchRequest.of(s -> s.index("goods")
                .query(q -> q
                        .match(m ->
                                m.field("").field(""))
                ));
        SearchResponse<Goods> search = client.search(request, Goods.class);
        //结果
        //总数
        TotalHits total = response.hits().total();
        assert total != null;
        boolean isExactResult = total.relation() == TotalHitsRelation.Eq;
        if (isExactResult) {
            log.info("找到 " + total.value() + " 个结果");
        } else {
            log.info("找到超过 " + total.value() + " 个结果");
        }
        List<Hit<Goods>> hits = response.hits().hits();
        for (Hit<Goods> hit : hits) {
            Goods goods = hit.source();
            System.out.println(goods);
        }
    }

3.10 多精确terms

public void terms(){
        List<FieldValue> v = new ArrayList<>();
        FieldValue tag2 = FieldValue.of("tag2");
        FieldValue tag1 = FieldValue.of("tag1");
        v.add(tag1);v.add(tag2);
        TermsQuery tags = TermsQuery.of(t -> t.field("tags").terms(tm -> tm.value(v)));
        SearchRequest of = SearchRequest.of(s -> s.index("goods")
                .query(q -> q
                        .bool(b -> b
                                .must(m -> m
                                        .terms(tags)
                                )
                                .should(sh -> sh
                                        .match(ma -> ma
                                                .field("")
                                                .query("")
                                        )
                                )
                        )
                )
                .from(0)
                .size(10)

        );
        
    }

3.11 布尔查询




@Slf4j
@Service
public class EsTest {

    @Autowired
    private ElasticsearchClient client;

    
    /**
     * bool
     */
    public void boolQuery() throws IOException {
        Map<String, HighlightField> map = new HashMap<>();
        map.put("title", HighlightField.of(hf -> hf.preTags("<em>").postTags("<em/>")));
        map.put("description", HighlightField.of(hf -> hf.preTags("<em>").postTags("<em/>")
                .numberOfFragments(4).fragmentSize(50)));
        //numberOfFragments(4)，表示将字段分割为最多4个片段，并设置 fragmentSize(50)，表示每个片段的大小为50个字符。

        Highlight highlight = Highlight.of(
                h -> h.type(HighlighterType.Unified)
                        .fields(map)
                        .fragmentSize(50)//设置默认的高亮片段大小为50个字符，如果字段没有单独设置，则使用此默认值。
                        .numberOfFragments(5)//设置每个字段的最大高亮片段数为5个。
        );

        String text = "华为mate60";
        SearchResponse<Goods> search = client.search(s -> s
                        .index("goods")
                        .query(q -> q
                                .bool(b -> b
                                        .must(m -> m
                                                .term(t -> t
                                                        .field("品牌")
                                                        .value("华为")
                                                )
                                        )
                                        .should(sd -> sd
                                                .match(mh -> mh
                                                        .field("name")
                                                        .query("mate60")))
                                )
                        )
                        .from(0)
                        .size(10)
                        .highlight(highlight)
                , Goods.class);
        //of
        SearchRequest of = SearchRequest.of(s -> s.index("goods")
                .query(q -> q
                        .bool(b -> b
                                .must(m -> m
                                        .term(t -> t.field("品牌")
                                                .value("华为")
                                        )
                                )
                                .should(sh -> sh
                                        .match(ma -> ma
                                                .field("")
                                                .query("")
                                        )
                                )
                        )
                )
                .from(0)
                .size(10)
                .highlight(highlight)

        );

        SearchResponse<Goods> response = client.search(of, Goods.class);
        List<Hit<Goods>> hits = response.hits().hits();
        for (Hit<Goods> hit : hits) {
            Goods goods = hit.source();
            if (goods == null){
                continue;
            }
            Map<String, List<String>> highlightList = hit.highlight();
            highlightList.forEach((key, Value)->{
                if (Objects.equals(key,goods.getName())){
                    //存入
                }else {
                    //无高亮
                }
               }
            );
            System.out.println(goods);
        }

    }
    
}

3.12构建排序

/**
     * 构建排序
     */
    private List<SortOptions> buildSort(SearchDTO dto) {
        if (dto.getTimeSort() != null){
            SortOptions sortOptions ;
            if (dto.getTimeSort() == 0){
                sortOptions = SortOptions.of(s -> s.field(FieldSort.of(f -> f.field(SearchConstants.TIMESTAMP).order(SortOrder.Asc))));
            }else {
                sortOptions = SortOptions.of(s -> s.field(FieldSort.of(f -> f.field(SearchConstants.TIMESTAMP).order(SortOrder.Desc))));
            }
            return List.of(sortOptions);
        }else {
            return Collections.emptyList();
        }

    }

...........

又是努力搬砖的一年
关注
最新版ES8的client API操作 Elasticsearch Java API client 8.0
ShockChen7的博客
12-07 3780
我们在学习ES客户端时，一直使用的都是`Java High Level Rest Client`，在浏览官网时，发现官方给出的警告是：`Java REST` 客户端已被弃用，取而代之的是 `Java API client` 客户端，ES `8.x` 新版本中，`Type` 概念被弃用，所以新版 `JavaAPI` 也相应做出了改变，使用更加简便。ES 官方从 `7.15` 起开始建议使用新的 `JavaAPI` 如何使用最新的 `Elasticsearch Java client 8.0` 来创建索引并进
elasticsearch笔记五：2024最新版ES8Java客户端-Elasticsearch Java 的client API 操作 Elasticsearch client 8.0
热门推荐
LoveSummer
12-28 1万+
低级别的 REST 客户端，通过 http 与集群交互，用户需自己编组请求 JSON 串，及解析响应 JSON 串。兼容所有 ES 版本。高级别的 REST 客户端，基于低级别的 REST 客户端，增加了编组请求 JSON 串、解析响应 JSON 串等相关 api。使用的版本需要保持和 ES 服务端的版本一致，否则会有版本问题。
es8 java api 分页查询
weixin_42133415的博客
08-01 39
给大家整理了一些有关【API,AP】的项目学习资料（附讲解～～）：https://edu.51cto.com/course/31636.htmlhttps://edu.51cto.com/course/19064.html以一些关于【api】的学习资料和大家一起分享一下：https://edu.51cto.com/v...
【elasticsearch8.0+】java 新版 api
qq_31286957的博客
10-25 722
2、API使用示例参考摘自。4、多层bool嵌套查询。5、客户端连接配置工具类。
SpringBoot集成Elasticsearch8.x（7）|（新版本Java API Client使用完整示例）
Oaklkm的博客
06-01 8445
在Es7.15版本之后，es官方将它的高级客户端RestHighLevelClient标记为弃用状态。同时推出了全新的java API客户端Elasticsearch Java API Client，该客户端也将在Elasticsearch8.0及以后版本中成为官方推荐使用的客户端。定义一个实体，用于向ES中存储数据@Data@Builder} ## 4. 调用测试实现 > 实现索引的创建以及数据的存储查询示例```c"ES操作" }) @RestController。
ES8（Java API）集成与使用详细介绍
ztsjwnwb的博客
08-08 1277
maven中央仓库以及es官网也没有再去更新这个客户端api，转而使用起了新版的Java API，本文讲详细介绍Java API的使用。我们可以通过几行代码建立连接，并使用各种提供的方法执行索引、搜索和更新等操作。方法将文档索引到指定的索引中。你可以提供文档的JSON表示形式作为源数据，也可以使用对象映射工具（例如Jackson）将Java对象转换为JSON。首先，你需要在你的Java项目中添加Elasticsearch的Java客户端依赖。你可以指定要搜索的索引名称，以及匹配的字段和值。
SpringBoot集成Elasticsearch8.x（6）|（新版本Java API Client使用）
Oaklkm的博客
02-15 4500
ElasticSearch在7.17版本之前使用的java客户端是Java REST Client，但是从7.17版本开始，官方将Java REST Client标记为弃用（deprecated），推荐使用新版Java Client。本文介绍新版ElasticSearch Java Client的基本用法1、JAVA REST client ES提供了两个REST客户端版本（7.17版本后使用）Java Low Level REST Client ：用于Elasticsearch的官方低级客户端。
elasticsearch8.0 java客户端 ＜一＞
u013979493的博客
02-24 4929
elasticsearch8.0 java连接客户端 <一>前言elasticsearch8.0 java连接客户端java连接es8.0es8.0创建索引es8.0获取索引es8.0删除索引es8.0创建doc 前言 本人在学习elasticsearch8.0时，因elasticsearch8.0缺少java文档，自己在摸索中学习es8.0 java。 elasticsearch8.0 java连接客户端 首先在es官网下载8.0，安装后，使用java调用es报错连接超时，es中提示 rece
ElasticSearch 实战：ElasticSearch JavaApi 文档批量操作
qq_33240556的博客
04-01 388
Elasticsearch 实战：Elasticsearch Java API 文档批量操作使用 Elasticsearch Java API 进行文档的批量操作，可以显著提高数据导入、更新或删除的效率。
es8 java api client nested 如何进行 更新
09-26
在ES8 (Elasticsearch 8.x) 中，更新Java API客户端处理嵌套数据通常涉及`UpdateRequest`或`DocumentBuilder`。假设你有一个包含嵌套字段的文档模型，比如： ```java public class User { private String id; ...
javaAPI操作Elasticsearch_elasticsearch 修改字段 java api
m0_63174529的博客
04-07 1021
最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！
ElasticSearch系列——Elasticsearch Java API Client
qq_51553982的博客
11-10 3070
实体类}//创建文档 final Produce produce = new Produce("aabbcc123" , "旺仔牛比糖" , "旺仔牛比糖吃了炒鸡牛笔" , 6.66D);
es java api 创建索引结构_Elasticsearch创建索引和映射结构详解
weixin_42317626的博客
02-23 1152
前言这篇文章详细介绍了如何创建索引和某个类型的映射。下文中[address]指代elasticsearch服务器访问地址(http://localhost:9200)。1 创建索引1.1 简单创建语句curl -XPUT [address]/blog1.2 带参数的创建语句curl -XPUT [address]/blog/ -d '{"settings":{"numb...
Elasticsearch聚合分析Java Client
Tyshawn的博客
01-10 1171
本文基于Elasticsearch7.x 本文将上篇Elasticsearch聚合分析Rest API里的实例转化为Java Client Bucket Aggregation Bucket Aggregation是一系列满足特定条件的文档的集合, 类似于SQL语句里的分组功能. (1) main方法 public static void main(String[] args) throws...
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1067
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 360
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 881
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值