ES工具类ESUtils

最新推荐文章于 2024-04-25 15:39:17 发布
最新推荐文章于 2024-04-25 15:39:17 发布
阅读量9.8k 收藏 2
点赞数 1
分类专栏： ELK 文章标签： ELK 
package com.dm.data.util;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.types.TypesExistsRequest;
import org.elasticsearch.action.admin.indices.flush.FlushRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingResponse;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.transport.NoNodeAvailableException;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.index.Index;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.indices.IndexMissingException;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.sort.FieldSortBuilder;

import com.dm.core.system.SystemParameter;
import com.dm.core.util.CollectionUtils;
import com.dm.core.util.StringUtil;
import com.dm.meta.domain.Column;

/**
 * ES工具类
 * @author ZRH
 *
 */
public class ESUtils {
    static Pattern badChars = Pattern.compile("\\s*[\\s~!\\^&\\(\\)\\-\\+:\\|\\\\\"\\\\$]+\\s*"); 

    private static Client clients = null;

    private ESUtils() {
    }
    /**
     * 关闭对应client
     * @param client
     */
    public static void close(Client client) {
        if (client != null) {
            try {
             client.close();
            } catch (Exception e) {
            }
            client = null;
        }
    }

    public static void flush(Client client, String indexName, String indexType) {
        try{
            client.admin().indices().flush(new FlushRequest(indexName.toLowerCase(), indexType)).actionGet();
        }catch(Exception e){};
    }

    /**
     * 根据默认系统默认配置初始化库,如果已经有连接则使用该连接
     * @return
     */
    public static Client getClient() {

        if(clients!=null) {
            return clients;
        }
        clients = newClient();

        return clients;

    }

    /**
     * 初始化并连接elasticsearch集群，返回连接后的client
     * @return 返回连接的集群的client
     */
    public static Client newClient() {
        String clusterName = SystemParameter.get("es.clusterName", "elasticsearch");
        String _clientTransportSniff = SystemParameter.get("es.clientTransportSniff", "true");
        String _port = SystemParameter.get("es.port", "9300");
        String hostname = SystemParameter.get("es.hostname", "127.0.0.1");
        String hostnames[] = hostname.split(",");

        boolean clientTransportSniff = false;
        try{
            if( !"false".equals(_clientTransportSniff.toLowerCase().trim())) {
                clientTransportSniff = true;
            }
        }catch(Exception e){};
        int port = 9300;
        try{
            port = Integer.parseInt(_port);
        }catch(Exception e){};

        return newClient(clusterName, clientTransportSniff, port, hostnames);

    }

    /**
     * 初始化并连接elasticsearch集群，返回连接后的client
     * @param clusterName 中心节点名称
     * @param clientTransportSniff 是否自动发现新加入的节点
     * @param port 节点端口
     * @param hostname 集群节点所在服务器IP，支持多个
     * @return 返回连接的集群的client
     */
    public static Client newClient(String clusterName, boolean clientTransportSniff, int port, String... hostname) {
        Settings settings = ImmutableSettings.settingsBuilder()
                .put("cluster.name", clusterName)
                .put("client.transport.sniff", clientTransportSniff)
                .build();

        TransportClient transportClient = new TransportClient(settings);
        if(hostname!=null){
            for(String host: hostname) {
                transportClient.addTransportAddress(new InetSocketTransportAddress(host, port));
            }
        }
        return transportClient;
    }

    public static boolean indicesExists(Client client, String indexName){
        IndicesExistsRequest ier = new IndicesExistsRequest();
        ier.indices(new String[]{indexName.toLowerCase()});

        return client.admin().indices().exists(ier).actionGet().isExists();
    }

    public static boolean typesExists(Client client, String indexName, String indexType){
        if(indicesExists(client, indexName)) {
            TypesExistsRequest ter = new TypesExistsRequest(new String[]{indexName.toLowerCase()}, indexType);
            return client.admin().indices().typesExists(ter).actionGet().isExists();
        }
        return false;
    }

    /**
     * 根据索引数据id删除索引
     * @param indexName 索引名称
     * @param indexType 索引类型
     * @param id 对应数据ID
     */
    public static void deleteIndex(Client client, String indexName, String indexType, String id){
        try {
            client.prepareDelete(indexName.toLowerCase(), indexType.toLowerCase(), id).execute().actionGet();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据索引名称删除索引
     * @param indexName 索引名称 
     */
    public static void deleteIndex(String indexName){
        try {
            IndicesExistsRequest ier = new IndicesExistsRequest();
            ier.indices(new String[]{indexName.toLowerCase()});

            boolean exists = getClient().admin().indices().exists(ier).actionGet().isExists();
            if(exists){
                getClient().admin().indices().prepareDelete(indexName.toLowerCase()).execute().actionGet();
            }

        }
        catch(IndexMissingException ime){}
    }

    public static SearchHits search(String indexName, List<String> indexTypes, QueryBuilder query, List<FieldSortBuilder> sortBuilders, int from, int size) throws NoNodeAvailableException, IndexMissingException {
        if(getClient() == null ) {
            return null;
        }
        indexName = indexName.toLowerCase();

        // 去掉不存在的索引
        IndicesExistsRequest ier = new IndicesExistsRequest();
        ier.indices(new String[]{indexName});
        boolean exists = getClient().admin().indices().exists(ier).actionGet().isExists();
        if(exists){
            getClient().admin().indices().open(new OpenIndexRequest(indexName)).actionGet();
        }else{
            Index index = new Index(indexName);
            //throw new IndexMissingException(index);
            return null;
        }

        try {
            getClient().admin().indices().refresh(new RefreshRequest(indexName)).actionGet();
        } catch (IndexMissingException e) {
            e.printStackTrace();
        }

        SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(indexName);

        if(indexTypes != null && indexTypes.size() > 0) {
            String[] types = new String[indexTypes.size()];
            for(int i=0; i<indexTypes.size(); i++) {
                types[i] = indexTypes.get(i).toLowerCase();
            }
            searchRequestBuilder.setTypes(types);
        }

        searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
        searchRequestBuilder.setFrom(from);
        searchRequestBuilder.setSize(size);
        searchRequestBuilder.setExplain(false);
        searchRequestBuilder.setQuery(query);
        if(sortBuilders!=null && sortBuilders.size()>0){
            for(FieldSortBuilder sortBuilder: sortBuilders){
                searchRequestBuilder.addSort(sortBuilder);
            }
        }

        return searchRequestBuilder.execute().actionGet().getHits();
    }

    /**
     * 查询数据
     * @param indexName 索引名称
     * @param indexType 索引类型
     * @param id 数据id
     * @return 如果不存在，返回<code>null</code>
     */
    public static Map<String, Object> query(String indexName, String indexType, String id) {
        if(getClient() == null ) {
            return null;
        }
        if( StringUtil.isEmpty(indexName) || StringUtil.isEmpty(indexType) ||  StringUtil.isEmpty(id)) {
            return null;
        }
        indexName = indexName.toLowerCase();
        indexType = indexType.toLowerCase();

        IndicesExistsRequest ier = new IndicesExistsRequest();
        ier.indices(new String[]{indexName});
        boolean exists = getClient().admin().indices().exists(ier).actionGet().isExists();
        if(!exists){
            // 索引不存在
            return null; 
        }

        getClient().admin().indices().open(new OpenIndexRequest(indexName)).actionGet();
        getClient().admin().indices().refresh(new RefreshRequest(indexName)).actionGet();

        GetRequest gr = new GetRequest(indexName, indexType, id);

        ActionFuture<GetResponse> future = getClient().get(gr);
        GetResponse response = future.actionGet();
        return swapResult(response);
    }

    /**
     * 初始化索引
     * @param client
     * @param indexName
     * @param indexType
     * @param cols
     * @return 初始化成功,返回true；否则返回false
     * @throws Exception
     */
    public static boolean initIndex(Client client, String indexName, String indexType, List<Column> cols) throws Exception {
        if(StringUtil.isEmpty(indexName) || StringUtil.isEmpty(indexType) || CollectionUtils.isEmpty(cols)) {
            return false;
        }

        indexName = indexName.toLowerCase();
        indexType = indexType.toLowerCase();

        if(indicesExists(client, indexName)) {
             OpenIndexRequestBuilder openIndexBuilder = new OpenIndexRequestBuilder(client.admin().indices());
             openIndexBuilder.setIndices(indexName).execute().actionGet();
        }else{
             client.admin().indices().prepareCreate(indexName).execute().actionGet();
        }

        TypesExistsRequest ter = new TypesExistsRequest(new String[]{indexName.toLowerCase()}, indexType);
        boolean typeExists = client.admin().indices().typesExists(ter).actionGet().isExists();

        if(typeExists) {
            return true;
        }

        XContentBuilder mapping = jsonBuilder()
                .startObject()
                .startObject(indexType)
                .startObject("properties");
//      mapping.startObject("_all").field("type", "string").field("store", "yes").field("term_vector", "no").field("analyzer", "ik").endObject();
        for (Column col : cols) {
            //(varchar、numeric、timestamp)
            String colName = col.getName().toLowerCase();
            String colType = col.getData_type().toLowerCase().trim();
            if("varchar".equals(colType)) {
                mapping.startObject(colName).field("type", "string").field("store", "yes").field("analyzer", "ik").field("include_in_all", true).endObject();
            }else if("numeric".equals(colType)) {
                if(col.getData_scale()>0) {
                    mapping.startObject(colName).field("type", "float").field("index", "not_analyzed").field("include_in_all", false).endObject();
                }else{
                    mapping.startObject(colName).field("type", "long").field("index", "not_analyzed").field("include_in_all", false).endObject();
                }
            }else if("timestamp".equals(colType)) {
                mapping.startObject(colName).field("type", "date").field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd").field("index", "not_analyzed").field("include_in_all", false).endObject();
            }else {
                mapping.startObject(colName).field("type", "string").field("store", "yes").field("analyzer", "ik").field("include_in_all", true).endObject();
            }

        }
        mapping.endObject()
                .endObject()
                 .endObject();

System.out.println(mapping.string());

        PutMappingRequest mappingRequest = Requests.putMappingRequest(indexName).type(indexType).source(mapping);
        PutMappingResponse response = client.admin().indices().putMapping(mappingRequest).actionGet();

        return response.isAcknowledged();
    }

//  public static SearchHits search(String indexName, String indexType, String[] keywords, String[] channelIdArr, int from, int size) throws NoNodeAvailableException, IndexMissingException {
//      if(getClient() == null ) {
//          return null;
//      }
//      
//      // 去掉不存在的索引
//      IndicesExistsRequest ier = new IndicesExistsRequest();
//      ier.indices(new String[]{indexName});
//      boolean exists = getClient().admin().indices().exists(ier).actionGet().isExists();
//      if(exists){
//          getClient().admin().indices().open(new OpenIndexRequest(indexName)).actionGet();
//      }else{
//          Index index = new Index(indexName);
//          throw new IndexMissingException(index);
//      }
//      
//      try {
//          getClient().admin().indices().refresh(new RefreshRequest(indexName)).actionGet();
//      } catch (IndexMissingException e) {
//          e.printStackTrace();
//      }
//      
//      SearchRequestBuilder searchRequestBuilder = getClient().prepareSearch(indexName);
//      
//      searchRequestBuilder.setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
//      searchRequestBuilder.setFrom(from);
//      searchRequestBuilder.setSize(size);
//      searchRequestBuilder.setExplain(true);
//      
//      BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//      
//      StringBuffer totalKeys = new StringBuffer();
//      for(String keyword: keywords) {
//          totalKeys.append(keyword);
//      }
//      
//      if(!totalKeys.toString().equals("*")){
//          for(String keyword: keywords) {
//              if( keyword == null || keyword.trim().length() == 0 ) {
//                  continue;
//              }
//              keyword = badChars.matcher(keyword).replaceAll("");
//              if( keyword == null || keyword.trim().length() == 0 ) {
//                  continue;
//              }
//              
//              if(keyword.indexOf("*")!=-1 || keyword.indexOf("×")!=-1 || keyword.indexOf("?")!=-1 || keyword.indexOf("？")!=-1){
//                  keyword = keyword.replaceAll("×", "*").replaceAll("？", "?");
//                  BoolQueryBuilder subBoolQuery = QueryBuilders.boolQuery();
//                  for(String indexColumnName: Content.indexColumnNames) {
//                      subBoolQuery.should(QueryBuilders.wildcardQuery(indexColumnName.toLowerCase(), keyword));
//                  }
//                  boolQuery.must(subBoolQuery);
//              }else{
//                  QueryStringQueryBuilder qb = QueryBuilders.queryString("\""+keyword+"\""); 
//                  boolQuery.must(qb);
//              }
//          }
//      }else {
//          //boolQuery.should(QueryBuilders.queryString("*"));
//      }
//      
//      if(channelIdArr!=null && channelIdArr.length>0){
//          TermsQueryBuilder inQuery = QueryBuilders.inQuery("channelid_", channelIdArr);
//          boolQuery.must(inQuery);
//      }
//      
//      searchRequestBuilder.setQuery(boolQuery);
//      
//      
//      return searchRequestBuilder.execute().actionGet().getHits();
//  }

    public static String preReadString(String read, int maxLength) {
        if(read==null||read.trim().length()==0){
            return "";
        }
        read = read.trim();

        if(read.length()<=maxLength){
            return read;
        }

//      if(keywords!=null && keywords.length>0){
//          for(String keyword: keywords) {
//              if( keyword == null || keyword.trim().length() == 0 ) {
//                  continue;
//              }
//              keyword = badChars.matcher(keyword).replaceAll("");
//              int loc = read.indexOf(keyword);
//              if(loc != -1){
//                  if(loc <= maxLength) {
//                      return read.substring(0, maxLength);
//                  }else{
//                      int aft = read.length()-loc;
//                      if(aft>(maxLength/2)){
//                          return read.substring(loc-maxLength/2, loc+maxLength/2+1);
//                      }else{
//                          return read.substring(loc-maxLength+aft, loc+aft);
//                      }
//                  }
//              }
//          }
//      }
        return read.substring(0, maxLength);

    }

    public static List<Map<String, Object>> swapResult(SearchHits hits) {
        List<Map<String, Object>> datas = new ArrayList<Map<String, Object>>();

        if(hits == null || hits.getTotalHits() <= 0) {
            return datas;
        }

        for(int i=0; i<hits.hits().length; i++) {
            SearchHit hit = hits.getAt(i);

            Map<String, Object> rowData = hit.sourceAsMap(); 
            rowData.put("_index", hit.getIndex());
            rowData.put("_type", hit.getType());
            rowData.put("_id", hit.getId());

            datas.add(rowData);
        }

        return datas;
    }

    public static Map<String, Object> swapResult(GetResponse response) {
        if(response == null || !response.isExists()) {
            return null;
        }

        Map<String, Object> rowData = response.getSourceAsMap();
        rowData.put("_index", response.getIndex());
        rowData.put("_type", response.getType());
        rowData.put("_id", response.getId());

        return rowData;
    }


}
jj心静自然禅
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
elasticsearch通用工具类
weixin_45985053的博客
07-19 3010
本文中使用到的elasticsearch版本6.7，但实际上也支持es7.x以上版本，因为主要是对springboot提供的ElasticsearchRestTemplate提供的API做的二次封装。外部业务模块可引入es-apijarmaven依赖，由Jar提供的入口，通过httpClient或feign调用(springcloud分布式项目)到es-server服务上的es工具类，得到需要的数据。可通过must嵌套一层解决。这几天写了一个关于es的工具类，主要封装了业务中常用es的常用方法。...
elasticsearch工具包ESUtils.java
08-10
elasticsearch搜索工具包，常用接口封装，可直接用于项目进行基于elasticsearch的搜索，分页、查询、初始化、创建索引、以及索引的增、删、改、查都封装成普通接口。
【Elasticsearch＜一＞✈️✈️】简单安装使用以及各种踩坑
最新发布
只会CV也没关系的
04-25 1272
本地实现 Elasticsearch、kibana 管理工具、IK 分词器 的安装部署以及初步使用（以及填坑策略）
# ElasticSearchUtils 工具类
不积跬步，无以至千里；不积小流，无以成江海
01-27 1302
ElasticSearchUtils 工具类 Es 配置详见博客https://blog.csdn.net/qq_37248504/article/details/108247875 EsUtils工具类 public class EsUtils { private static final Logger logger = LoggerFactory.getLogger(EsUtils.class); /** * 判断索引是否存在 * * @para
es工具类（自定义）
m0_50008952的博客
01-05 1177
public class EsUtils { /** * 查询满足条件的数据总条数 * */ public static long queryCount(RestHighLevelClient client,QueryBuilder queryBuilder,String indices){ long count =0; CountRequest countRequest = new CountRequest(); cou.
Elasticsearch教程(27) ES拼接查询条件的工具类
Java Spring Elasticsearch
12-29 5086
ES拼接查询条件的工具类一、前言二、工具类三、测试四、总结 一、前言 在大多数公司产线Elasticsearch还在6.X的时候，ES已经更新到7.10.1了，这更新速度。 目前我手上的项目也做到一套工具类兼容ES6.1到ES7.9+。我用的是原生的ES6.8.12的Java API来实现的工具类。目前功能上线几个月没有出过错。 工作中用ES查询大于插入，所以代码里到处都是拼接ES查询条件的语句，ES本身的Java API已经很强大了，我们利用BoolQueryBuilder和QueryBuilders可以
Elasticsearch工具类
04-08
Elasticsearch工具类是开发中常见的一种抽象封装，旨在简化与Elasticsearch数据库的交互，提高代码的可读性和可维护性。Elasticsearch是一种基于Lucene的分布式、RESTful搜索和分析引擎，广泛用于实时大数据分析和...
ElasticSearchPoolUtil.java(es连接池工具类)
09-11
使用过Elasticsearch RestFul API的都知道，在Java端使用是ES服务需要创建Java Client，但是每一次连接都实例化一个client，对系统的消耗很大，而且最令人头疼的是它的连接非常慢。所以为了解决上述问题并提高client...
Elasticsearch Java api 工具类
12-15
Elasticsearch Java api 工具类，包括增删改查索引，增删改查数据等代码，欢迎下载
Elasticsearch java工具类
01-18
本项目是针对Elasticsearch 5.x版本的Java工具类，旨在简化与SpringBoot集成时的开发流程，通过封装常用API和自定义注解，实现开箱即用的功能。 首先，让我们深入理解Elasticsearch的Java API。Elasticsearch提供了...
esutil工具类
05-16
es 工具类 elasticsearches 工具类 elasticsearches 工具类 elasticsearches 工具类 elasticsearch
Elasticsearch7.6和6.61配置和使用
hangge的学习基地
04-11 656
Spring Data Elasticsearch使用1.Elasticsearch新建一个用户leyou上传并解压修改配置运行错误1：内核过低错误2：文件权限不足错误3：线程数不够错误4：进程虚拟内存重启终端窗口启动kibana配置运行控制台ik分词器安装测试Rest风格API客户端APIElasticsearch学习笔记2.操作索引3.查询4.聚合aggregations5.Spring Da...
es 7.0 工具类
weixin_44583135的博客
11-04 645
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import lombok.extern.slf4j.Slf4j; import org.apache.lucene.search.join.ScoreMode; import org.elasticsearch.action.ActionListener; import org.e.
ElasticSearch学习笔记
可小辉的博客
01-08 674
目录 1. ElasticSearch概述 2. ES与Solr的差别 2.1. Solr简介 2.2. Lucene简介 2.3. ES VS Solr 3. ElasticSearch 安装 4. Kibana安装 5. ES核心概念 6. IK分词器 7. Restful风格说明 8. 关于文档的基本操作 9. 集成SpringBoot 10. 实战：模拟全文搜索-京东搜索 1. ElasticSearch概述 2. ES与Solr的差别 2.1. Solr简介
spring boot集成 elasticsearch集群 之REST Client
weixin_43174967的博客
05-29 5166
elasticsearch 集群的搭建 和 概念这里不说可以参考以下地址: https://www.cnblogs.com/chenmc/tag/elasticSearch/ ,主要记录下,自己工作中要去集成es 时,选用操作es的方式 三种方式 操作es的主要有三种方式: 第一种 :spring date es ,这种方式简单,多用于一些简单业务,但因为方法都帮你封装好了,灵活度不高!(复杂业...
Elasticsearch（二）：使用JAVA API实现简单查询、聚合查询
Super涌
04-11 1万+
使用java api对ES进行查询操作
Java操作ES
热门推荐
Life is for sharing的博客
01-10 1万+
1. 集群名称 2. 嗅探功能 3. 查询类型SearchType 4. 分页压力 5. 超时timeout 6. maven依赖 7. Java代码 Java操作ElasticSearch 1. 集群名称 默认集群名为elasticsearch，如果集群名称和指定的不一致则在使用节点资源时会报错。 2. 嗅探功能 通过client.transport.sniff启动嗅探...
ElasticSearch工具类
04-16
Elasticsearch是一个开源的分布式搜索和分析引擎，它被广泛应用于全文搜索、日志分析、数据可视化等领域。Elasticsearch提供了丰富的API和功能，可以方便地进行数据索引、搜索、聚合和分析。 在使用Elasticsearch时，可以使用Java编写工具类来简化与Elasticsearch的交互。下面是一个简单的Elasticsearch工具类的示例： ```java import org.elasticsearch.action.search.SearchResponse; import org.elasticsearch.client.RequestOptions; import org.elasticsearch.client.RestClient; import org.elasticsearch.client.RestHighLevelClient; import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.search.builder.SearchSourceBuilder; import org.elasticsearch.search.sort.SortOrder; import java.io.IOException; public class ElasticsearchUtils { private RestHighLevelClient client; public ElasticsearchUtils() { client = new RestHighLevelClient( RestClient.builder(new HttpHost("localhost", 9200, "http"))); } public SearchResponse search(String index, String field, String keyword) throws IOException { SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); sourceBuilder.query(QueryBuilders.matchQuery(field, keyword)); sourceBuilder.sort(field, SortOrder.DESC); SearchRequest searchRequest = new SearchRequest(index); searchRequest.source(sourceBuilder); return client.search(searchRequest, RequestOptions.DEFAULT); } public void close() throws IOException { client.close(); } } ``` 上述示例中的工具类使用了Elasticsearch的Java高级客户端（RestHighLevelClient）来与Elasticsearch进行交互。其中，`search`方法用于执行搜索操作，`close`方法用于关闭与Elasticsearch的连接。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值