SpringBoot整合elasticsearch

最新推荐文章于 2024-06-11 18:01:44 发布
最新推荐文章于 2024-06-11 18:01:44 发布
阅读量2.5k 收藏 10
点赞数 4
分类专栏： java  初级 文章标签： es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50990903/article/details/117170364
版权

SpringBoot整合ES

1.pom.xml依赖

<!--引入es的坐标-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.4.0</version>
        </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>

2.application.yml配置

server:
  port: 8080

elasticsearch:
  host: localhost
  port: 9200

3.ESConfig.java

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix="elasticsearch")
public class ElasticSearchConfig {

    private String host;

    private int port;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
    @Bean
    public RestHighLevelClient client(){
        return new RestHighLevelClient(RestClient.builder(
                new HttpHost(host,port,"http")
        ));
    }
}

4.测试

4.1索引测试

数据准备

import lombok.Data;

@Data
public class Person {
    private String id;
    private String name;
    private int age;
    private String address;
}

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.IndicesClient;
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.client.indices.GetIndexResponse;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

@SpringBootTest(classes = ESAPP.class)
@RunWith(SpringRunner.class)
public class ESTest {
    @Autowired
    private RestHighLevelClient client;

    @Test
    //添加索引
    public void addIndex()throws Exception{
        //1.使用client获取操作索引的对象
        IndicesClient indices = client.indices();
        //2.具体操作，获取返回值
        CreateIndexRequest createIndexRequest=new CreateIndexRequest("ztuo");
        CreateIndexResponse response = indices.create(createIndexRequest, RequestOptions.DEFAULT);
        //3.根据返回值判断结果
        System.out.println(response.isAcknowledged());
    }

    /**
     * 添加索引，并添加映射
     */
    @Test
    public void addIndexAndMapping() throws IOException {
        //1.使用client获取操作索引对象
        IndicesClient indices = client.indices();
        //2.具体操作获取返回值
        //2.具体操作，获取返回值
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("itcast");
        //2.1 设置mappings
        String mapping = "{\n" +
                "      \"properties\" : {\n" +
                "        \"address\" : {\n" +
                "          \"type\" : \"text\",\n" +
                "          \"analyzer\" : \"ik_max_word\"\n" +
                "        },\n" +
                "        \"age\" : {\n" +
                "          \"type\" : \"long\"\n" +
                "        },\n" +
                "        \"name\" : {\n" +
                "          \"type\" : \"keyword\"\n" +
                "        }\n" +
                "      }\n" +
                "    }";
        createIndexRequest.mapping(mapping, XContentType.JSON);

        CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
        //3.根据返回值判断结果
        System.out.println(createIndexResponse.isAcknowledged());
    }


    /**
     * 查询索引
     */
    @Test
    public void queryIndex() throws Exception{
        IndicesClient indices = client.indices();

        GetIndexRequest getIndexRequest=new GetIndexRequest("itcast");
        GetIndexResponse response = indices.get(getIndexRequest, RequestOptions.DEFAULT);
        Map<String, MappingMetaData> mappings=response.getMappings();
        //iter 提示foreach
        for (String key : mappings.keySet()) {
            System.out.println(key+"==="+mappings.get(key).getSourceAsMap());
        }
    }

    /**
     * 删除索引
     */
    @Test
    public void deleteIndex() throws IOException {
        IndicesClient indices = client.indices();
        DeleteIndexRequest deleteRequest=new DeleteIndexRequest("itheima");
        AcknowledgedResponse delete = indices.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());

    }

    /**
     * 索引是否存在
     */
    @Test
    public void existIndex() throws IOException {
        IndicesClient indices = client.indices();

        GetIndexRequest getIndexRequest=new GetIndexRequest("itheima");
        boolean exists = indices.exists(getIndexRequest, RequestOptions.DEFAULT);

        System.out.println(exists);
    }

}

4.2文档测试

import cn.ztuo.es.pojo.Person;
import com.alibaba.fastjson.JSON;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@SpringBootTest(classes = ESAPP.class)
@RunWith(SpringRunner.class)
public class ESdocTest {
    @Autowired
    private RestHighLevelClient client;

    /**
     * 添加文档,使用map作为数据
     */
    @Test
    public void addDoc()throws Exception{
        //数据对象，map
        Map data = new HashMap();
        data.put("address", "北京昌平");
        data.put("name", "大胖");
        data.put("age", 20);

        //1。获取操作文档对象
        IndexRequest request=new IndexRequest("itcast").id("1").source(data);
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);

        //打印响应结果
        System.out.println(response.getId());
    }

    /**
     * 添加文档,使用对象作为数据
     * 修改文档：添加文档时，如果id存在则修改，id不存在则添加
     */
    @Test
    public void addDoc2() throws IOException {
        //数据对象，javaObject
        Person p = new Person();
        p.setId("2");
        p.setName("小胖2222");
        p.setAge(30);
        p.setAddress("陕西西安");

        //将对象转为json
        String data = JSON.toJSONString(p);

        //1.获取操作文档的对象
        IndexRequest request = new IndexRequest("itcast").id(p.getId()).source(data,
                XContentType.JSON);
        //添加数据，获取结果
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);

        //打印响应结果
        System.out.println(response.getId());
    }

    /**
     * 根据id查询文档
     */
    @Test
    public void getDoc()throws Exception{
        GetRequest indexRequest=new GetRequest("itcast","2");
        GetResponse response = client.get(indexRequest, RequestOptions.DEFAULT);
        System.out.println(response.getSourceAsString());
    }
}

4.3-高级查询


import cn.ztuo.es.pojo.Goods;
import com.alibaba.fastjson.JSON;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

@SpringBootTest(classes = ESAPP.class)
@RunWith(SpringRunner.class)
public class ESQueryTest {
    @Autowired
    private RestHighLevelClient client;

    /**
     * 批量导入
     */
    @Test
    public void imporyData()throws Exception{
        //1.查询所有数据，mysql
        //List<Goods> goodsList = goodsMapper.findAll();
        List<Goods> goodsList = new ArrayList<>();

        //2.bulk导入
        BulkRequest bulkRequest = new BulkRequest();

        //2.1 循环goodsList，创建IndexRequest添加数据
        for (Goods goods : goodsList) {
            //2.2 设置spec规格信息 Map的数据   specStr:{}
            //goods.setSpec(JSON.parseObject(goods.getSpecStr(),Map.class));

            String specStr = goods.getSpecStr();
            //将json格式字符串转为Map集合
            Map map = JSON.parseObject(specStr, Map.class);
            //设置spec map
            goods.setSpec(map);
            //将goods对象转换为json字符串
            String data = JSON.toJSONString(goods);//map --> {}
            IndexRequest indexRequest = new IndexRequest("goods");
            indexRequest.id(goods.getId() + "").source(data, XContentType.JSON);
            bulkRequest.add(indexRequest);
        }

        BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

    /**
     * 查询所有
     *  1. 高级查询
     *  2. 将查询结果封装为Goods对象，装载到List中
     *  3. 分页。默认显示10条
     */
    @Test
    public void queryPlusAll() throws Exception{
        //2. 构建查询请求对象，指定查询的索引名称
        SearchRequest searchRequest=new SearchRequest("goods");

        //3. 创建查询条件构建器SearchSourceBuilder
        SearchSourceBuilder sourceBuilder=new SearchSourceBuilder();

        //  查询条件 match_all查询
        MatchAllQueryBuilder query = QueryBuilders.matchAllQuery();


        /*//term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词。
        QueryBuilder query = QueryBuilders.termQuery("title", "华为");*/


        /*//match Query即全文检索，它的搜索方式是先将搜索字符串分词，再使用各各词条从索引中搜索。
        MatchQueryBuilder query = QueryBuilders.matchQuery("title", "华为手机");
        query.operator(Operator.AND);//求交集*/

        /*//模糊查询 wildcard：会对查询条件进行分词
        WildcardQueryBuilder query = QueryBuilders.wildcardQuery("title", "华*");//华后多个字符
        //正则查询
        RegexpQueryBuilder query = QueryBuilders.regexpQuery("title", "\\w+(.)*");
        //前缀查询
        PrefixQueryBuilder query = QueryBuilders.prefixQuery("brandName", "三");*/


        /*//范围查询 以price 价格为条件
        RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
        //指定下限
        query.gte(2000);
        //指定上限
        query.lte(3000);*/


        /*//queryString
        QueryStringQueryBuilder query =
                QueryBuilders.queryStringQuery("华为手机")
                        .field("title").field("categoryName").field("brandName")
                        .defaultOperator(Operator.AND);*/


        /*//boolQuery：对多个查询条件连接。
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        //2.构建各个查询条件
        //2.1 查询品牌名称为:华为
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("brandName", "华为");
        boolQuery.must(termQueryBuilder);

        //2.2. 查询标题包含：手机
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("title", "手机");
        boolQuery.filter(matchQuery);

        //2.3 查询价格在：2000-3000
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
        rangeQuery.gte(2000);
        rangeQuery.lte(3000);
        boolQuery.filter(rangeQuery);*/


        //聚合查询 查询品牌列表  只展示前100条
        AggregationBuilder aggregation= AggregationBuilders.terms("goods_brands").field("brandName").size(100);
        sourceBuilder.aggregation(aggregation);


        /*//高亮查询
        // 1. 查询title包含手机的数据
        MatchQueryBuilder query = QueryBuilders.matchQuery("title", "手机");

        sourceBulider.query(query);

        //设置高亮
        HighlightBuilder highlighter = new HighlightBuilder();
        //设置三要素
        highlighter.field("title");
        //设置前后缀标签
        highlighter.preTags("<font color='red'>");
        highlighter.postTags("</font>");

        //加载已经设置好的高亮配置
        sourceBulider.highlighter(highlighter);*/



        //5.指定查询条件
        sourceBuilder.query(query);

        //6.添加查询条件构建器
        searchRequest.source(sourceBuilder);

        //7.添加分页信息
        sourceBuilder.from(0);
        sourceBuilder.size(100);

        //1. 查询,获取查询结果
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //8.获取命中对象
        SearchHits hits = searchResponse.getHits();

        //8.1获取总记录条数
        long value = hits.getTotalHits().value;
        System.out.println("总数:"+value);

        //8.2获取hits数据 数组
        SearchHit[] hits1 = hits.getHits();
        //获取json字符串格式的数据
        List<Goods> goodsList =new ArrayList<>();
        for (SearchHit searchHit : hits1) {
            String sourceAsString = searchHit.getSourceAsString();
            //转为java对象
            Goods goods = JSON.parseObject(sourceAsString, Goods.class);
            goodsList.add(goods);
        }
        for (Goods goods : goodsList) {
            System.out.println(goods);
        }
    }
}

5.高级查询解释

5.1-matchAll-脚本

查询所有商品信息

默认查询只能查询10条数据

5.2-termQuery

term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词。

5.3-matchQuery

match Query即全文检索，它的搜索方式是先将搜索字符串分词，再使用各各词条从索引中搜索。

5.4-termQuery和matchQuery的区别

  • term query会去倒排索引中寻找确切的term，它并不知道分词器的存在。这种查询适合keyword 、numeric、date
  • match query知道分词器的存在。并且理解是如何被分词的

5.5-模糊查询(了解)

wildcard查询：会对查询条件进行分词。还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）

"*华*"  包含华字的
"华*"   华字后边多个字符
"华?"  华字后边单个字符
"*华"或"?华" 会引发全表（全索引）扫描 注意效率问题

# wildcard 查询。查询条件分词，模糊查询
GET goods/_search
{
  "query": {
    "wildcard": {
      "title": {
        "value": "华*"
      }
    }
  }
}
5.5.1-正则查询
\W：匹配包括下划线的任何单词字符，等价于 [A-Z a-z 0-9_]   开头的反斜杠是转义符

+号多次出现

(.)*为任意字符
正则查询取决于正则表达式的效率

GET goods/_search
{
  "query": {
    "regexp": {
      "title": "\\w+(.)*"
    }
  }
}
5.5.2-前缀查询

对keyword类型支持比较好

# 前缀查询 对keyword类型支持比较好
GET goods/_search
{
  "query": {
    "prefix": {
      "brandName": {
        "value": "三"
      }
    }
  }
}

5.6-范围&排序查询

范围查询：查找指定字段在指定范围内包含值：gte大于等于,lte 小于等于

gte: greater than or equal 大于等于
lte: less than or equal 小于等于
排序查询：desc 降序，asc升序

5.7-queryString多字段查询

queryString 多条件查询,可以让字符串中包含关键词

•会对查询条件进行分词。
•然后将分词后的查询条件和词条进行等值匹配
•默认取并集（OR）
•可以指定多个查询字段

query_string：识别query中的连接符（or 、and）

# queryString
GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","categoryName","brandName"], 
      "query": "华为 AND 手机"
    }
  }
}

simple_query_string：不识别query中的连接符（or 、and），查询时会将 “华为”、“and”、“手机”分别进行查询

GET goods/_search
{
  "query": {
    "simple_query_string": {
      "fields": ["title","categoryName","brandName"], 
      "query": "华为 AND 手机"
    }
  }
}

query_string：有default_operator连接符的脚本

GET goods/_search
{
  "query": {
    "query_string": {
      "fields": ["title","brandName","categoryName"],
      "query": "华为手机 "
      , "default_operator": "AND"
    }
  }
}

5.8-布尔查询-脚本

boolQuery：对多个查询条件连接。

must（and）：条件必须成立
must_not（not）：条件必须不成立
should（or）：条件可以成立
filter：条件必须成立，性能比must高。不会计算得分
       得分:即条件匹配度,匹配度越高，得分越高

5.9-高亮查询-脚本

高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置。

高亮三要素：

•高亮字段

•前缀

•后缀

默认前后缀 ：

<em>手机</em>

替换默认高亮前后缀为：更改字体颜色为red

GET goods/_search
{
  "query": {
    "match": {
      "title": "电视"
    }
  },
  "highlight": {
    "fields": {
      "title": {
        "pre_tags": "<font color='red'>",
        "post_tags": "</font>"
      }
    }
  }
}
似夜晓星辰
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合Elasticsearch7.2.0的实现方法
08-25
SpringBoot整合Elasticsearch7.2.0的实现方法 在本篇文章中，我们将详细介绍如何将 Spring Boot 与 Elasticsearch 7.2.0 整合的实现方法。该方法主要通过示例代码进行详细的介绍，对大家的学习或者工作具有一定的...
ElasticSearch基础学习（SpringBoot集成ES）
weibingbing_net的专栏
07-08 4891
什么是ElasticSearch？ElasticSearch，简称为ES， ES是一个开源的高扩展的分布式全文搜索引擎。它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。ES也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的来隐藏Lucene的复杂性，从而让全文搜索变得简单。ES核心概念知道了ES是什么后，接下来还需要知道ES是如何存储数据，数据结构是什么，又是如何实现搜索的呢？
maven项目使用java接口连接elasticsearch，基本操作：增删改查
百草疯茂的专栏
11-06 5841
创建maven项目，创建myElasticSearch.java文件，在App.java(默认创建文件)中的Main()执行。 pom.xml文件 &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoc...
12-Springboot集成Elasticsearch
最新发布
qq_42397932的博客
06-11 1038
Springboot集成Es
ElasticSearch高级操作
凉茶铺的博客
04-22 1160
介绍了ElasticSearch的高级操作（使用java代码操作）
Elasticsearch：Java使用批量操作bulk及注意事项
样young的博客
03-02 7180
1.BulkRequest对象可以用来在一次请求中，执行多个索引、更新或删除操作 且允许在一次请求中进行不同的操作，即一次请求中索引、更新、删除操作可以同时存在 BulkRequest bulkRequest = new BulkRequest(); bulkRequest.add(new DeleteRequest("posts", "doc", "300")); bulkRequ...
SpringBoot整合Elasticsearch完整源码
02-16
这个"SpringBoot整合Elasticsearch完整源码"提供了实现这一目标的详细步骤和代码实例。以下是对相关知识点的详细说明： 1. **Spring Boot**： Spring Boot是由Pivotal Team创建的，旨在简化Spring应用的初始搭建...
SpringBoot整合elasticsearch集群
01-07
8.2.8 SpringBoot整合elasticsearch集群 Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。Spring Boot是由Pivotal团队...
springboot整合ElasticSearch集群
03-29
springboot 2.0.2集成elasticsearch5.5.1，并使用集群模式，亲测可用！！！
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
SpringBoot整合ElasticSearch实践
08-30
SpringBoot 整合 Elasticsearch 实践 本篇文章主要介绍了 SpringBoot 整合 Elasticsearch 实践，通过一个发表文章的案例来说明 SpringBoot 如何与 Elasticsearch 集成。Elasticsearch 本身可以是一个独立的服务，也...
springboot整合Elasticsearch
12-05
通过以上步骤，你可以轻松地在Spring Boot应用中整合Elasticsearch，实现高效的全文搜索、数据分析和存储功能。随着项目的深入，还可以探索更高级的功能，如聚合分析、地理位置搜索、多租户支持等，进一步提升应用的...
SpringBoot整合ElasticSearch的示例代码
08-29
SpringBoot整合ElasticSearch的示例代码 本篇文章主要介绍了SpringBoot整合ElasticSearch的示例代码，通过示例代码讲解了如何将ElasticSearch与SpringBoot整合，实现搜索功能。 知识点1：ElasticSearch简介 ...
springboot整合elasticsearch
01-20
此篇文章为springboot整合elasticsearch的demo,以此做一下记录 文章目录环境准备运行elasticsearchdemo代码展示代码结构图pom.xmlapplication.ymlmodelservicecontroller启动类postman请求连接插入数据查询数据...
SpringBoot整合Elasticsearch并实现CRUD操作
08-27
SpringBoot整合Elasticsearch并实现CRUD操作 在本篇文章中，我们将介绍如何将Spring Boot与Elasticsearch集成，并实现CRUD（Create，Read，Update，Delete）操作。Elasticsearch是一个基于Lucene的搜索引擎，可以...
ElasticSearch（11）bulk批量操作与导入数据
учёба
12-27 3925
1 项目环境准备 springboot整合es：项目代码说明 2 bulk批量操作 都是使用add()方法实现的 未执行之前： package com.yy.esdemo; import org.elasticsearch.action.bulk.BulkRequest; import org.elasticsearch.action.bulk.BulkResponse; import org.elasticsearch.action.delete.DeleteRequest; import or
【ElasticSearch教程】--- Elasticsearch JavaApi 文档批量操作（十九）
maoye的博客
05-15 1673
Elasticsearch JavaApi 文档批量操作 在实际的工程项目中，数据批量操作的需求是比较强烈的，所以ES的API也提供了这样的应用场景。下面将演示如何进行批量的文档增加，文档删除操作。 文档批量增加 在ES中批量的操需要使用到一个请求对象就是BulkRequest，然后将要做的请求集合添加到BulkRequest中，最后使用bulk方法发送批量请求。 批量添加文档的步骤如下 定义要链接主机的信息,这里使用org.apache.http.HttpHost对象。 构建RestClientBuil
Elasticsearch报错：java.lang.NoSuchMethodError：org.elasticsearch.action.bulk.BulkRequest.pipeline（）Ljav
qq_42727102的博客
01-12 2822
1.今天在使用Elasticsearch时，报错：java.lang.NoSuchMethodError：org.elasticsearch.action.bulk.BulkRequest.pipeline（）Ljava / lang / String; 2.最后找出原因是：依赖包版本不一致导致的 3.用下面的依赖即可： <dependency> <gro...
springboot+elasticsearch的集成使用
撸码人
03-19 448
最近项目中做对接，需要接入外部es服务，由于自己原先只是简单了解过，所以趁着工作需求来完整的学习一次。 先简单说说环境配置： Windows、springboot2.4.3、elasticsearch7.9.3 1、由于个人没有环境，所以得部署一套es的服务环境，这里简要的说明下这个部署 采用安装包部署，下载地址先放上：https://elasticsearch.cn/download/ 下载一定要选准自己所需的版本号一致，具体的安装直接某度吧. 2、springboot+elasticsear
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值