ElasticSearchLinux安装和springboot整合的记录和遇到的问题

已于 2024-03-12 14:46:38 修改
阅读量1.1k 收藏 10
点赞数 9
文章标签： spring boot 后端 java
于 2024-03-11 17:01:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mou_O/article/details/136625927
版权

前面整合遇到的一些问题有的记录在下面了，有的当时忘了记录下来，希望下面的能帮到你们

1：Linux安装ES

下载安装：
参考文章：连接1

连接2

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.12.2-linux-x86_64.tar.gz

解压：tar -zxvf elasticsearch-8.12.2-linux-x86_64.tar.gz
这里注意，在bin目录下启动报错，因为不能通过root账户启动，需要新建账户

创建新用户给ES使用：adduser els
修改密码：echo 123456 | passwd --stdin els 或者：sudo passwd newpassword
然后将解压的es 目录赋予新创建的用户
sudo chown -R els:els /home/cdszwy/elasticsearch/elasticsearch-8.12.2
切换到新创建用户
su - els
然后进入解压目录的/bin 执行 ./elasticsearch -d 运行es
然后 执行curl http://127.0.0.1:9200显示

先要在防火墙打开该端口才能访问

安装遇到的问题：

  • Password: su: Permission denied

添加用户修改密码后，切换到新用户环境，再切换到root环境提示异常：Password: su: Permission denied
使用su命令时输入密码后提示权限限制，确认密码是正确的
即：

su root
Password:
su: permission denied

解决：
1.改变用户分组，将用户添加进wheel分组
#语法
#usermod [-G] [GroupName] [UserName]
usermod -G wheel username

2.修改/etc/pam.d/su
注释行：auth required pam_wheel.so use_uid

3：查看当前用户分组：
#语法
#id username
id els
#执行结果如下
uid=1001(els) gid=1001(els) groups=1001(els),10(wheel)

  • vm.max_map_count [65530] is too low

解决vm.max_map_count [65530] is too low问题
编辑 /etc/sysctl.conf 文件来永久更改该值。在文件的末尾添加下面一行并保存：vm.max_map_count=262144
然后可以通过运行以下命令重新加载配置文件：sudo sysctl -p

修改ES的配置：
修改配置：elasticsearch.yml

绑定到0.0.0.0，允许任何ip来访问

network.host: 0.0.0.0

#浏览器可直接访问

xpack.security.http.ssl:
enabled: false

末尾添加：

http.cors.enabled: true
http.cors.allow-origin: "*"
http.cors.allow-headers: Authorization

修改配置：jvm.options

-Xms1g
-Xmx1g

设置用户名密码：
在bin目录下执行：./elasticsearch-reset-password -u elskib -i
添加新用户给kibana使用
添加用户：./elasticsearch-users useradd elskib
分配绝俗： ./elasticsearch-users roles -a superuser elskib
账号：elskib
密码：qwe123

在启动ES
使用命令查看进程：
查看是否成功：ps -ef|grep elastic

IK分词器安装：https://github.com/infinilabs/analysis-ik/releases
下载再执行
在bin目录下执行命令：./elasticsearch-plugin install file:///home/cdszwy/elasticsearch/elasticsearch-analysis-ik-8.12.2.zip

2.springboot 整合ES

这里有一个区别：下面会有两种快速接口调用ES，分别是：使用RestHighLevelClient，使用ElasticsearchClient，先讲使用RestHighLevelClient

使用RestHighLevelClient

  • 引入依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

配置ES基础信息：

es:
  ip: 192.34.21.129
  port: 9200
  username: elskib
  password: qwe123

添加Java配置：

@Configuration
public class ElasticSearchConfig {

    @Value("${es.ip}")
    private String esIp;

    @Value("${es.port}")
    private Integer port;

    @Value("${es.username}")
    private String username;

    @Value("${es.password}")
    private String password;

    /**
     * 注册 rest高级客户端
     * @date   2024/3/5 16:01
     **/
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        // 创建CredentialsProvider，并设置用户名密码
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(username,password));
        // 创建RestHighLevelClient实例，并设置CredentialsProvider
        return new RestHighLevelClient(
                RestClient.builder(new HttpHost(esIp, port, "http"))
                        .setHttpClientConfigCallback(httpAsyncClientBuilder ->
                                httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider)
                        )
        );
    }

添加方法的实现类：


import cn.test.vo.DocumentInfoPageVo;
import cn.test.vo.DocumentInfoVo;
import cn.hutool.json.JSONUtil;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchScrollRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.Scroll;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.elasticsearch.search.suggest.completion.CompletionSuggestion;
import org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Description: 多条件操作文档
 * @version 1.0
 * @ClassName RestHighLevelServiceImpl
 * @date 2024/3/7 11:12
 **/
@Service
public class RestHighLevelServiceImpl {

    @Autowired
    private RestHighLevelClient restHighLevelClient;


    /**
     * 判断索引是否存在
     */
    public Boolean indexExists(String indexName) throws Exception {
        GetIndexRequest request = new GetIndexRequest(indexName);
        return restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
    }

    /**
     * 创建 ES 索引
     */
    public CreateIndexResponse createIndex(String indexName, Settings.Builder settings, XContentBuilder mappings) throws Exception {
        //将 Settings 和 Mappings 封装到一个Request 对象中
        CreateIndexRequest request = new CreateIndexRequest(indexName)
                .settings(settings)
                .mapping(mappings);

        //通过 client 对象去连接ES并执行创建索引
        return restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
    }

    /**
     * 批量创建 ES 文档
     */
    public IndexResponse createDoc(String indexName, String id, String json) throws Exception {
        //准备一个Request对象
        IndexRequest request = new IndexRequest(indexName);
        //手动指定ID
        request.id(id);
        request.source(json, XContentType.JSON);
        //request.opType(DocWriteRequest.OpType.INDEX); 默认使用 OpType.INDEX，如果 id 重复，会进行  覆盖更新， resp.getResult().toString() 返回 UPDATE
        //request.opType(DocWriteRequest.OpType.CREATE); 如果ID重复，会报异常 =>  document already exists

        //通过 Client 对象执行添加
        return restHighLevelClient.index(request, RequestOptions.DEFAULT);
    }

    /**
     * 批量创建 ES 文档
     *
     * @param jsonMap Key = id,Value =  json
     */
    public BulkResponse batchCreateDoc(String indexName, Map<String, String> jsonMap) throws Exception {
        //准备一个Request对象
        BulkRequest bulkRequest = new BulkRequest();
        for (String id : jsonMap.keySet()) {
            IndexRequest request = new IndexRequest(indexName)
                    //手动指定ID
                    .id(id)
                    .source(jsonMap.get(id), XContentType.JSON);
            bulkRequest.add(request);
        }

        //通过 Client 对象执行添加
        return restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

    /**
     * 自动补全 根据用户的输入联想到可能的词或者短语
     *
     * @param indexName 索引名称
     * @param field     搜索条件字段
     * @param keywords  搜索关键字
     * @param size      匹配数量
     * @return
     * @throws Exception
     */
    public List<String> suggest(String indexName, String field, String keywords, int size) throws Exception {
        //定义返回
        List<String> suggestList = new ArrayList<>();
        //构建查询请求
        SearchRequest searchRequest = new SearchRequest(indexName);
        //通过查询构建器定义评分排序
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
        //构造搜索建议语句,搜索条件字段
        CompletionSuggestionBuilder completionSuggestionBuilder = new CompletionSuggestionBuilder(field);
        //搜索关键字
        completionSuggestionBuilder.prefix(keywords);
        //去除重复
        completionSuggestionBuilder.skipDuplicates(true);
        //匹配数量
        completionSuggestionBuilder.size(size);
        searchSourceBuilder.suggest(new SuggestBuilder().addSuggestion("article-suggest", completionSuggestionBuilder));
        //article-suggest为返回的字段，所有返回将在article-suggest里面，可写死,sort按照评分排序
        searchRequest.source(searchSourceBuilder);
        //定义查找响应
        SearchResponse suggestResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //定义完成建议对象
        CompletionSuggestion completionSuggestion = suggestResponse.getSuggest().getSuggestion("article-suggest");
        List<CompletionSuggestion.Entry.Option> optionsList = completionSuggestion.getEntries().get(0).getOptions();
        //从optionsList取出结果
        if (!CollectionUtils.isEmpty(optionsList)) {
            optionsList.forEach(item -> suggestList.add(item.getText().toString()));
        }
        return suggestList;
    }

    /**
     * 前缀查询，可以通过一个关键字去指定一个Field的前缀，从而查询到指定的文档
     */
    public SearchResponse prefixQuery(String indexName, String searchField, String searchKeyword) throws Exception {

        //创建Request对象
        SearchRequest request = new SearchRequest(indexName);

        //XX开头的关键词查询
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.prefixQuery(searchField, searchKeyword));
        request.source(builder);
        //执行查询
        return restHighLevelClient.search(request, RequestOptions.DEFAULT);
    }

    /**
     * 通过 QueryBuilder 构建多字段匹配如：QueryBuilders.multiMatchQuery("人工智能","title","content")
     * multi_match => https://www.cnblogs.com/vipsoft/p/17164544.html
     */
    public SearchResponse search(String indexName, QueryBuilder query, int currPage, int pageSize) throws Exception {
        SearchRequest request = new SearchRequest(indexName);
        SearchSourceBuilder builder = new SearchSourceBuilder();
        int start = (currPage - 1) * pageSize;
        builder.from(start);
        builder.size(pageSize);
        builder.query(query);
        request.source(builder);
        return restHighLevelClient.search(request, RequestOptions.DEFAULT);
    }




    /**
     * Description：根据条件查询文档信息
     * 分页问题：《不能实现跳转分页》
     * @date   2024/3/7 11:19
     * @param  indexName 索引名称
     * @param  queryBuilder 查询条件
     * @param  pageSize 每页数量
     * @param  page 页码
     * @param  scrollId 下一页的请求ID
     * @return List<DocumentInfo> 返回所有文档信息
     **/
//    @Override
    public Object getDocPageList(String indexName, QueryBuilder queryBuilder, Integer pageSize, Integer page, String scrollId) throws IOException {
        List<Object> list = new ArrayList<>();
        //指定scroll信息,2分钟过期
        //失效时间为2min
        Scroll scroll = new Scroll(TimeValue.timeValueMinutes(2));
        Long totalCount = null;
        //首次查询scrollId为空
        if(StringUtils.isEmpty(scrollId)){
            //指定搜索索引
            SearchRequest searchRequest = new SearchRequest(indexName);
            //封存快照
            searchRequest.scroll(scroll);
            //指定条件对象
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            //指定查询条件
            sourceBuilder.size(pageSize);
            sourceBuilder.sort("reportDate", SortOrder.DESC);
            sourceBuilder.query(queryBuilder);
            searchRequest.source(sourceBuilder);
            //参数 1:搜索请求对象 参数2: 请求配置对象 返回值:查询结果对象
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
            //计算总数量
            totalCount = searchResponse.getHits().getTotalHits().value;
//            //得到总页数
//            page = (int) Math.ceil((float) totalCount / 2);
            //多次遍历分页，获取结果
            scrollId = searchResponse.getScrollId();
            SearchHit[] hits = searchResponse.getHits().getHits();
            for (SearchHit hit : hits) {
                System.out.println("id: "+hit.getId()+" source: "+hit.getSourceAsString());
                list.add(JSONUtil.toBean(JSONUtil.parseObj(hit.getSourceAsString()), Object.class));
            }
        } else {
            System.out.println("第二次查询");
            //TODO 只能连续分页查询，不能进行分页跳转查询
            //获取到该id
            SearchScrollRequest searchScrollRequest = new SearchScrollRequest(scrollId);
            searchScrollRequest.scroll(scroll);
            SearchResponse response = restHighLevelClient.scroll(searchScrollRequest, RequestOptions.DEFAULT);
            //打印数据
            SearchHits searchHits = response.getHits();
            scrollId = response.getScrollId();

            for (SearchHit hit : searchHits) {
                System.out.println("id: "+hit.getId()+" source: "+hit.getSourceAsString());
                list.add(JSONUtil.toBean(JSONUtil.parseObj(hit.getSourceAsString()), Object.class));
            }
        }
        Object vo = new Object();
        vo.setTotal(totalCount);
//        vo.setScrollId(scrollId);
        vo.setList(list);
        return vo;
    }
}

这里的Object可以替换为你的实体类，想要解析的对象

使用ElasticsearchClient

  • 添加依赖：
        <!-- Elasticsearch8.12版本(Java API Client)，使用ElasticsearchClient-->
        <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.12.2</version>
            <exclusions>
                <exclusion>
                    <artifactId>jakarta.json-api</artifactId>
                    <groupId>jakarta.json</groupId>
                </exclusion>
            </exclusions>
        </dependency>

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

        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.1.1</version>
        </dependency>
  • 添加配置
package cn.test.configs;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

/**
 * Description: es配置累
 * @version 1.0
 * @ClassName ElasticSearchConfig
 * @date 2024/3/5 15:58
 **/
@Configuration
public class ElasticSearchConfig {

    @Value("${es.ip}")
    private String esIp;

    @Value("${es.port}")
    private Integer port;

    @Value("${es.username}")
    private String username;

    @Value("${es.password}")
    private String password;


    @Bean
    public ElasticsearchClient esRestClientWithCred(){
        final String scheme = "http";
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 配置连接ES的用户名和密码，如果没有用户名和密码可以不加这一行
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
        RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(esIp, port, scheme))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                        return httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                    }
                });
        RestClient restClient = restClientBuilder.build();
        ElasticsearchTransport transport = new RestClientTransport(
                restClient, new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);
    }

    /**
     * 异步方式
     *
     * @return
     */
    @Bean
    public ElasticsearchAsyncClient elasticsearchAsyncClient() {
        HttpHost[] httpHosts = toHttpHost();
        RestClient restClient = RestClient.builder(httpHosts).build();
        RestClientTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
        return new ElasticsearchAsyncClient(transport);
    }


    /**
     * 解析配置的字符串hosts，转为HttpHost对象数组
     *
     * @return
     */
    private HttpHost[] toHttpHost() {
        if (!StringUtils.hasLength(esIp)) {
            throw new RuntimeException("invalid elasticsearch configuration. elasticsearch.hosts不能为空！");
        }

        // 多个IP逗号隔开
        String[] hostArray = esIp.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], port, "http");
            httpHosts[i] = httpHost;
        }

        return httpHosts;
    }
}
  • 实现类

索引操作

import cn.test.service.ElasticSearchIndexService;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.mapping.Property;
import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
import co.elastic.clients.elasticsearch.indices.*;
import co.elastic.clients.util.ObjectBuilder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.HashMap;
import java.util.function.Function;

/**
 * Description: ES索引操作
 * @version 1.0
 * @ClassName ElasticSearchIndexServiceImpl
 * @date 2024/3/6 14:05
 **/
@Service
@Slf4j
public class ElasticSearchIndexServiceImpl implements ElasticSearchIndexService {

    @Autowired
    private ElasticsearchClient elasticsearchClient;


    /**
     * Description：根据索引名称创建索引
     * @date   2024/3/6 14:09
     * @param  name 索引名称
     **/
    @Override
    public void createIndex(String name) throws IOException {
        //ApplicationContext applicationContext;
        CreateIndexResponse response = elasticsearchClient.indices().create(c -> c.index(name));
        log.info("createIndex方法，acknowledged={}", response.acknowledged());
    }

    /**
     * Description：索引创建
     * @date   2024/3/6 14:15
     * @param  name 索引名称
     * @param  settingFn 索引属性设置
     * @param  mappingFn mapping属性设置
     **/
    @Override
    public void createIndex(String name,
                            Function<IndexSettings.Builder, ObjectBuilder<IndexSettings>> settingFn,
                            Function<TypeMapping.Builder, ObjectBuilder<TypeMapping>> mappingFn) throws IOException {
        CreateIndexResponse response = elasticsearchClient
                .indices()
                .create(c -> c
                        .index(name)
                        .settings(settingFn)
                        .mappings(mappingFn)
                );
        log.info("createIndex方法，acknowledged={}", response.acknowledged());
    }

    /**
     * Description：根据索引名称删除索引
     * @date   2024/3/6 14:10
     * @param  name 索引名称
     **/
    @Override
    public void deleteIndex(String name) throws IOException {
        DeleteIndexResponse response = elasticsearchClient.indices().delete(c -> c.index(name));
        log.info("deleteIndex方法，acknowledged={}", response.acknowledged());
    }

    /**
     * Description：根据索引名称设置mapping
     * @date   2024/3/6 14:12
     * @param  name 索引名称
     * @param  propertyMap 属性
     **/
    @Override
    public void updateIndexProperty(String name, HashMap<String, Property> propertyMap) throws IOException {
        PutMappingResponse response = elasticsearchClient.indices()
                .putMapping(typeMappingBuilder ->
                        typeMappingBuilder
                                .index(name)
                                .properties(propertyMap)
                );
        log.info("updateIndexMapping方法，acknowledged={}", response.acknowledged());
    }

    /**
     * Description：获取所有索引信息
     * @date   2024/3/6 14:13
     **/
    @Override
    public GetIndexResponse getIndexList() throws IOException {
        //使用 * 或者 _all都可以
        GetIndexResponse response = elasticsearchClient.indices().get(builder -> builder.index("_all"));
        log.info("getIndexList方法，response.result()={}", response.result().toString());
        return response;
    }

    /**
     * Description：根据索引名称获取所有详情
     * @date   2024/3/6 14:13
     * @param  name 索引名称
     * @return GetIndexResponse 返回信息
     **/
    @Override
    public GetIndexResponse getIndexDetail(String name) throws IOException {
        GetIndexResponse response = elasticsearchClient.indices().get(builder -> builder.index(name));
        log.info("getIndexDetail方法，response.result()={}", response.result().toString());
        return response;
    }

    /**
     * Description：根据索引名称判断索引是否存在
     * @date   2024/3/6 14:13
     * @param  name 索引名称
     * @return boolean 返回存在的布尔值
     **/
    @Override
    public boolean indexExists(String name) throws IOException {
        return elasticsearchClient.indices().exists(b -> b.index(name)).value();
    }
}

文档类

package cn.goktech.workbench.service.impl;

import cn.test.configs.PublicConfig;
import cn.test.entity.docmanagement.po.DocumentInfo;
import cn.test.entity.docmanagement.vo.DocumentInfoPageVo;
import cn.test.entity.docmanagement.vo.DocumentInfoVo;
import cn.test.service.ElasticSearchDocService;
import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.search.Hit;
import com.fasterxml.jackson.databind.node.ObjectNode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiConsumer;

/**
 * Description: es操作文档的接口
 * @version 1.0
 * @ClassName ElasticSearchDocServiceImpl
 * @date 2024/3/6 17:44
 **/
@Service
@Slf4j
public class ElasticSearchDocServiceImpl implements ElasticSearchDocService {

    @Autowired
    private ElasticsearchClient elasticsearchClient;

    @Autowired
    private ElasticsearchAsyncClient elasticsearchAsyncClient;


    /**
     * 新增一个文档并返回ID
     * @param indexName 索引名称
     * @param document 文档对象
     * @return IndexResponse
     * @throws Exception 抛出操作异常
     */
    @Override
    public String createByFluentDsl(String indexName, DocumentInfo document) throws Exception {
        return  elasticsearchClient.index(idx -> idx
                .index(indexName)
                .id(document.getDocId())
                .document(document)).id();
    }


    /**
     * 新增一个文档
     * @param indexName 索引名称
     * @param document 文档对象 需要的字段自己创建一个实体类
     * @return IndexResponse
     * @throws Exception 抛出操作异常
     */
    @Override
    public String createByBuilderPattern(String indexName, DocumentInfo document) throws Exception {
        IndexRequest.Builder<Object> indexReqBuilder = new IndexRequest.Builder<>();
        indexReqBuilder.index(indexName);
        indexReqBuilder.id(document.getDocId());
        indexReqBuilder.document(document);
        return elasticsearchClient.index(indexReqBuilder.build()).id();
    }

    /**
     * 用JSON字符串创建文档
     * @param indexName 索引名称
     * @param idxId 索引id
     * @param jsonContent json字符串
     * @return IndexResponse
     * @throws Exception 抛出操作异常
     */
    @Override
    public String createByJson(String indexName, String idxId, String jsonContent) throws Exception {
        return elasticsearchClient.index(i -> i
                .index(indexName)
                .id(idxId)
                .withJson(new StringReader(jsonContent))).id();
    }

    /**
     * 异步新增文档
     * @param indexName 索引名称
     * @param idxId 索引id
     * @param document 文档内容 需要的字段自己创建一个实体类
     * @param action 属性
     */
    @Override
    public void createAsync(String indexName, String idxId, DocumentInfo document, BiConsumer<IndexResponse, Throwable> action) {
        elasticsearchAsyncClient.index(idx -> idx
                .index(indexName)
                .id(idxId)
                .document(document)
        ).whenComplete(action);
    }

    /**
     * 批量增加文档
     * @param indexName 索引名称
     * @param documents 要增加的对象集合 需要的字段自己创建一个实体类
     * @return 批量操作的结果
     * @throws Exception 抛出操作异常
     */
    @Override
    public BulkResponse bulkCreate(String indexName, List<DocumentInfo> documents) throws Exception {
        BulkRequest.Builder br = new BulkRequest.Builder();
        //可以将 Object定义为一个文档基类。比如 ESDocument类
        // 将每一个product对象都放入builder中
        documents.stream().forEach(esDocument -> br
                .operations(op -> op
                        .index(idx -> idx
                                .index(indexName)
                                .id(esDocument.getDocId())
                                .document(esDocument))));
        return elasticsearchClient.bulk(br.build());
    }

    /**
     * 根据文档id查找文档
     * @param indexName 索引名称
     * @param docId 文档id
     * @return Object类型的查找结果
     * @throws IOException 抛出操作异常
     */
    @Override
    public Object getById(String indexName, String docId) throws IOException {
        GetResponse<Object> response = elasticsearchClient.get(g -> g
                        .index(indexName)
                        .id(docId),
                Object.class);
        return response.found() ? response.source() : null;
    }

    /**
     * 根据文档id查找文档，返回类型是ObjectNode
     * @param indexName 索引名称
     * @param docId 文档id
     * @return ObjectNode类型的查找结果
     * @throws IOException 抛出操作异常
     */
    @Override
    public ObjectNode getObjectNodeById(String indexName, String docId) throws IOException {
        GetResponse<ObjectNode> response = elasticsearchClient.get(g -> g
                        .index(indexName)
                        .id(docId),
                ObjectNode.class);
        return response.found() ? response.source() : null;
    }

    /**
     * 根据文档id删除文档
     * @param indexName 索引名称
     * @param docId 文档id
     * @return Object类型的查找结果
     * @throws IOException 抛出操作异常
     */
    @Override
    public Boolean deleteById(String indexName, String docId) throws IOException {
        DeleteResponse delete = elasticsearchClient.delete(d -> d
                .index(indexName)
                .id(docId));
        return delete.forcedRefresh();
    }

    /**
     * 批量删除文档
     * @param indexName 索引名称
     * @param docIds 要删除的文档id集合
     * @return BulkResponse
     * @throws Exception 抛出操作异常
     */
    @Override
    public BulkResponse bulkDeleteByIds(String indexName, List<String> docIds) throws Exception {
        BulkRequest.Builder br = new BulkRequest.Builder();
        // 将每一个对象都放入builder中
        docIds.stream().forEach(id -> br
                .operations(op -> op
                        .delete(d -> d
                                .index(indexName)
                                .id(id))));
        return elasticsearchClient.bulk(br.build());
    }


    /**
     * Description：修改文档信息
     * @date   2024/3/7 10:09
     * @param  indexName 索引名称
     * @param  documentInfo 文档信息 需要的字段自己创建一个实体类
     **/
    @Override
    public void updateDocById(String indexName, DocumentInfo documentInfo) throws IOException {
        final UpdateResponse<DocumentInfo> response = elasticsearchClient.update(builder -> builder
                .index(indexName)
                .id(documentInfo.getDocId())
                .doc(documentInfo), DocumentInfo.class);
        System.err.println(response.shards().successful());
    }

    public void getDocPageList(String indexName, Integer pageNum, Integer pageSize) throws IOException {
        /*
         * 分页查询，查询所有
         * sort 排序
        */
        final SearchResponse<DocumentInfo> response = elasticsearchClient.search(builder ->
                        builder.index(indexName)
                                .query(q->q.matchAll(v->v))
                                .size(pageSize)
                                .from(pageNum)
                                .sort(builder1 -> builder1.field(f->f.field("reportDate").order(SortOrder.Desc)))
                , DocumentInfo.class);
        List<Hit<DocumentInfo>> hitList = response.hits().hits();
        System.err.println(hitList);
    }

    public void getDocPageListBySearchWords(String indexName, Integer pageNum, Integer pageSize, String searchWords) throws IOException {
        /*
         * 分页查询，可根据输入文字搜索
         * sort 排序
         */
        final SearchResponse<DocumentInfoVo> response = elasticsearchClient.search(builder ->
                        builder.index(indexName)
                                .query(q->q.multiMatch(v->v.query(searchWords).fields("docTitle", "docContent")))
                                .size(pageSize)
                                .from(pageNum)
                                .sort(builder1 -> builder1.field(f->f.field("reportDate").order(SortOrder.Desc)))
                , DocumentInfoVo.class);
        System.err.println(response);
    }

    public void getDocPageListByTitle(String indexName, Integer pageNum, Integer pageSize, String type) throws IOException {
        /*
         * 分页查询，可根据类型搜索
         * query 查询条件
         * sort 排序
         */
        final SearchResponse<DocumentInfoVo> response = elasticsearchClient.search(builder ->
                        builder.index(indexName)
                                .query(q->q.term(t ->t.field("docType.keyword").value(type)))
                                .size(pageSize)
                                .from(pageNum)
                                .sort(builder1 -> builder1.field(f->f.field("reportDate").order(SortOrder.Desc)))
                , DocumentInfoVo.class);
        System.err.println(response);
        List<Hit<DocumentInfoVo>> hitList = response.hits().hits();
    }


    /**
     * Description：TODOmethod
     * @date   2024/3/8 10:26
     * @param  indexName 索引名称
     * @param  pageNum 页码
     * @param  pageSize 每页数量
     * @param  queryList 查询条件query
     * @return DocumentInfoPageVo 返回分页数据
     * @throws IOException 抛出操作异常
     **/
    @Override
    public DocumentInfoPageVo getDocPageList(String indexName, Integer pageNum, Integer pageSize, List<Query> queryList) throws IOException {
        List<DocumentInfoVo> list = new ArrayList<>();
        SearchResponse<DocumentInfoVo> response = elasticsearchClient.search(s -> s
                        .index(indexName)
                        .query(q -> q.bool(b -> b.must(queryList)))
                        //高亮
                        .highlight(h -> h
                                .preTags("<span>")
                                .postTags("</span>")
                                .requireFieldMatch(false)
                                .fields("docTitle", hf -> hf)
                                .fields("docContent", hf -> hf))
                        //排序
                        .sort(sort -> sort.field(f -> f.field("reportDate").order(SortOrder.Desc)))
//                        //查询字段过滤
//                        .source(sc -> sc.filter(f -> f.includes(sources)))
                        //分页
                        .from((pageNum - 1) * pageSize)
                        .size(pageSize),
                DocumentInfoVo.class
        );
        DocumentInfoPageVo vo = new DocumentInfoPageVo();
        vo.setTotal(response.hits().total() != null ? response.hits().total().value() : PublicConfig.ZERO);

        System.err.println(response);

        List<Hit<DocumentInfoVo>> hitList = response.hits().hits();
        for (Hit<DocumentInfoVo> hit : hitList) {
            DocumentInfoVo infoVo = hit.source();
            if(Objects.nonNull(infoVo)){
                Map<String, List<String>> map = hit.highlight();
                //设置返回高亮的字段进行原字段替换
                infoVo.setDocTitle(CollectionUtils.isEmpty(map.get("docTitle")) ? infoVo.getDocTitle() : map.get("docTitle").get(PublicConfig.ZERO));
                infoVo.setDocContent(CollectionUtils.isEmpty(map.get("docContent")) ? infoVo.getDocContent() : map.get("docContent").get(PublicConfig.ZERO));
                list.add(infoVo);
            }
        }
        vo.setList(list);
        return vo;
    }
}

这里我想在分页多条件查询，使用方式：

try {
            //sources 为你过滤的字段，也就是你想要查询出来的字段，配置了那些字段才会返回那些字段
//            List<String> sources = new ArrayList<>();
            //queryList 为你想要的查询条件封装，每种查询方式的条件query不一样
            List<Query> queryList = new ArrayList<>();
            //根据文档类型筛选查询
            if(StringUtils.isNotEmpty(dto.getTypeName())){
                Query query = TermQuery.of(m -> m.field("docType.keyword").value(dto.getTypeName()))._toQuery();
                queryList.add(query);
            }
            //根据输入内容查询文档标签和文档内容
            if(StringUtils.isNotEmpty(dto.getSearchWord())){
                Query query = MultiMatchQuery.of(v -> v.query(dto.getSearchWord()).fields("docTitle", "docContent"))._toQuery();
                queryList.add(query);
            }
            //根据时间范围查询
            if(StringUtils.isNotEmpty(dto.getStartDate()) && StringUtils.isNotEmpty(dto.getEndDate())){
                long startTime = DateUtil.parse(dto.getStartDate()).getTime();
                Query startQuery = RangeQuery.of(r -> r.field("reportDate")
                        .gte(JsonData.of(startTime))
                )._toQuery();
                queryList.add(startQuery);
                long endTime = DateUtil.parse(dto.getEndDate()).getTime();
                Query endQuery = RangeQuery.of(r -> r.field("reportDate")
                        .lte(JsonData.of(endTime))
                )._toQuery();
                queryList.add(endQuery);
            }
            DocumentInfoPageVo pageVo = elasticSearchDocService.getDocPageList(DOC_INDEX, dto.getPage(), dto.getLimit(), queryList);
            return new PageResult<>(pageVo.getList(), pageVo.getTotal());

上面是我的分页查询，这里docType.keyword是为了匹配查询，如mysql中的 name=张三，我这里的docType在ES文档中的type就是keyword，MultiMatchQuery这个是我多字段分词查询，后面是范围查询。

在这里插入图片描述

上面分页有两种情况，一种是可以随机分页，连续分页，但是用HighLeavel我还没找到跳页的效果的实现方式，分页还有一个深分页的问题
在这里插入图片描述

其它问题在后续使用中陆续更新

上面这块可以看文章：这里讲了很多知识

文章查询并高亮显示可查看此文章

Elasticsearch Java API

ES的term查询无返回结果

学习和整合时推荐
ElasticSearch 所有知识总结

ElasticSearch（提高篇）

中文分词器(IK Analyzer)及自定义词库

以上简洁整理只是记录下，便于后期使用，希望对大家有所帮助

焚目圣僧渡众生
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
elasticsearchlinux搭建详解
03-05
自己做的关于elasticsearch-6.6.1的linux版搭建程ppt，内容包含elasticsearch-6.6.1搭建，集成ik分词器6.6.0版，logstash-6.6.1版，node安装，服务集群，服务搭建过程中可能会遇到的坑等等
SpringBoot 整合 ES 进行各种高级查询搜索
zhiyikeji的博客
02-08 3603
elasticsearch中的内部对象无法按预期工作，这里的问题是elasticsearch（lucene）使用的库没有内部对象的概念，因此内部对象被扁平化为一个简单的字段名称和值列表。值得我们注意的是在进行聚合操作的fild上，如果我们该字段设置成key或者text，则会出现以下错误。本章git上的代码如果有被注释掉的，只是为了防止和后面的章节不冲突，并无错误，大家自行解注查看即可。因为本文都是数据的搜索，所以我们需要在我们的es服务器里先插入一些数据以供我们后面使用。有时候，我们需要查询一个。
SpringBoot 整合 ElasticSearch
学习学习学习
05-11 5032
springBoot整合ES的基本操作
SpringBoot 3.2.5 + ElasticSearch 8.12.0 - SpringData 开发指南
CYK_byte的博客
05-11 1149
因此，一般会将需要进行模糊查询的字段存 Document 中（es 就擅长这个），而其他数据则可以在 Document 中以 id 的形式进行存储. 这样就既可以借助 es 高效的模糊查询能力，也能减少为保证一致性而带来的系统开销. 从 es 中查到数据后，再通过其他表的 id 从数据库中拿数据即可（这点开销，相对于从大量数据的数据库中进行 like 查询，几乎可以忽略）.a）CriteriaQuery：允许创建查询来搜索数据，而不需要了解 Elasticsearch 查询的语法或基础知识。
SpringBoot：SpringBoot整合Elasticsearch案例
热门推荐
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
02-16 1万+
声明：原作者：微信公众号：悟空聊架构 文章目录声明：原作者：微信公众号：悟空聊架构前言一、Elasticsearch 组件库介绍二、整合检索服务1.1 添加搜索服务模块1.2 配置 Maven 依赖1.3 注册搜索服务到注册中心1.4 添加 ES 配置类1.5 测试 ES Client 自动加载1.6 测试 ES 简单插入数据1.7 测试 ES 查询复杂语句1.7.1 构造检索条件17.2 获取命中记录的详情1.7.3 获取年龄分布聚合信息1.7.4 获取平均薪资聚合信息三、实战：同步 ES 数据3.1 定
Spring Boot集成Elasticsearch 8.12.2客户端
iOS逆向与安全
03-29 277
Java REST 客户端已被弃用，取而代之的是 Java API client 客户端，ES 8.x 新版本中，Type 概念被弃用，所以新版 JavaAPI 也相应做出了改变，支持lambda，使用更加简便。ElasticSearch 5.0以后，string类型有重大变更，移除了string类型，string字段被拆分成两种新的数据类型: text用于全文搜索的，而keyword用于关键词搜索。如果按照年进行索引存储，判断查询年份，如果没有对应的索引，则提示查询年份超出范围。
spring boot读取yml配置注意点记录
xiaolegeaizy的博客
07-04 476
spring boot yml配置玄机
Spring Boot中的响应式编程
07-06 307
响应式编程是一种基于异步数据流的编程范式，通过观察者模式实现数据流和变化的传播。今天我们将探讨Spring Boot中的响应式编程，这是一种现代化的编程范式，特别适用于需要高并发和高性能的应用场景。通过本文，我们了解了Spring Boot中响应式编程的基本概念和使用方法，以及它的优势和适用场景。：响应式编程利用非阻塞I/O和异步处理，能够处理大量并发请求而不会阻塞线程，提升了系统的吞吐量和性能。：使用函数式编程风格来处理数据流，简化了代码的编写和维护，提升了代码的可读性和可维护性。
Spring Boot与Spring MVC的区别和联系
技术研究中心
07-06 344
Spring Boot简化了Spring应用的开发过程，而Spring MVC则提供了构建Web应用的强大功能。Spring Boot集成了Spring MVC的所有功能，通过自动配置简化了Spring MVC应用的搭建过程。Spring Boot和Spring MVC是互补的技术，Spring Boot包含并扩展了Spring MVC。Spring Boot内置了Tomcat服务器，开发者无需额外配置，只需运行Spring Boot应用即可启动内置服务器并部署Spring MVC应用。
Spring Boot中的全局异常处理
07-06 365
今天我们将探讨如何在Spring Boot应用中实现全局异常处理，这是保证应用稳定性和用户体验的重要技术手段。通过本文，我们学习了如何在Spring Boot应用中实现全局异常处理，提升了应用的稳定性和用户体验。通过定义全局异常处理器，可以捕获应用中抛出的各种异常，然后进行统一的异常处理逻辑，例如记录日志、返回友好的错误信息给用户等。：可以在全局异常处理器中集中记录和处理异常信息，便于排查和分析问题。：通过全局异常处理器，可以统一处理应用中的所有异常，减少重复代码。编写一个全局异常处理器类，使用。
Spring Boot中的事件驱动开发
07-06 404
在事件驱动的架构中，组件之间通过发布和订阅事件的方式进行通信，提高了系统的可扩展性、灵活性和响应速度。通过本文，我们详细探讨了在Spring Boot中实现事件驱动开发的方法和技术细节，希望能够帮助您更好地利用事件驱动的优势构建高效、可扩展的应用程序。事件发布者负责发布事件，通常是某个服务或组件中的一个方法，通过Spring的。：通过事件驱动开发，各组件之间的依赖性降低，提高了代码的模块化和复用性。事件，用于表示订单创建的事件，并包含了订单ID作为事件的信息。事件，通知其他订阅了该事件的组件。
Spring Boot中的数据校验
技术研究中心
07-06 315
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨Spring Boot中的数据校验，了解如何在应用程序中有效地验证和处理数据。数据校验在应用开发中至关重要，它可以有效地防止无效或恶意数据输入，保障系统的稳定性和安全性。Spring Boot提供了强大的数据校验支持，通过注解和验证器可以轻松地对数据进行验证。合理地使用数据校验可以提升系统的安全性和稳定性，减少无效数据的输入，保障应用程序的健壮性。然后编写对应的验证器。
Spring Boot与Traefik的集成
最新发布
微赚淘客开发者博客
07-06 356
在当今的微服务架构中，服务的动态管理和路由是至关重要的。通过本文的介绍，我们了解了如何在Spring Boot应用中集成Traefik，实现动态的服务路由和负载均衡。在Spring Boot应用的Docker Compose或者Docker Swarm服务配置中，添加Traefik需要的标签，以便Traefik可以自动发现和路由服务。利用Traefik的动态配置能力，结合Spring Cloud配置中心（如Spring Cloud Config）或者环境变量，实现灵活的服务路由和配置管理。
java版本工程项目管理系统 Spring Cloud+Spring Boot+Mybatis+Vue+ElementUI+前后端分离构建工程项目管理系统
m0_65038841的博客
07-03 625
二、企业通过数字化转型，不仅有利于优化业务流程、提升经营管理能力和风险控制能力，还可强有力地促进企业体制机制的全面创新。四、在企业里建立一个管过程、提效率、降风险、控成本的工程项目管理环境，科学化、规范化是至关重要的。1、项目列表：实现对项目列表的增删改查操作，包括查看各项目的立项人、创建时间、2、项目计划管理：项目计划查看和管理模块，可执行增删改查操作，包括查看甘特图。3、收支报表：项目收支报表，包含总体收支、项目收支和收支统计模块。1、项目汇总：项目汇总信息查看，包括进度、计划时间等信息。
Spring Boot集成fastjson2快速入门Demo
HBLOG
07-04 285
fastjson2是阿里巴巴开发的一个高性能的Java JSON处理库，它支持将Java对象转换成JSON格式，同时也支持将JSON字符串解析成Java对象。本文将介绍fastjson2的常见用法，包括JSON对象、JSON数组的创建、取值、遍历，以及与字符串、Java对象、Map、List的相互转换。支持JSON/JSONB两种协议，JSONPath是一等公民。支持全量解析和部分解析。支持Java服务端、客户端Android、大数据场景。支持Kotlin支持。
如何在Spring Boot中实现数据加密
微赚淘客开发者博客
07-06 221
通过本文，我们详细介绍了如何在Spring Boot应用程序中实现数据加密。首先，我们了解了数据加密的重要性和常见应用场景，接着介绍了对称加密和非对称加密的原理与区别。然后，通过Spring Boot的实际代码示例，展示了如何配置加密算法、编写加密工具类，以及在业务中应用加密技术保护敏感数据。在当今信息安全日益受到重视的背景下，数据加密成为保护敏感信息不被未授权访问的重要手段。Spring Boot作为一种流行的Java开发框架，提供了多种方式来实现数据加密，适用于用户密码、数据库连接、敏感配置等场景。
spring boot初始化的几个总结
csdncjh的博客
06-30 712
Spring Boot 3.x要求 Java最低版本为17， 最新的SpringBoot版本已经要求Java22了所以，你可以升级Java版本，使用SpringBoot3.X。
Spring Boot中的依赖注入和控制反转
技术研究中心
07-06 514
通过自动配置、注解驱动和Java配置类，Spring Boot提供了一种优雅的方式来管理Spring应用中的Bean和依赖关系。理解和掌握Spring Boot中的依赖注入和控制反转，不仅可以提高代码的可维护性和可测试性，还能帮助开发者构建更灵活和可扩展的应用。通过依赖注入和控制反转，组件之间的依赖关系由容器管理，减少了代码的耦合性，使得代码更加模块化和可维护。通过Spring的配置文件和注解，可以很容易地添加或修改Bean的配置，增强了系统的可扩展性。通过构造函数注入，所有依赖在对象创建时就传递给对象。
elasticsearchlinux安装教程
08-19
你可以按照以下步骤来安装 Elasticsearch 在 Linux 上： 1. 在 Elasticsearch 官方网站 (https://www.elastic.co/downloads/elasticsearch) 上下载适合你的操作系统的压缩包。 2. 解压下载的压缩包。可以使用以下命令来解压： ``` tar -xzf elasticsearch-<版本号>-linux-x86_64.tar.gz ``` 3. 进入解压后的目录： ``` cd elasticsearch-<版本号> ``` 4. 打开 `config/elasticsearch.yml` 文件，修改以下配置： - 修改 `cluster.name` 为你想要的集群名称。 - 指定 `node.name` 为当前节点的名称。 - 如果你只在本地测试，请确保 `network.host` 设置为 `localhost`。 - 如果你需要更改默认端口，请修改 `http.port`。 5. 启动 Elasticsearch。运行以下命令： ``` ./bin/elasticsearch ``` Elasticsearch 将开始启动，并显示启动日志。 6. 等待 Elasticsearch 完全启动后，你可以使用 curl 命令进行测试： ``` curl -X GET "http://localhost:9200/" ``` 如果返回类似于以下内容的 JSON 响应，则表示 Elasticsearch 已经成功安装和运行： ``` { "name" : "your_node_name", "cluster_name" : "your_cluster_name",

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

焚目圣僧渡众生

你的 一角将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值