Elasticsearch7.x——Low Level REST Client详解

最新推荐文章于 2024-06-28 17:25:09 发布
最新推荐文章于 2024-06-28 17:25:09 发布
阅读量521 收藏 3
点赞数 1
分类专栏： ElasticSearch 文章标签： elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/133967304
版权

目录

Low Level REST Client

Elasticsearch Client低级别客户端。它允许通过HTTP请求与Elasticsearch集群进行通信。API本身不负责数据的编码解码，由用户去编码解码。它与所有的Elasticsearch版本兼容。这种方式好处就是兼容所有的 Es 版本。但是就是数据处理比较麻烦。

引入依赖：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>7.16.0</version>
</dependency>

1、初始化及配置

RestClient实例可以通过RestClientBuilder类创建，通过RestClient 的 builder（HttpHost …）静态方法创建。 唯一需要的参数是客户端将与之通信的一个或多个主机，如下所示：

@Test
public void create_client() {
    RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200, "http"),
            new HttpHost("localhost", 9201, "http")).build();
    try {
        restClient.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

RestClient类是线程安全的，理想情况下与使用它的应用程序具有相同的生命周期。当不再需要时关闭它是非常重要的，这样它所使用的所有资源以及底层http客户端实例及其线程都可以得到释放。

RestClientBuilder还允许在构建RestClient实例时可选地设置以下配置参数：

@Test
public void config_clent() {
    //配置可选参数
    RestClientBuilder builder = RestClient.builder(
            new HttpHost("localhost", 9200, "http"));
    Header[] defaultHeaders = new Header[]{new BasicHeader("header", "value")};
    //设置每个请求需要发送的默认headers，这样就不用在每个请求中指定它们。
    builder.setDefaultHeaders(defaultHeaders);
    //REST客户端是否应该使用gzip内容编码压缩请求，并添加“Accept-encoding:gzip”*标头以接收压缩的响应。
    builder.setCompressionEnabled(true);
    //是否发送运行环境的元信息
    builder.setMetaHeaderEnabled(false);
    //为http客户端使用的每个请求设置路径的前缀。例如，如果设置为“/my/path”，则任何客户端请求都将变为 /my/path/ + endpoint
    builder.setPathPrefix("/my/test");
    //是否包含warnning header的响应都是失败的。
    builder.setStrictDeprecationMode(false);
    //设置节点选择器(对所有请求都有效)，自定义：选择节点名称不以 log_ 开头的
    builder.setNodeSelector(new NodeSelector() {
        @Override
        public void select(Iterable<Node> nodes) {
            Iterator<Node> itr = nodes.iterator();
            while (itr.hasNext()) {
                if (itr.next().getName().startsWith("log_")) {
                    itr.remove();
                }
            }
        }
    });
    //监听器，每次请求失败都会被调用
    builder.setFailureListener(new RestClient.FailureListener(){
        @Override
        public void onFailure(Node node) {
            super.onFailure(node);
        }
    });
    //用于修改默认请求配置的回调，可以配置多个参数，如请求超时，是否进行身份验证等
    builder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
        @Override
        public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder builder) {
            return builder.setSocketTimeout(10000);
        }
    });
    //用于修改默认http客户端配置的回调
    //例如，通过SSL的加密通信，或者org.apache.http.impl.nio.client.HttpAsyncClientBuilder允许设置的任何内容）
    builder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
        @Override
        public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
            return httpClientBuilder.setProxy(new HttpHost("proxy", 9000, "http"));
        }
    });

    RestClient clien = builder.build();
    try {
        clien.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2、Base Auth认证

private RestClient restClient;

@Before
public void auth() {
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY,
            new UsernamePasswordCredentials("elastic", "123456"));
    restClient = RestClient.builder(new HttpHost("localhost", 9200, "http"))
            .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                @Override
                public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                }
            }).build();
}

3、执行请求

一旦创建了RestClient，就可以调用performRequest或performRequestAsync方法来发送请求。

  • performRequest方法是同步的，直接返回响应，这意味着客户端将被阻塞并等待响应返回。
  • performRequestAsync方法返回void，并接受一个ResponseListener作为参数，这意味着它们是异步执行的。当请求完成或失败时，监听器将被通知。

3.1、配置Request

@Test
public void config_request() throws IOException {
    //构建Request，两个必填参数 request-method  endpoint
    Request request = new Request("POST", "/_analyze");
    //设置查询参数，即 /_analyze?pretty=true
    request.addParameter("pretty", "true");
    //设置请求体和ContentType：一般就是JSON字符串
    //第一种方式：使用NStringEntity，此时一定要设置Content-Type为ContentType.APPLICATION_JSON
    // String jsonString = "{" +
    //         "\"analyzer\":\"ik_max_word\"," +
    //         "\"text\":\"我是中国人\"" +
    //         "}";
    // HttpEntity entity = new NStringEntity(jsonString, ContentType.APPLICATION_JSON);
    // request.setEntity(entity);
    //第二种方式：使用JsonEntity，此时不需要设置Content-Type，因为方法内部已经自动设置了ContentType.APPLICATION_JSON
    JSONObject jsonEntity = new JSONObject();
    jsonEntity.put("analyzer", "ik_max_word");
    jsonEntity.put("text", "我是中国人");
    request.setJsonEntity(jsonEntity.toJSONString());

    //配置选项
    request.setOptions(RequestOptions.DEFAULT.toBuilder().addHeader("key", "value"));
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "中国人",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "中国",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "国人",
      "start_offset" : 3,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 4
    }
  ]
}

3.2、同步发送请求

@Test
public void sync_request() throws IOException {
    Request request = new Request("GET", "/_count");
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));
}

{"count":33607,"_shards":{"total":12,"successful":12,"skipped":0,"failed":0}}

3.3、异步发送请求

@Test
public void async_request() {
    CountDownLatch latch = new CountDownLatch(1);
    Request request = new Request("GET", "/_count");
    restClient.performRequestAsync(request, new ResponseListener() {
        @Override
        public void onSuccess(Response response) {
            //处理返回的响应内容
            try {
                System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));
                latch.countDown();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(Exception exception) {
            //处理返回的异常
            System.out.println(exception.getMessage());
        }
    });

    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

{"count":33607,"_shards":{"total":12,"successful":12,"skipped":0,"failed":0}}

4、解析Response

@Test
public void analyze_response() throws IOException {
    Request request = new Request("GET", "/_count");
    Response response = restClient.performRequest(request);
    //响应码
    System.out.println(response.getStatusLine().getStatusCode());
    //协议
    System.out.println(response.getStatusLine().getProtocolVersion());
    //响应码对应的描述短语
    System.out.println(response.getStatusLine().getReasonPhrase());
    //Host
    System.out.println(response.getHost());
    //Headers
    Header[] headers = response.getHeaders();
    for (int i = 0; i < headers.length; i++) {
        System.out.println(headers[i].getName() + ":" + headers[i].getValue());
    }
    //warnings
    List<String> warnings = response.getWarnings();
    for (String warning : warnings) {
        System.out.println(warning);
    }
    //响应体
    System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));
}

200
HTTP/1.1
OK
http://localhost:9200
X-elastic-product:Elasticsearch
Warning:299 Elasticsearch-7.16.0-6fc81662312141fe7691d7c1c91b8658ac17aa0d "this request accesses system indices: [.apm-agent-configuration, .apm-custom-link, .fleet-policies-7, .kibana_7.16.0_001, .kibana_task_manager_7.16.0_001, .security-7, .tasks], but in a future major version, direct access to system indices will be prevented by default"
content-type:application/json; charset=UTF-8
content-length:77
this request accesses system indices: [.apm-agent-configuration, .apm-custom-link, .fleet-policies-7, .kibana_7.16.0_001, .kibana_task_manager_7.16.0_001, .security-7, .tasks], but in a future major version, direct access to system indices will be prevented by default
{"count":33607,"_shards":{"total":12,"successful":12,"skipped":0,"failed":0}}

5、简单示例

5.1、搜索

@Test
public void search_match() throws IOException {
    Request request = new Request("GET", "/bank/_search?pretty=true");
    NStringEntity entity = new NStringEntity("{\n" +
            "  \"query\": {\n" +
            "    \"match\": {\n" +
            "      \"address\": \"street\"\n" +
            "    }\n" +
            "  },\n" +
            "  \"from\": 0,\n" +
            "  \"size\": 2\n" +
            "}", ContentType.APPLICATION_JSON);
    request.setEntity(entity);
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));
}

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 385,
      "relation" : "eq"
    },
    "max_score" : 0.95395315,
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "_doc",
        "_id" : "6",
        "_score" : 0.95395315,
        "_source" : {
          "account_number" : 6,
          "balance" : 5686,
          "firstname" : "Hattie",
          "lastname" : "Bond",
          "age" : 36,
          "gender" : "M",
          "address" : "671 Bristol Street",
          "employer" : "Netagy",
          "email" : "hattiebond@netagy.com",
          "city" : "Dante",
          "state" : "TN"
        }
      },
      {
        "_index" : "bank",
        "_type" : "_doc",
        "_id" : "13",
        "_score" : 0.95395315,
        "_source" : {
          "account_number" : 13,
          "balance" : 32838,
          "firstname" : "Nanette",
          "lastname" : "Bates",
          "age" : 28,
          "gender" : "F",
          "address" : "789 Madison Street",
          "employer" : "Quility",
          "email" : "nanettebates@quility.com",
          "city" : "Nogal",
          "state" : "VA"
        }
      }
    ]
  }
}

5.2、设置Mapping

@Test
public void put_mapping() throws IOException {
    Request request = new Request("PUT", "/test_index");
    NStringEntity entity = new NStringEntity(
            "{\n" +
                    "  \"settings\": {\n" +
            "    \"number_of_shards\": 1,\n" +
            "    \"number_of_replicas\": 1\n" +
            "  },\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"title\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}\n" +
            "\n", ContentType.APPLICATION_JSON);
    request.setEntity(entity);
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

{"acknowledged":true,"shards_acknowledged":true,"index":"test_index"}

5.3、高亮结果

@Test
public void highlight() throws IOException {
    Request request = new Request("GET", "/bank/_search?pretty=true");
    NStringEntity entity = new NStringEntity("{\n" +
            "  \"query\": {\n" +
            "    \"term\": {\n" +
            "      \"city.keyword\": {\n" +
            "        \"value\": \"Brogan\"\n" +
            "      }\n" +
            "    }\n" +
            "  },\n" +
            "  \"highlight\": {\n" +
            "    \"fields\": {\"city.keyword\": {}}\n" +
            "  }\n" +
            "}"
            , ContentType.APPLICATION_JSON);
    request.setEntity(entity);
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

{
  "took" : 45,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 6.5032897,
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 6.5032897,
        "_source" : {
          "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"
        },
        "highlight" : {
          "city.keyword" : [
            "<em>Brogan</em>"
          ]
        }
      }
    ]
  }
}

5.4、聚合

日期直方图聚合：

@Test
public void date_histogram() throws IOException {
    Request request = new Request("GET", "/kibana_sample_data_flights/_search?pretty=true");
    NStringEntity entity = new NStringEntity("{\n" +
            "  \"track_total_hits\": true,\n" +
            "  \"size\": 0,\n" +
            "  \"aggs\": {\n" +
            "    \"timestamp_histogram\": {\n" +
            "      \"date_histogram\": {\n" +
            "        \"field\": \"timestamp\",\n" +
            "        \"calendar_interval\": \"1M\",\n" +
            "        \"format\": \"yyyy-MM-dd\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}"
            , ContentType.APPLICATION_JSON);
    request.setEntity(entity);
    Response response = restClient.performRequest(request);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

{
  "took" : 10,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 13059,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "timestamp_histogram" : {
      "buckets" : [
        {
          "key_as_string" : "2023-10-01",
          "key" : 1696118400000,
          "doc_count" : 7165
        },
        {
          "key_as_string" : "2023-11-01",
          "key" : 1698796800000,
          "doc_count" : 5894
        }
      ]
    }
  }
}
吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch Client详解
qdwd888的博客
05-03 4138
代码@1：使用空配置。 代码@2：连接ElasticSearch 节点，可以通过addTransportAddress方法连接多个Node节点，这样请求会轮流发送到这些节点上，实现集群节点在接受请求时的负载均衡。 TransportClient级别的主要参数如下： | 参数名 | 描述 | | — | — | | cluster.name | transport node与服务端节点并不在一个集群中 | | client.transport.sniff | 是否开启集群嗅探功能，下文会详细介绍。 | | c
02-Elasticsearch 8.x 向量搜索使用详解 杭州 1.6 2024
01-08
**Elasticsearch 8.x 向量搜索使用详解** Elasticsearch 8.x 版本引入了对向量搜索的支持，这使得它能够处理非结构化的数据，如图像、文本和语音的语义搜索。向量搜索是通过将数据转换为高维向量并进行相似度比较来...
Java Low Level REST Client 官网说明-依赖
tttmdds的专栏
11-30 49
es版本说明： 基于es的7.16版本 1、相关版本说明 要求java1.8以及以上 Java Low Level REST Client（以下简称客户端） 发布从属于Elasticsearch发布周期，但是二者版本无关，客户端可以访问任意版本Elasticsearch 2、依赖配置 maven依赖配置 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>el.
Elasticsearch-Rest-Client
最新发布
2301_78117253的博客
06-28 309
【代码】Elasticsearch-Rest-Client。
Elasticsearch Java Low Level REST Client（通用配置）
dreamzuora的博客
10-10 1080
Elasticsearch Java Low Level REST Client（通用配置） 通用配置 正如初始化中所解释的，RestClientBuilder支持提供RequestConfigCallback和HttpClientConfigCallback，它们允许Apache Async Http Client公开的任何自定义。这些回调可以修改客户端的某些特定行为，而不会覆盖RestClient初始化的所有其他默认配置，本节介绍一些需要为低级别Java REST Client进行其他配置的常见方案
【es笔记三】Java Low Level REST Client
西瓜游侠的博客
12-06 7056
0 综述 Java REST Client 有两种风格： Java Low Level REST Client：ElasticSearch官方的低级客户端。它允许通过http与一个Elasticsearch集群通信。将请求的编组和响应的反编组工作留给用户自己处理。它兼容所有的Elasticsearch的版本。 Java High Level REST Client：Elasticsearch官方...
Elasticsearch Java REST 客户端 6.2（一）Java Low Level REST 客户端官方文档
热门推荐
HoloLens的博客
03-17 1万+
提示！本文是我翻译自Elasticsearch官方说明文档，这里是原文地址，文章结构与原文对应，对翻译内容如有疑问可自行翻阅，也欢迎私信评论纠正错误。 概述 Java REST客户端有两种风格： Java Low Level REST Client：官方提供的低级客户端。该客户端通过http来连接Elasticsearch集群。用户在使用该客户端时需要将请求数据手动拼接成Elast...
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
elasticsearch-rest-high-level-client-6.8.3-API文档-中英对照版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
Elasticsearch 7.x 单机多node部署步骤 X-Pack设置用户密码+安装包
08-24
**Elasticsearch 7.x 单机多node部署步骤** 在Elasticsearch 7.x版本中，单机多node部署是一种常见的优化方案，用于提高数据处理能力。以下是一步步的详细部署过程： 1. **环境准备**: 首先确保你的系统支持...
东软单片机-ES7P213x——IIC从机配置.zip
07-03
【标题】"东软单片机-ES7P213x——IIC从机配置.zip"中的内容主要涉及的是如何在基于东软单片机ES7P213x的系统中设置IIC（Inter-Integrated Circuit）协议，使其工作在从机模式下。IIC是一种多主控、多从机的两线制...
java low level rest client
留不住斜阳的博客
07-20 763
基于http的客户端rest client，官网给出的restclient有java low level rest client和java hight level rest client，前者兼容所有版本的es，后者是基于前者开发的，只暴露了部分api 添加依赖 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-clie
Elasticsearch java api操作（一）（Java Low Level Rest Client）
weixin_30346033的博客
04-19 555
一、说明： 　　一、Elasticsearch提供了两个JAVA REST Client版本： 　　1、java low level rest client: 　　低级别的rest客户端，通过http与集群交互，用户需自己编组请求JSON串，及解析响应JSON串。兼容所有Elasticsearch版本。 　　特点：maven引入 　　使用介绍:https://www.elastic.c...
Elasticsearch：使用 Low Level Java 客户端来创建连接 - Elastic Stack 8.x
Elastic 中国社区官方博客
07-13 1302
展示如何使用 Elastic 所提供的 Low Level Client API 来访问 Elasticsearch。
ElasticSearch的client
XuXing_java的专栏
01-03 848
4、elasticsearch-rest-high-level-client:6.4.3，高级客户端【es官方推荐】，依赖于低级客户端elasticsearch-rest-client和elasticsearch两个模块，使用面向对象的方式来形成dsl，和TransportClient不同的是，它是通过低级客户端的http协议和es服务器来交互。总的来说，High Level REST Client 是目前推荐使用的客户端，而 Transport Client 已经被废弃不建议使用。
Elasticsearch客户端
浪子huang
10-09 233
maven 依赖 <!--elasticsearch--> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>6.8.10</version> </d
华为云Elasticsearch(FusionInsight HD)连接和开发教程02-通过LowLevel RestClient操作ES
sunjian286的专栏
06-19 303
本文介绍在华为云FusionInsight的环境下，通过LowLevel RestClient操作ElasticSearch，并提供相关样例代码
ElasticSearch 应用开发（七）Java Low Level Rest Client——Java API
腊八粥
04-01 3543
1.概述 Java restclient分为两种:Java Low Level Rest Client(本节介绍重点)、Java HighLevel Rest Client（下节介绍）。 Java Low Level Rest Client Elasticsearch 官方低级客户端： 通过http协议 与Elasticsearch服务进行通信。请求编码和响应解码保留给用户实现。与...
使用Java Low Level REST Client操作elasticsearch
05-30
当使用Java Low Level REST Client操作elasticsearch时，可以按照以下步骤进行： 1. 导入Java Low Level REST Client依赖 在Maven项目中，需要在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-client</artifactId> <version>7.13.3</version> </dependency> ``` 2. 创建REST Client 在Java代码中，可以使用以下代码创建REST Client： ```java RestClient restClient = RestClient.builder( new HttpHost("localhost", 9200, "http"), new HttpHost("localhost", 9201, "http")).build(); ``` 其中，HttpHost参数指定了elasticsearch的地址和端口。 3. 发送请求 可以使用REST Client发送GET、POST、PUT、DELETE等请求。以下是一个GET请求的示例： ```java Request request = new Request( "GET", "/my_index/_search"); Response response = restClient.performRequest(request); String responseBody = EntityUtils.toString(response.getEntity()); ``` 其中，Request对象指定了请求类型和请求路径，performRequest方法发送请求并返回Response对象，EntityUtils.toString方法将返回的Response对象转换为字符串。 4. 关闭REST Client 在完成操作后，需要关闭REST Client以释放资源： ```java restClient.close(); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值