SpringBoot集成Elasticsearch7.4 实战（二）

最新推荐文章于 2024-04-17 11:50:55 发布
最新推荐文章于 2024-04-17 11:50:55 发布
阅读量737 收藏 2
点赞数
分类专栏： Java工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38175358/article/details/109766797
版权

SpringBoot集成Elasticsearch7.4 实战（二）

 

内容规划总共分为三个章节来写，分别运行环境构建、利用Web应用管理索引以及Web应用管理数据三大块来说明。

具体有：
一、SpringBoot集成Elasticsearch7.4 实战（一）：这些操作都是在CentOS下操作的，主要带大家熟悉下Elasticsearch环境。

  • 1.1.下载& Linux下ElasticSearch安装
  • 1.2.中文分词插件IK
  • 1.3.索引
  • 1.4.如何数据管理

二、SpringBoot集成Elasticsearch7.4 实战（二）：在Springboot环境下，利用JAVA环境操作索引。

  • 2.1.新增索引
  • 2.2.查询索引
  • 2.3.删除索引

三、SpringBoot集成Elasticsearch7.4 实战（三）：在Springboot环境下，管理数据。

  • 3.1.WEB HTTP提交数据<单条提交、批量提交>
  • 3.2.WEB HTTP方式条件查询
  • 3.3.WEB HTTP删除数据

elasticsearch

0 目录

1. SpringBoot集成

开发工具，这里选择的是IDEA 2019.2，构建Maven工程等一堆通用操作，不清楚的自行百度。

我这边选择elasticsearch-rest-high-level-client方式来集成，发现这有个坑，开始没注意，踩了好久，就是要排除掉elasticsearch、elasticsearch-rest-client，这里没有选择spring-boot-starter-data-elasticsearch，因为最新版的starter现在依然是6.x版本号，并没有集成elasticsearch7.4.0，导致使用过程中有很多版本冲突，读者在选择的时候多加留意。

1.1. POM配置

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.4.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>7.4.0</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.4.0</version>
</dependency>

1.2. yml配置

server:
  port: 9090
spring:
  datasource:
    name: mysql
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 30000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: select 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: false
      max-pool-prepared-statement-per-connection-size: 20
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=6000
es:
  host: 192.168.147.132
  port: 9200
  scheme: http

mybatis:
  mapperLocations: classpath:mapper/**/*.xml

这里连接Elasitcsearch的配置如下

es:
  host: 192.168.147.132
  port: 9200
  scheme: http

1.3. 核心操作类

package xyz.wongs.weathertop.base.service;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.IndicesOptions;
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.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import sun.rmi.runtime.Log;
import xyz.wongs.weathertop.base.entiy.ElasticEntity;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Slf4j
@Component
public class BaseElasticService {

    @Autowired
    RestHighLevelClient restHighLevelClient;

    /**
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:30
     * @param idxName   索引名称
     * @param idxSQL    索引描述
     * @return void
     * @throws
     * @since
     */
    public void createIndex(String idxName,String idxSQL){
        try {
            if (!this.indexExist(idxName)) {
                log.error(" idxName={} 已经存在,idxSql={}",idxName,idxSQL);
                return;
            }
            CreateIndexRequest request = new CreateIndexRequest(idxName);
            buildSetting(request);
            request.mapping(idxSQL, XContentType.JSON);
//            request.settings() 手工指定Setting
            CreateIndexResponse res = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            if (!res.isAcknowledged()) {
                throw new RuntimeException("初始化失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
    }

    /** 断某个index是否存在
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:27
     * @param idxName index名
     * @return boolean
     * @throws
     * @since
     */
    public boolean indexExist(String idxName) throws Exception {
        GetIndexRequest request = new GetIndexRequest(idxName);
        request.local(false);
        request.humanReadable(true);
        request.includeDefaults(false);
        request.indicesOptions(IndicesOptions.lenientExpandOpen());
        return restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
    }

    /** 断某个index是否存在
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:27
     * @param idxName index名
     * @return boolean
     * @throws
     * @since
     */
    public boolean isExistsIndex(String idxName) throws Exception {
        return restHighLevelClient.indices().exists(new GetIndexRequest(idxName),RequestOptions.DEFAULT);
    }

    /** 设置分片
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 19:27
     * @param request
     * @return void
     * @throws
     * @since
     */
    public void buildSetting(CreateIndexRequest request){
        request.settings(Settings.builder().put("index.number_of_shards",3)
                .put("index.number_of_replicas",2));
    }
    /**
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:27
     * @param idxName index
     * @param entity    对象
     * @return void
     * @throws
     * @since
     */
    public void insertOrUpdateOne(String idxName, ElasticEntity entity) {
        IndexRequest request = new IndexRequest(idxName);
        log.error("Data : id={},entity={}",entity.getId(),JSON.toJSONString(entity.getData()));
        request.id(entity.getId());
        request.source(entity.getData(), XContentType.JSON);
//        request.source(JSON.toJSONString(entity.getData()), XContentType.JSON);
        try {
            restHighLevelClient.index(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


    /** 批量插入数据
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:26
     * @param idxName index
     * @param list 带插入列表
     * @return void
     * @throws
     * @since
     */
    public void insertBatch(String idxName, List<ElasticEntity> list) {
        BulkRequest request = new BulkRequest();
        list.forEach(item -> request.add(new IndexRequest(idxName).id(item.getId())
                .source(item.getData(), XContentType.JSON)));
        try {
            restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /** 批量删除
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:14
     * @param idxName index
     * @param idList    待删除列表
     * @return void
     * @throws
     * @since
     */
    public <T> void deleteBatch(String idxName, Collection<T> idList) {
        BulkRequest request = new BulkRequest();
        idList.forEach(item -> request.add(new DeleteRequest(idxName, item.toString())));
        try {
            restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:14
     * @param idxName index
     * @param builder   查询参数
     * @param c 结果类对象
     * @return java.util.List<T>
     * @throws
     * @since
     */
    public <T> List<T> search(String idxName, SearchSourceBuilder builder, Class<T> c) {
        SearchRequest request = new SearchRequest(idxName);
        request.source(builder);
        try {
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            SearchHit[] hits = response.getHits().getHits();
            List<T> res = new ArrayList<>(hits.length);
            for (SearchHit hit : hits) {
                res.add(JSON.parseObject(hit.getSourceAsString(), c));
            }
            return res;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /** 删除index
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:13
     * @param idxName
     * @return void
     * @throws
     * @since
     */
    public void deleteIndex(String idxName) {
        try {
            if (!this.indexExist(idxName)) {
                log.error(" idxName={} 已经存在",idxName);
                return;
            }
            restHighLevelClient.indices().delete(new DeleteIndexRequest(idxName), RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


    /**
     * @author WCNGS@QQ.COM
     * @See
     * @date 2019/10/17 17:13
     * @param idxName
     * @param builder
     * @return void
     * @throws
     * @since
     */
    public void deleteByQuery(String idxName, QueryBuilder builder) {

        DeleteByQueryRequest request = new DeleteByQueryRequest(idxName);
        request.setQuery(builder);
        //设置批量操作数量,最大为10000
        request.setBatchSize(10000);
        request.setConflicts("proceed");
        try {
            restHighLevelClient.deleteByQuery(request, RequestOptions.DEFAULT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

2. 实战

2.1. 索引管理

由于在BaseElasticDao类中createIndex方法，我在Controller层将索引名称和索引SQL封装过，详细见Github演示源码 中xyz.wongs.weathertop.palant.vo.IdxVo

2.1.1. 创建索引

我们在创建索引过程中需要先判断是否有这个索引，否则不允许创建，由于我案例采用的是手动指定indexName和Settings，大家看的过程中要特别注意下，而且还有一点indexName必须是小写，如果是大写在创建过程中会有错误

官方索引创建说明

索引名大写


/**
    * @Description 创建Elastic索引
    * @param idxVo
    * @return xyz.wongs.weathertop.base.message.response.ResponseResult
    * @throws
    * @date 2019/11/19 11:07
    */
@RequestMapping(value = "/createIndex",method = RequestMethod.POST)
public ResponseResult createIndex(@RequestBody IdxVo idxVo){
    ResponseResult response = new ResponseResult();
    try {
        //索引不存在，再创建，否则不允许创建
        if(!baseElasticDao.indexExist(idxVo.getIdxName())){
            String idxSql = JSONObject.toJSONString(idxVo.getIdxSql());
            log.warn(" idxName={}, idxSql={}",idxVo.getIdxName(),idxSql);
            baseElasticDao.createIndex(idxVo.getIdxName(),idxSql);
        } else{
            response.setStatus(false);
            response.setCode(ResponseCode.DUPLICATEKEY_ERROR_CODE.getCode());
            response.setMsg("索引已经存在，不允许创建");
        }
    } catch (Exception e) {
        response.setStatus(false);
        response.setCode(ResponseCode.ERROR.getCode());
        response.setMsg(ResponseCode.ERROR.getMsg());
    }
    return response;
}

创建索引需要设置分片，这里采用Settings.Builder方式，当然也可以JSON自定义方式，本文篇幅有限，不做演示。查看xyz.wongs.weathertop.base.service.BaseElasticService.buildSetting方法，这里是默认值。

index.number_of_shards：分片数

number_of_replicas：副本数


/** 设置分片
    * @author WCNGS@QQ.COM
    * @See
    * @date 2019/10/17 19:27
    * @param request
    * @return void
    * @throws
    * @since
    */
public void buildSetting(CreateIndexRequest request){
    request.settings(Settings.builder().put("index.number_of_shards",3)
            .put("index.number_of_replicas",2));

这时候我们通过Postman工具调用Controller，发现创建索引成功。

新增索引

再命令行执行curl -H "Content-Type: application/json" -X GET "http://localhost:9200/_cat/indices?v"，效果如图：


[elastic@localhost elastic]$ curl -H "Content-Type: application/json" -X GET "http://localhost:9200/_cat/indices?v"
health status index        uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   twitter      scSSD1SfRCio4F77Hh8aqQ   3   2          2            0      8.3kb          8.3kb
yellow open   idx_location _BJ_pOv0SkS4tv-EC3xDig   3   2          1            0        4kb            4kb
yellow open   wongs        uT13XiyjSW-VOS3GCqao8w   3   2          1            0      3.4kb          3.4kb
yellow open   idx_locat    Kr3wGU7JT_OUrRJkyFSGDw   3   2          3            0     13.2kb         13.2kb
yellow open   idx_copy_to  HouC9s6LSjiwrJtDicgY3Q   3   2          1            0        4kb            4kb

说明创建成功，这里总是通过命令行来验证，有点繁琐，既然我都有WEB服务，为什么不直接通过HTTP验证了？

2.1.2. 查看索引

我们写一个对外以HTTP+GET方式对外提供查询的服务。存在为TRUE，否则False.

/**
    * @Description 判断索引是否存在；存在-TRUE，否则-FALSE
    * @param index
    * @return xyz.wongs.weathertop.base.message.response.ResponseResult
    * @throws
    * @date 2019/11/19 18:48
    */
@RequestMapping(value = "/exist/{index}")
public ResponseResult indexExist(@PathVariable(value = "index") String index){

    ResponseResult response = new ResponseResult();
    try {
        if(!baseElasticDao.isExistsIndex(index)){
            log.error("index={},不存在",index);
            response.setCode(ResponseCode.RESOURCE_NOT_EXIST.getCode());
            response.setMsg(ResponseCode.RESOURCE_NOT_EXIST.getMsg());
        } else {
            response.setMsg(" 索引已经存在, " + index);
        }
    } catch (Exception e) {
        response.setCode(ResponseCode.NETWORK_ERROR.getCode());
        response.setMsg(" 调用ElasticSearch 失败！");
        response.setStatus(false);
    }
    return response;
}

2.1.3. 删除索引

删除的逻辑就比较简单，这里就不多说。

/** 删除index
    * @author WCNGS@QQ.COM
    * @See
    * @date 2019/10/17 17:13
    * @param idxName
    * @return void
    * @throws
    * @since
    */
public void deleteIndex(String idxName) {
    try {
        if (!this.indexExist(idxName)) {
            log.error(" idxName={} 已经存在",idxName);
            return;
        }
        restHighLevelClient.indices().delete(new DeleteIndexRequest(idxName), RequestOptions.DEFAULT);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

3. 源码

Github演示源码 ，记得给Star

3.相关章节

一、SpringBoot集成Elasticsearch7.4 实战（一）
二、SpringBoot集成Elasticsearch7.4 实战（二）
三、SpringBoot集成Elasticsearch7.4 实战（三）

HelloWorld_MHC
关注
专栏目录
从零学ELK系列（八）:SpringBoot项目接入ELK（超详细图文教程）
通往精英的成长之路
12-28 6048
【前言】 在前几篇博文中将ELK+Filebeat日志收集系统搭建完毕，本次我们将展示如何将SpringBoot接入我们搭建的日志系统，把步骤记录下来，一是方便自己以后安装，二是可以为大家做参考共享。 【一句总结一张架构图】 一、一句话总结学完本篇博文，你将学到什么？ SpringBoot项目接入ELK+Filebeat收集系统...
Elasticsearch
weixin_55261016的博客
06-15 773
ELK是包含但不限于Elasticsearch（简称es）、Logstash、Kibana 三个开源软件的组成的一个整体。这三个软件合成ELK。是用于数据抽取（Logstash）、搜索分析（Elasticsearch）、数据展现（Kibana）的一整套解决方案，所以也称作ELK stack。 本课程从分别对三个组件经行详细介绍，尤其是Elasticsearch，因为它是elk的核心。本课程从es底层对文档、索引、搜索、聚合、集群经行介绍，从搜索和聚合分析实例来展现es的魅力。Logstash从内部如何采集
SpringBoot集成Elasticsearch7.4 实战.pdf
11-07
1、CentOS7下安装Elasticsearch7.4 2、SpringBoot版本2.1.8.RELEASE，集成Elasticsearch7.4实现创建索引、删除索引；添加输入
elasticsearch7..4.2 整合 springboot
weixin_43863895的博客
06-16 1827
elasticsearch 7.4.2整合SpringBoot创建项目测试 保存操作 创建项目 本示例使用springboot版本是2.3.1 第一步: pom依赖 <!-- https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-high-level-client --> <dependency> <groupId&
SpringBoot整合ElasticSearch7.4.2，简单而详细
web15870359587的博客
04-26 970
SpringBoot整合ElasticSearch7.4.2，简单而详细 SpringBoot整合ElasticSearch7.4.2，简单而详细 1、创建一个SpringBoot项目 2、导入相关的坐标，写入pom文件 3、创建一个配置类，用于配置Elasticsearch的集群信息 4、编写配置文件 5、向elasticsearch中存入测试数据 6、编写测试controller 7、启动服务，并使用postman发送请求 SpringBoot整合ElasticSearch7.4.2，简单而
SpringBoot集成 ElasticSearch
阿水的博客
04-14 6227
Spring Boot 集成 ElasticSearch Elasticsearch 是位于 Elastic Stack 核心的分布式搜索和分析引擎。Logstash 和 Beats 有助于收集、聚合和丰富您的数据并将其存储在 Elasticsearch 中。Kibana 使您能够以交互方式探索、可视化和分享对数据的见解，并管理和监控堆栈。
SpringBoot集成Elasticsearch7.4 实战（1）
孤山之王
12-30 721
Sprinboot集成Elasticsearch完成对索引的基本操作
SpringBoot 集成Elasticsearch mapping
07-28
- *1* *3* [SpringBoot集成Elasticsearch7.4 实战（一）](https://blog.csdn.net/qq_37284798/article/details/128718272)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
SpringBoot整合Canal实现数据同步到ElasticSearch，2024年最新你连原理都还没弄明白
最新发布
2401_84167086的博客
04-17 785
canal 译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费，canal可以用来监控数据库数据的变化，从而获得新增数据，或者修改的数据。canal原理就是伪装成mysql的从节点，从而订阅master节点的binlog日志canal模拟mysql slave的交互协议，伪装自己为mysql slave，向mysql master发送dump协议mysql master收到dump请求，开始推送binary log给slave(也就是canal)
elasticsearch学习，0基础学习
qq_51596772的博客
04-02 351
1、是一种面向文档的搜索引擎与数据分析，他能根据value 获取到key (倒排索引) ，能够根据搜索关键字搜索到想要查到的内容。
ElasticSearch报错client.indices().create方法deprecated
o0way0o的博客
12-10 513
发送请求时报如下错误： ElasticsearchStatusException[Elasticsearch exception [type=mapper_parsing_exception, reason=Failed to parse mapping [properties]: Root mapping definition has unsupported parameters: [all : …]; 检查是否方法过时： 创建索引库CreateIndexRequest应该修改成这个包：
【ElasticSearch教程】--- Elasticsearch JavaApi 索引操作（十七）
maoye的博客
05-11 763
JavaApi 索引操作 与RESTful api类似， java api 是采用代码的形式操作索引，也有相同的索引增、改、查操作。下面我们对api 一一进行测试。 创建索引 步骤： 创建HttpHost对象，该对象主要用于链接ES服务器的描述，包含了, host, port, schema。 创建RestClientBuilder对象，该对象由RestClient对象的静态方法build创建，需要带入HttpHost。集群应该还可以带入多个HttpHost。 创建关键对象RestHighLevelCli
elasticSearch 基本操作类
regrethh的博客
03-20 1306
elasticSearch官方文档地址 https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html 因为官方后续不会支持transportClient，所以，本篇博客采用的是RestHighLevelClient客户端。版本是6.4.2。 RestHighLevelCl...
03 java操作elasticsearch完成索引与搜索
张力的程序园
02-27 350
如上一节所示，elasticsearch提供了多种多样Restful格式的api，但es也提供了很多语言的对应插件。es的java客户端包括Java Transport Client和Java REST Client，后者又可分为Java Low Level REST Client和Java High Level REST Client。这一节我们将看一下使用Java High L...
springboot整合elasticsearch7
jdbcmeng的博客
06-28 7106
springboot整合elasticsearch7
springboot+elasticsearch的集成使用
撸码人
03-19 494
最近项目中做对接，需要接入外部es服务，由于自己原先只是简单了解过，所以趁着工作需求来完整的学习一次。 先简单说说环境配置： Windows、springboot2.4.3、elasticsearch7.9.3 1、由于个人没有环境，所以得部署一套es的服务环境，这里简要的说明下这个部署 采用安装包部署，下载地址先放上：https://elasticsearch.cn/download/ 下载一定要选准自己所需的版本号一致，具体的安装直接某度吧. 2、springboot+elasticsear
【SpringBoot整合ElasticSearch7.x及实战】
蛋饼吧的博客
02-11 4237
此笔记内容为狂神说SpringBoot整合ElasticSearch部分。
Content-Type详解
热门推荐
阳阳的博客
01-19 7万+
Content-Type是什么？ 在HTTP协议消息头中，使用Content-Type来表示媒体类型信息。它被用来告诉服务端如何处理请求的数据，以及告诉客户端（一般是浏览器）如何解析响应的数据，比如显示图片，解析html或仅仅展示一个文本等。 Post请求的内容放置在请求体中，Content-Type定义了请求体的编码格式。数据发送出去后，还需要接收端解析才可以。接收端依靠请求头中的Conte...
java 获取elasticsearch Client以及 判断是否存在此索引
一叶扁舟的博客
05-15 7835
总结一下：使用java客户端 连接 ES,获取client public static ESClient buildClient(){ Settings settings = ImmutableSettings.settingsBuilder() .put("client.transport.sniff", true).put("cluster.name", "集群名称").buil
Springboot集成Elasticsearch实战指南
"本文将介绍如何在SpringBoot应用中整合Elasticsearch，主要关注JavaHighLevelRestClient的使用和配置。" 在SpringBoot中整合Elasticsearch是一个常见的需求，特别是对于那些需要实现高效全文检索功能的Web应用。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值