elasticsearch搜索中文分词理解、类似SQL语句中的"LIKE”条件的模糊搜索以及忽略大小写搜索

最新推荐文章于 2024-04-28 09:24:51 发布
最新推荐文章于 2024-04-28 09:24:51 发布
阅读量1.5w 收藏 18
点赞数 6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangqiang_accp/article/details/80422820
版权

elasticsearch作为一款搜索引擎，应用于数据库无法承受前端的搜索压力时，采用其进行数据的搜索。可以大并发架构设计中一种选择，以下是elasticsearch搜索引擎的部分规则，在实际应用中可以让我们快速熟悉和帮助解决一些问题。

01》不进行分词的索引建立

URL： es_index_test

{
  "settings": {
    "index": {
      "number_of_shards": "4",
      "number_of_replicas": "1"
    }
  },
  "mappings": {
    "es_index_type_test": {
      "properties": {
        "productId": {
          "type": "text"
        },
        "productName": {
          "type": "keyword",
          "index": "true"
        }
      }
    }
  }

}

说明：“productName”属性建立索引时，将其设置为不进行分词设置。利用wildcard搜索方式，可以实现MYSQL中的LIKE效果。例如：文档{"productId":10001,"productName":"山鸡图"}，可以用{"query":{"wildcard":{"productName":"*鸡*"}}}，搜索出来。

02》需要进行分词的索引建立

URL： es_index_test

{
  "settings": {
    "index": {
      "number_of_shards": "4",
      "number_of_replicas": "1"
    }
  },
  "mappings": {
    "es_index_type_test": {
      "properties": {
        "productId": {
        "type": "text"
        },
        "productName": {
          "type": "text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_max_word"
        }
      }
    }
  }

}

说明：“productName”属性建立索引时，将其设置为进行分词设置。elasticsearch默认针对中文的分词是按照一个中文字符，就是一个分词。例如：文档{"productId":10001,"productName":"山鸡图"}中,会拆分为“山”、“鸡”和“图”三个分词。中文分词的拆分，可以安装ik分词器进行分词拆分。例如：文档{"productId":10001,"productName":"山鸡图"}中，会拆分为“山鸡”和“图”两个分词。中文短句具体拆分成哪些分词是ik分词器的字典来识别的，此字典可以根据实际情况进行调整。

03》忽略大小写的索引建立

URL： es_index_test
{
  "settings": {
    "index": {
      "number_of_shards": "10",
      "number_of_replicas": "3"
    },
    "analysis": {
      "normalizer": {
        "es_normalizer": {
          "filter": [
            "lowercase",
            "asciifolding"
          ],
          "type": "custom"
        }
      }
    }
  },
  "mappings": {
    "es_index_test": {
      "properties": {
        "productId": {
          "type": "text"
        },
        "productName": {
          "type": "keyword",
          "normalizer": "es_normalizer",
          "index": "true"
        }
      }
    }
  }

}

说明：“productName”属性建立索引时，将其设置为忽略大小写。

04》分词查询

URL：es_index_test/es_index_type_test/_analyze

  • ik分词器以“ik_max_word”方式拆分
{
  "analyzer":"ik_max_word",
  "text":"中华人民共和国"

}

  • 结果

{
  "tokens": [
    {
      "end_offset": 7,
      "start_offset": 0,
      "position": 0,
      "type": "CN_WORD",
      "token": "中华人民共和国"
    },
    {
      "end_offset": 4,
      "start_offset": 0,
      "position": 1,
      "type": "CN_WORD",
      "token": "中华人民"
    },
    {
      "end_offset": 2,
      "start_offset": 0,
      "position": 2,
      "type": "CN_WORD",
      "token": "中华"
    },
    {
      "end_offset": 3,
      "start_offset": 1,
      "position": 3,
      "type": "CN_WORD",
      "token": "华人"
    },
    {
      "end_offset": 7,
      "start_offset": 2,
      "position": 4,
      "type": "CN_WORD",
      "token": "人民共和国"
    },
    {
      "end_offset": 4,
      "start_offset": 2,
      "position": 5,
      "type": "CN_WORD",
      "token": "人民"
    },
    {
      "end_offset": 7,
      "start_offset": 4,
      "position": 6,
      "type": "CN_WORD",
      "token": "共和国"
    },
    {
      "end_offset": 6,
      "start_offset": 4,
      "position": 7,
      "type": "CN_WORD",
      "token": "共和"
    },
    {
      "end_offset": 7,
      "start_offset": 6,
      "position": 8,
      "type": "CN_CHAR",
      "token": "国"
    }
  ]

}

  • ik分词器以“ik_smart”方式拆分

{
  "analyzer":"ik_smart",
  "text":"中华人民共和国"

}

  • 结果

{

"tokens": [

    {
      "end_offset": 7,
      "start_offset": 0,
      "position": 0,
      "type": "CN_WORD",
      "token": "中华人民共和国"
    }
  ]

}

  • ES默认

{
  "text":"中华人民共和国"

}

  • 结果

{

  "tokens": [
    {
      "end_offset": 1,
      "start_offset": 0,
      "position": 0,
      "type": "<IDEOGRAPHIC>",
      "token": "中"
    },
    {
      "end_offset": 2,
      "start_offset": 1,
      "position": 1,
      "type": "<IDEOGRAPHIC>",
      "token": "华"
    },
    {
      "end_offset": 3,
      "start_offset": 2,
      "position": 2,
      "type": "<IDEOGRAPHIC>",
      "token": "人"
    },
    {
      "end_offset": 4,
      "start_offset": 3,
      "position": 3,
      "type": "<IDEOGRAPHIC>",
      "token": "民"
    },
    {
      "end_offset": 5,
      "start_offset": 4,
      "position": 4,
      "type": "<IDEOGRAPHIC>",
      "token": "共"
    },
    {
      "end_offset": 6,
      "start_offset": 5,
      "position": 5,
      "type": "<IDEOGRAPHIC>",
      "token": "和"
    },
    {
      "end_offset": 7,
      "start_offset": 6,
      "position": 6,
      "type": "<IDEOGRAPHIC>",
      "token": "国"
    }
  ]

}

说明：以上三种分词拆分的方式不一样，最终产生分词的结果不相同。

05》数据查询-wildcard

URL： es_index_test/es_index_type_test/_search
{
  "query":{"wildcard":{"productName": "山鸡图" }}

}

说明：wildcard种查询方式需要结合方法支持匹配符合，例如：*鸡*,ES会去匹配，在JAVA程序中构建采用。JAVA程序中采用QueryBuilders类的wildcardQuery(String name, Object text)方法。

06》数据查询-match

URL：es_index_test/es_index_type_test/_search
{
  "query":{"match":{"productName": "山鸡图" }}

}

说明：查询时会根据分词进行匹配，例如：“山鸡图”ES拆分为“山鸡”和“图”两个分词到ES搜索引擎内筛选出记录，最后将符合记录的数据返回。返回的记录可能包含，山鸡汤（包含“山鸡”）和山虎图（包含“图”分词）。JAVA程序中采用QueryBuilders类的matchQuery(String name, Object text)方法。

07》数据查询-term

URL： es_index_test/es_index_type_test/_search
{
  "query":{
    "term":{
      "productName":"山鸡图"
    }
  }
}
说明：只有分词完全匹配“山鸡图”这三个字后，才可以返回数据。JAVA程序中采用QueryBuilders类的termQuery(String name, Object value)方法。

08》数据查询-terms

URL： es_index_test/es_index_type_test/_search

{
  "query":{
    "terms":{
      "productName":["山鸡图","山虎图"]
    }
  }

}

说明：分词匹配“山鸡图”和“山虎图”返回记录。JAVA程序中采用QueryBuilders类的termsQuery(String name, String... values)方法。

09》删除查询出来的结果集

URL：es_index_test/es_index_type_test/_delete_by_query

{
  "query":{"wildcard":{"productName": "*鸡*" }}

}

说明：删除产品名称包含“鸡”字文档。

10》elasticsearch中JAVA实例

1、ElasticSearchProperties 
package com.jd.ccc.sys.biz.yb.op.notice.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import lombok.Data;

/**
 * ElasticSearch搜索引擎配置参数 
 * 具体参数的配置信息在yml文件内
 * 
 * @create 2018-5-10
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 *
 */
@Data
@Component
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticSearchProperties {
   /**
    * 集群名
    */
   private String clusterName;
   /**
    * 索引名称
    */
   private String indexName;

   /**
    * 类型名称
    */
   private String typeName;

   /**
    * 主节点
    */
   private String masterNode;

   /**
    * 从节点
    */
   private String slaveNodes;

}
2、ElasticSearchConfig 
package com.jd.ccc.sys.biz.yb.op.notice.config;

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 
 * 初始化一个ES搜索引擎配置
 * 
 * @create 2018-5-10
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 *
 */
@Configuration
@EnableConfigurationProperties(ElasticSearchProperties.class)
public class ElasticSearchConfig {
   
    private static final Logger LOGGER = LoggerFactory.getLogger(ElasticSearchConfig.class);
   
   @Autowired
   private ElasticSearchProperties elasticSearchProperties;
   
   private static final String SYS_PROPERTY="es.set.netty.runtime.available.processors";
   
   private static final String CLUSTER_NAME="cluster.name";
   
   private static final String CLIENT_SNIFF="client.transport.sniff";

   @Bean(name="elasticSearchCluster")
   public Client getClient() {

      System.setProperty(SYS_PROPERTY, "false");
      Settings settings = Settings.builder().put(CLUSTER_NAME, elasticSearchProperties.getClusterName())
            .put(CLIENT_SNIFF, false).build();
      
      TransportClient transportClient = null;
      try {

         String[] masters = elasticSearchProperties.getMasterNode().split(":");
         transportClient = new PreBuiltTransportClient(settings).addTransportAddress(
               new InetSocketTransportAddress(InetAddress.getByName(masters[0]), Integer.parseInt(masters[1])));

         String[] slaveNodes = elasticSearchProperties.getSlaveNodes().split(",");// 逗号分隔

         //遍历从库信息
         for (String node : slaveNodes) {
            String[] ipPort = node.split(":");// 冒号分隔
            if (ipPort.length == 2) {
               transportClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ipPort[0]),
                     Integer.parseInt(ipPort[1])));
            }
         }
         return transportClient;
      } catch (UnknownHostException e) {
         LOGGER.error("ES 客户端连接失败.{}",e);
         return null;
      }
   }

}
3、服务层操作 
/**
 * 查询模糊搜索产品列表的总记录数
 *
 * @param likeProductName
 *            模糊搜索产品名称的关键字
 * @param type
 *            产品类型
 * @return 总记录数
 *
 * @create 2018-5-9
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 */
private Integer queryCount(String likeProductName, String type) {
    BoolQueryBuilder builder=this.builderQueryData(likeProductName, type);
    try {
        SearchResponse searchResponse = elasticSearchCluster.prepareSearch(elasticSearchProperties.getIndexName())
                .setTypes(elasticSearchProperties.getTypeName()).setQuery(builder)
                .setSearchType(SearchType.DEFAULT).get();
        SearchHits hits = searchResponse.getHits();
        return (int)hits.getTotalHits();
    }catch(Exception e) {
        LOGGER.error("Server access failure,{}",e);
        return 0;
    }
}

/**
 * 拼接模糊查询筛选条件
 *
 * @param likeProductName
 *            模糊搜索产品名称的关键字
 * @param type
 *            产品类型
 * @return 筛选条件字符串
 *
 * @create 2018-5-9
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 */
private BoolQueryBuilder builderQueryData(String likeProductName, String type) {
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.must(QueryBuilders.matchQuery(PRODUCT_STATUS, "03"));
    if(StringUtils.isNotBlank(likeProductName)) {
        boolQueryBuilder.must(QueryBuilders.wildcardQuery(PRODUCT_NAME,"*"+likeProductName+"*"));
    }
    // 类型不为空
    if (StringUtils.isNotBlank(type)) {
        String[] types = type.split(",");
        if (types.length == 1) {
            boolQueryBuilder.must(QueryBuilders.matchQuery(INST_TYPE,type));
        } else {
            boolQueryBuilder.must(QueryBuilders.termsQuery(INST_TYPE, types));
        }
    }
    LOGGER.debug("wild card query-->{}",boolQueryBuilder.toString());
    return boolQueryBuilder;
}

/**
 * 模糊查询商品列表数据
 * @param likeProductName 模糊搜索产品名称的关键字
 * @param type 产品类型
 * @param startIndex 开始索引
 * @param pageSize 每页大小
 * @returnW
 *
 * @create 2018-5-9
 * @author zhangqiang200<https://blog.csdn.net/zhangqiang_accp>
 */
private List<String> queryData(String likeProductName, String type, int startIndex, int pageSize) {
    List<String> resultList = new ArrayList<>();
    BoolQueryBuilder builder=this.builderQueryData(likeProductName, type);
    try {

        SearchResponse searchResponse = elasticSearchCluster.prepareSearch(elasticSearchProperties.getIndexName())
                .setTypes(elasticSearchProperties.getTypeName()).setQuery(builder)
                .setSearchType(SearchType.DEFAULT).setFrom(startIndex).setSize(pageSize).get();
        SearchHit[] hits = searchResponse.getHits().getHits();


        for (SearchHit hit : hits) {
            resultList.add(hit.getSourceAsString());
        }
    }catch(Exception e) {
        LOGGER.error("Server access failure,{}",e);
    }

    return resultList;
}

单纯的心
关注
  • 6
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Elasticsearch实现sql的like的功能并测试性能
apply_bomb的博客
06-15 387
不同版本Elasticsearch语法不同本文使用的Elasticsearch是6.8.0原理使用Elasticsearch自带分词器ngram，将句子短语逐字按步长完全拆分出来加入倒排索引中，搜索无需分词直接查询。顺带举例下分词器ngram的分词效果例如句子：你要购买什么结果：见本文下方的"查看某个id的文档的字段拆分出的实际结果"
elasticsearch中忽略大小写模糊搜索实现
tiancityycf的专栏
05-24 6620
参考：https://www.phpmianshi.com/?id=255 背景 有时我们想cms搜索的时候更精准一点，可能会用到wildcard不分词的模糊搜索，但是不分词就有区分大小写搜索的问题 解决方案 1.在es查询时不区分大小写，可以让查询更方便，具体设置如下： { "settings": { "analysis": { "analyzer": { "caseSensitive": { ...
Elasticsearch实现Mysql的Like效果
最新发布
baily_ycl的博客
04-28 1065
为实现模糊匹配的搜索效果，通常有两种方式，其中之一是match_phrase，先说说match_phrase。match_phrase短语匹配会对检索内容进行分词，要求这些分词在被检索内容中全部存在，并且顺序必须一致。默认情况下，这些词必须是连续的。Wildcard Query 是使用通配符表达式进行查询匹配。?，使用?来匹配任意字符。*，使用 * 来匹配 0 或多个字符。"query": {"customerName": "*测试*"
elasticsearch6.6版本 es填坑之路 解决：QueryBuilder同时使用should must时，会影响should的筛选结果！
q18810146167的博客
04-19 2万+
如题，我们经常会使用es的组合查询时，用到must和should 分别对应sql语句里面的 and 和 or； 今天开发的时候，should单独使用的结果没问题，加上must发现should不起作用了。 先上错误的写法： QueryBuilder termQueryBuilder = QueryBuilders.matchPhraseQuery("tablenamecn","*"+key...
elasticsearch类似与sql like查询
weixin_42475367的博客
10-21 1892
https://www.jianshu.com/p/2f8ac4aa9f6d @Field(type = FieldType.Keyword) private String name; QueryBuilders.wildcardQuery("name", "*全*")
Elasticsearch 实现类似SQL语句中like %关键字% 的单纯模糊查询（不进行分词）
gmHappy
01-05 1万+
一、前言 1.1 需求描述 用Elasticsearch 实现类似SQL中like的功能（'%aaa%'），查询数据时，要前后模糊匹配，不要分词（用户输入AAA,检索的结果中AAA需要连在一起，不能是AABA） 1.2 所需知识点 1.2.1 phrase-matching phrase-matching 短语匹配 类似 match 查询， match_phrase 查询首先将查询字符串解析成一个词项列表，然后对这些词项进行搜索，但只保留那些包含全部搜索词项，且位置与搜索词项相同的文档。 比如对于quick
elasticsearch wildcard查询取消大小写
weixin_43632687的博客
09-21 1989
wildcard 取消大小写
elasticsearch进行类似mysql的like查询
m0_67392126的博客
08-16 954
在使用es查询日志的时候，需要按照ip进行模糊查找，经测试match，match_pharse都不能满足需求，下述方式可以满足。
Elasticsearch 查询革新：探索 Wildcard 类型的高效模糊匹配策略
铭毅天下Elasticsearch
12-12 2079
1、背景在生产使用中，Elasticsearch 除了精确匹配的要求，也会有模糊查询的场景。2、解决方案探讨面对这种问题 ，传统的解决方案有两种：2.1 方案一：ngram 分词器使用 ngram 分词器对存入的数据进行精细化的拆分，利用细颗粒度的 token 进行快速的召回。这是一个利用空间换时间的方案，细化查询所需的词根内容，利用精确匹配结果大范围的命中来达到模糊效果。PUTtest-005...
【ES】QueryBuilder构造ES查询条件：精准匹配、模糊搜索、范围查询、and、or
weixin_43091333的博客
04-09 7456
private QueryBuilder getQueryBuilder() { // termsQuery("key", obj1, obj2..) 一次匹配多个值 // matchQuery("key", Obj) 单个匹配, field不支持通配符, 前缀具高级特性 // multiMatchQuery("text", "field1", "field2"..); 匹配多个字段, field有通配符忒行 /...
ES 模糊查询 实现像Mysql like %%那样的模糊查询
qq_41187124的博客
05-11 1674
其中keyName为要匹配的字段名，value为要匹配的字段值。
elasticsearch查询QueryBuilders详解（es7.80）
lililidahaoren的博客
04-24 3126
目录 1 QueryBuilders.matchQuery(“supplierName”,param) 2 QueryBuilders.matchPhraseQuery(“supplierName”,param) 3 QueryBuilders.matchPhrasePrefixQuery(“supplierName”,param) 4 QueryBuilders.termQuery(“supplierName”,param) 5 QueryBuilders.wildcardQuery(“supp
elasticsearch 模糊查询不分词，实现 mysql like
cbaln0的博客
01-29 1万+
一、分词 我们可以先来看下啥叫分词，在es中，分词会对关键词进行一个或者几个分隔，比如输入了 隔壁小白，则会查询到 隔壁、小、白、隔、小壁等关键词有关的文档数据。 而使用过mysql的模糊查询的童鞋们，应该都知道，输入了 隔壁小白，则只会出现 隔壁小白123、321淘宝了压抑122、22445淘宝了压抑等相关的数据。它不会对其中的关键词进行分割 二、不分词使用 es对于不分词，其实主要是 match_phrase的使用。我们平时比较多是使用match，这个是会进行分词的 三、先看下使用match
ElasticSearch如何不分词完全匹配搜索
热门推荐
Haoyugg的博客
08-22 4万+
最近在做一个查询系统，用到了ES，版本是6.1。 场景：通过用户姓名搜索用户列表，名字必须完全匹配。如 输入 “贾跃” 不会检索出”贾跃亭“，输入 ”马云“ 不会检索出马云云。 6.0之前的操作： PUT /&lt;index_name&gt;/_mapping { &lt;type_name&gt;: { ...
elasticsearch实现入库分词，查询不分词，实现like关键字%
向南向北
05-30 1511
实现类似sql关键字匹配like"a%"功能
Elasticsearch实战 | 怎么通过Elasticsearch实现模糊查询？
xd15074483478的博客
11-24 4820
怎么通过elasticsearch实现模糊查询呢？match_phrase和match_phrase_prefix的异同和应用
BoolQueryBuilder 和 wildcardQuery withFilter 查询
robinson_911的专栏
04-30 1万+
利用BoolQueryBuilder的must，should实现精确查找 /** * must，should查找 * @param keyword * @return */ @GetMapping("/blog/search/title") public JsonResult<List<BlogModel>&gt...
es系列:忽略大小写查询
zhuchunyan_aijia的博客
04-11 3012
对于elasticsearch查询忽略大小写的问题，官方给出了一个解决方案，使用normalizer来解决，normalizer是的一个属性，可以对keyword生成的单一term,query_string做进一步的处理，比如lowercase,小写转换，使用方式和自定义分词器有相似之处，需要自定义，具体步骤如下。所以注意:对已有索引中字段,增加normalizer属性, 新增数据或者更新的数据,查询是生效的.但是历史数据, 如果不更新,则不生效的. 所以你需要reindex处理。
elasticsearch 基于ik分词器的分词查询和模糊匹配
朝立的博客
05-05 4145
将查询的内容分解，提取。例如 文档数据库 ，就会被分词器 分解为 文档 ，数据 ，数据库等 查询返回更加有广度。类似 mysql 语法中的 like ‘%value%’此处简单梳理一下最常用的查询。查询会将分词解析出的分词。根据具体字段精确查询内容。ES查询条件 分词查询。类似于百度的分词查询。
spring elasticsearch7 忽略大小写
08-09
在使用Spring集成Elasticsearch7时，可以通过设置索引的映射和查询时使用的分析器来实现忽略大小写的功能。 首先，在创建索引时，可以使用字段的映射设置来指定对应字段的分析器。通过设置分析器为"keyword_lowercase"，可以将字段设置为忽略大小写。例如，以下代码片段演示了如何创建一个忽略大小写的索引： ```java CreateIndexRequest createIndexRequest = new CreateIndexRequest("my_index"); createIndexRequest.settings(Settings.builder() .put("index.analysis.analyzer.default.type", "custom") .put("index.analysis.analyzer.default.tokenizer", "keyword") .put("index.analysis.analyzer.default.filter", "lowercase") .build()); Mapping mapping = new Mapping.Builder() .field(new StringField("my_field") .analyzer("keyword_lowercase")) .build(); createIndexRequest.mapping(mapping); CreateIndexResponse response = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT); ``` 在查询时，我们可以使用Spring Data Elasticsearch来构造查询请求。通过使用`QueryBuilders`类提供的`matchQuery`方法，并指定字段为忽略大小写的分析器，可以实现忽略大小写的查询。例如，以下代码片段演示了如何使用忽略大小写的方式进行查询： ```java QueryBuilder queryBuilder = QueryBuilders.matchQuery("my_field", "value") .analyzer("keyword_lowercase"); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); searchSourceBuilder.query(queryBuilder); SearchRequest searchRequest = new SearchRequest("my_index"); searchRequest.source(searchSourceBuilder); SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT); ``` 通过以上的设置和方法，我们可以在Spring集成Elasticsearch7中实现忽略大小写的功能。这样，无论字段的大小写如何，都可以正确地进行索引和查询操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值