springboot elasticsearch整合 （整合es操作）

最新推荐文章于 2024-05-15 15:31:11 发布
最新推荐文章于 2024-05-15 15:31:11 发布
阅读量1.8k 收藏 4
点赞数
分类专栏： spring boot elasticsearch 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sunday2017/article/details/121523460
版权

版本

**Spring Boot 2.6.0**
**spring-boot-starter-data-elasticsearch 4.3.0**

配置

spring.elasticsearch.uris=http://localhost:9201,http://localhost:9202,http://localhost:9203

RestService.java

package com.sjy.elasticsearch.config;

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.indices.CloseIndexRequest;
import org.elasticsearch.client.indices.CloseIndexResponse;
import org.elasticsearch.client.indices.PutIndexTemplateRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.SearchScrollHits;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.IndexQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * @author shijingyang
 */
@Component
public class RestService {
    protected static final Logger log = LoggerFactory.getLogger(RestService.class);

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    private static final String PLACEHOLDERS = "%s";


    /**
     * 判断索引是否存在
     *
     * @return boolean
     */
    public boolean indexExists(String indexName) {
        try {
            return elasticsearchRestTemplate.indexOps(IndexCoordinates.of(indexName)).exists();
        } catch (Exception e) {
            log.error("RestService##indexExists:", e);
            return false;
        }
    }

    /**
     * 创建索引
     *
     * @param clazz 实体
     * @return boolean
     */
    public boolean createIndex(Class<?> clazz, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            if (!this.indexExists(indexName)) {
                HashMap<String, Object> settingMap = new HashMap<>();
                settingMap.put("number_of_shards", getShardsFromClass(clazz));
                settingMap.put("number_of_replicas", getReplicasFromClass(clazz));
                settingMap.put("max_result_window", 10000000);
                Document settings = Document.from(settingMap);
                return elasticsearchRestTemplate.indexOps(IndexCoordinates.of(indexName)).create(settings);
            } else {
                log.info("{} 索引已经存在", indexName);
            }
        } catch (Exception e) {
            log.error("RestService##createIndex:", e);
        }
        return false;
    }

    /**
     * 删除索引
     *
     * @param clazz 实体
     * @return boolean
     */
    public boolean deleteIndex(Class<?> clazz, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            if (this.indexExists(indexName)) {
                return elasticsearchRestTemplate.indexOps(IndexCoordinates.of(indexName)).delete();
            } else {
                log.info("{} 索引不存在", indexName);
            }
        } catch (Exception e) {
            log.error("RestService##deleteIndex:", e);
        }
        return false;
    }

    /**
     * 关闭索引
     *
     * @param clazz 实体
     * @return boolean
     */
    public boolean closeIndex(Class<?> clazz, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            CloseIndexRequest request = new CloseIndexRequest(indexName);
            CloseIndexResponse execute = elasticsearchRestTemplate.execute(client -> client.indices().close(request, RequestOptions.DEFAULT));
            boolean acknowledged = execute.isAcknowledged();
            if (acknowledged) {
                log.info("close index {} success" ,indexName );
            }else{
                log.info("close index {} fail" ,indexName );
            }
            return acknowledged;
        } catch (Exception e) {
            log.error("RestService##deleteIndex:", e);
            return false;
        }
    }

    /**
     * 打开索引
     *
     * @param clazz 实体
     * @return boolean
     */
    public boolean openIndex(Class<?> clazz, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            OpenIndexRequest request = new OpenIndexRequest(indexName);
            OpenIndexResponse execute = elasticsearchRestTemplate.execute(client -> client.indices().open(request, RequestOptions.DEFAULT));
            boolean acknowledged = execute.isAcknowledged();
            if (acknowledged) {
                log.info("open index {} success" ,indexName );
            }else{
                log.info("open index {} fail" ,indexName );
            }
            return acknowledged;
        } catch (Exception e) {
            log.error("RestService##deleteIndex:", e);
            return false;
        }
    }

    /**
     * 设置索引Mapping
     *
     * @param clazz
     * @param json
     * @param placeholders
     * @return
     */
    public boolean putMapping(Class<?> clazz, String json, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            return elasticsearchRestTemplate.indexOps(IndexCoordinates.of(indexName)).putMapping(Document.parse(json));
        } catch (Exception e) {
            log.error("RestService##deleteIndex:", e);
            return false;
        }
    }

    /**
     * 设置 template
     *
     * @param name
     * @param source
     * @return
     */
    public boolean putTemplate(String name, String source) {
        try {
            PutIndexTemplateRequest builder = new PutIndexTemplateRequest(name);
            builder.source(source, XContentType.JSON);
            AcknowledgedResponse execute = elasticsearchRestTemplate.execute(client -> client.indices().putTemplate(builder, RequestOptions.DEFAULT));
            return execute.isAcknowledged();
        } catch (Exception e) {
            log.error("RestService##putTemplate:", e);
            return false;
        }
    }

    /**
     * 新增文档
     *
     * @param clazz
     * @param source
     * @param placeholders
     * @param <T>
     * @return
     */
    public <T> String index(Class<T> clazz, T source, String... placeholders) {
        String indexName = getIndexName(clazz, placeholders);
        return elasticsearchRestTemplate.index(new IndexQueryBuilder().withId(getIdFromSource(source))
                .withObject(source).build(), IndexCoordinates.of(indexName));
    }

    /**
     * 批量插入
     *
     * @param list
     * @param clazz
     * @param placeholders
     * @return
     */
    public boolean bulkIndex(List<?> list, Class<?> clazz, String... placeholders) {
        String indexName = getIndexName(clazz, placeholders);
        try {
            if (list != null && !list.isEmpty()) {
                List<IndexQuery> indexQueries = new ArrayList<>();
                list.forEach(source ->
                        indexQueries.add(new IndexQueryBuilder().withId(getIdFromSource(source)).withObject(source).build()));
                elasticsearchRestTemplate.bulkIndex(indexQueries, IndexCoordinates.of(indexName));
            }
        } catch (Exception e) {
            log.error("RestService##bulkIndex:", e);
            return false;
        }
        return true;
    }


    /**
     * 滚动查询
     *
     * @param query
     * @param clazz
     * @param placeholders
     * @return
     */
    public SearchScrollHits<?> scrollFirst(Query query, Class<?> clazz, String... placeholders) {
        String indexName = getIndexName(clazz, placeholders);
        try {
            return elasticsearchRestTemplate.searchScrollStart(60000, query, clazz, IndexCoordinates.of(indexName));
        } catch (Exception e) {
            log.error("RestService##scrollFirst:", e);
        }
        return null;
    }

    public SearchScrollHits<?> scroll(String scrollId, Class<?> clazz, String... placeholders) {
        String indexName = getIndexName(clazz, placeholders);
        try {
            return elasticsearchRestTemplate.searchScrollContinue(scrollId, 60000, clazz, IndexCoordinates.of(indexName));
        } catch (Exception e) {
            log.error("RestService##scrollFirst:", e);
        }
        return null;
    }

    public SearchHits<?> search(Query query, Class<?> clazz, String... placeholders) {
        try {
            String indexName = getIndexName(clazz, placeholders);
            return elasticsearchRestTemplate.search(query, clazz, IndexCoordinates.of(indexName));
        } catch (Exception e) {
            log.error("RestService##scrollFirst:", e);
        }
        return null;
    }

    /**
     * 获取 @id 属性的数据
     *
     * @param source
     * @return
     */
    private String getIdFromSource(Object source) {
        if (source == null) {
            return null;
        } else {
            Field[] fields = source.getClass().getDeclaredFields();
            Field[] var2 = fields;
            int var3 = fields.length;

            for (int var4 = 0; var4 < var3; ++var4) {
                Field field = var2[var4];
                if (field.isAnnotationPresent(Id.class)) {
                    try {
                        field.setAccessible(true);
                        Object name = field.get(source);
                        return name == null ? null : name.toString();
                    } catch (IllegalAccessException var7) {
                    }
                }
            }
            return null;
        }
    }

    /**
     * 获取实体类注解索引名称
     *
     * @param source
     * @return
     */
    private String getIndexFromClass(Class<?> source) {
        try {
            return source.getAnnotation(org.springframework.data.elasticsearch.annotations.Document.class).indexName();
        } catch (Exception e) {
            log.error("RestService##getIndexFromClass", e);
        }
        return null;
    }

    private long getShardsFromClass(Class<?> source) {
        try {
            return source.getAnnotation(Setting.class).shards();
        } catch (Exception e) {
            log.error("RestService##getShardsFromClass", e);
        }
        return 1;
    }

    private long getReplicasFromClass(Class<?> source) {
        try {
            return source.getAnnotation(Setting.class).replicas();
        } catch (Exception e) {
            log.error("RestService##getReplicasFromClass", e);
        }
        return 1;
    }

    /**
     * 获取索引名称
     *
     * @param clazz
     * @param placeholders
     * @return
     */
    private String getIndexName(Class<?> clazz, String... placeholders) {
        String indexName = getIndexFromClass(clazz);
        Assert.notNull(indexName, "indexName must not be null");
        if (indexName.contains(PLACEHOLDERS)) {
            Assert.notEmpty(placeholders, "placeholders must not be null");
            indexName = String.format(indexName, placeholders);
        }
        return indexName;
    }
}

实体

LogMessage.java

package com.sjy.elasticsearch.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Setting;

import java.io.Serializable;
import java.util.Date;

/**
 * log-message-test-2021-11-24
 * log-message-dev-2021-11-24
 * @author shijingyang
 */
@Document(indexName = "log-message-%s-%s")
@Setting(shards = 2, replicas = 2)
public class LogMessage implements Serializable {

    @Id
    @Field(type = FieldType.Keyword)
    private String id;
    @Field(type = FieldType.Keyword)
    private String level;
    @Field(type = FieldType.Long)
    private Long createTime;
    @Field(type = FieldType.Text)
    private String msg;

    ...getter and setter...
}

Student.java

package com.sjy.elasticsearch.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Setting;

import java.io.Serializable;

/**
 * @author shijingyang
 */
@Document(indexName = "student")
@Setting(shards = 2, replicas = 2)
public class Student implements Serializable {

    public Student(long id, String name, Integer age, String sex, String desc) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.desc = desc;
    }

    @Id
    private long id;
    @Field(type = FieldType.Keyword)
    private String name;
    @Field(type = FieldType.Integer)
    private Integer age;
    @Field(type = FieldType.Keyword)
    private String sex;
    @Field(type = FieldType.Text)
    private String desc;
   ...getter and setter...  
}

StudentDao.java

package com.sjy.elasticsearch;

import com.sjy.elasticsearch.entity.Student;
import org.elasticsearch.client.ElasticsearchClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

/**
 * @author shijingyang
 */
public interface StudentDao extends ElasticsearchRepository<Student,Long> {

}

TEST

package com.sjy.elasticsearch;

import com.sjy.elasticsearch.config.RestService;
import com.sjy.elasticsearch.entity.LogMessage;
import com.sjy.elasticsearch.entity.Student;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.SearchScrollHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.UUID;

@SpringBootTest
class ElasticsearchApplicationTests {


    @Autowired
    private StudentDao studentDao;

    @Test
    void saveAll() {
        for (int j = 1; j <= 100; j++) {
            ArrayList<Student> students = new ArrayList<>();
            for (int i = 1; i <= 500; i++) {
                Student student = new Student(j * (i + 1), "student name" + j * (i + 1), j * (i + 1), j * (i + 1) + "", "I don't know");
                students.add(student);
            }
            long start = System.currentTimeMillis();
            studentDao.saveAll(students);
            long end = System.currentTimeMillis();
            System.out.println(j + " : " + (end - start));
        }
    }

    @Autowired
    RestService restService;

    @Test
    void indexExists() {
        boolean student = restService.indexExists("student");
        boolean student22 = restService.indexExists("student11");
        boolean student33 = restService.indexExists("student22");
        System.out.println("student22 = " + student22);
        System.out.println("student33 = " + student33);
        System.out.println("student = " + student);
    }

    @Test
    void test2() {

    }

    @Test
    void putTemplate() {
        // restService.putTemplate("content-template", "{\"index_patterns\":\"content_*\",\"order\":1,\"settings\":{\"number_of_shards\":4,\"number_of_replicas\":1},\"mappings\":{\"properties\":{\"@timestamp\":{\"type\":\"date\",\"format\":\"yyyy-MM-dd HH:mm:ss\"}}}}");
        System.out.println(restService.putTemplate("log-template", "{\"index_patterns\":\"log-message-*\",\"order\":1,\"settings\":{\"number_of_shards\":2,\"number_of_replicas\":0,\"max_result_window\":10000000},\"mappings\":{\"properties\":{\"id\":{\"index\":true,\"type\":\"keyword\"},\"level\":{\"index\":true,\"type\":\"keyword\"},\"createTime\":{\"index\":true,\"type\":\"long\"},\"msg\":{\"index\":true,\"type\":\"text\"}}}}"));
    }

    @Test
    void deleteIndex() {
        System.out.println(restService.deleteIndex(LogMessage.class, "dev", LocalDate.now().toString()));
    }

    @Test
    void createIndex() {
        System.out.println(restService.createIndex(LogMessage.class, "dev", LocalDate.now().toString()));
    }

    @Test
    void closeIndex() {
        System.out.println(restService.closeIndex(LogMessage.class, "dev", LocalDate.now().toString()));
    }

    @Test
    void openIndex() {
        System.out.println(restService.openIndex(LogMessage.class, "dev", LocalDate.now().toString()));
    }

    @Test
    void index() {
        LogMessage logMessage = new LogMessage();
        logMessage.setId(UUID.randomUUID().toString());
        logMessage.setCreateTime(System.currentTimeMillis());
        logMessage.setMsg("elasticsearch yyds");
        logMessage.setLevel("INFO");
        System.out.println(restService.index(LogMessage.class, logMessage, "dev", LocalDate.now().toString()));
    }

    @Test
    void bulkIndex() {
        for (int j = 0; j < 100; j++) {
            ArrayList<LogMessage> logMessages = new ArrayList<>();
            for (int i = 0; i < 500; i++) {
                LogMessage logMessage = new LogMessage();
                logMessage.setId(UUID.randomUUID().toString());
                logMessage.setCreateTime(System.currentTimeMillis());
                logMessage.setMsg("elasticsearch yyds " + i + "-" + j);
                logMessage.setLevel("INFO");
                logMessages.add(logMessage);
            }
            restService.bulkIndex(logMessages, LogMessage.class, "dev", LocalDate.now().toString());
        }
    }

    @Test
    void scroll() {
        QueryBuilder age = QueryBuilders.matchQuery("msg", "elasticsearch yyds 0");
        RangeQueryBuilder createTime = QueryBuilders.rangeQuery("createTime").gte(1637754072221L).lte(1637754072221L);

        int pageSize = 100;
        Query query = new NativeSearchQueryBuilder().withQuery(age).withQuery(createTime).withPageable(Pageable.ofSize(pageSize)).build();
        String dateStr = LocalDate.now().toString();
        SearchScrollHits<?> searchHits = restService.scrollFirst(query, LogMessage.class,"dev", dateStr);
        long totalHits = searchHits.getSearchHits().size();

        System.out.println(totalHits);
        String scrollId = searchHits.getScrollId();
        while (totalHits == pageSize) {
            SearchScrollHits<?> scroll = restService.scroll(scrollId, LogMessage.class,"dev", dateStr);
            scrollId = scroll.getScrollId();
            totalHits = scroll.getSearchHits().size();
            System.out.println(totalHits);
        }
        System.out.println("down");
    }

    @Test
    void search() {
        QueryBuilder age = QueryBuilders.matchQuery("msg", "elasticsearch yyds 0");
        RangeQueryBuilder createTime = QueryBuilders.rangeQuery("createTime").gte(1637754072221L);
        int pageSize = 10000;
        PageRequest pageRequest = PageRequest.of(0, pageSize, Sort.Direction.ASC, "createTime");
        Query query = new NativeSearchQueryBuilder().withQuery(age).withQuery(createTime).withPageable(pageRequest).build();
        SearchHits<?> search = restService.search(query, LogMessage.class,"dev", LocalDate.now().toString());
        System.out.println(search.getSearchHits());
    }
}

参考

https://docs.spring.io/spring-data/elasticsearch/docs/4.3.0/reference/html/#

Sunday2017
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合Elasticsearch
qq_20395245的博客
01-30 737
前面介绍了Elasticsearch的搭建，API使用，测试数据实战搜索。本文介绍怎么在SpringBoot中整合Elasticsearch。
SpringBoot整合ElasticSearch实践
08-30
通过引入 spring-boot-starter-data-elasticsearch 依赖，我们可以使用 SpringBoot 的数据访问对象（DAO）来操作 Elasticsearch。我们可以使用 @Document 注解来标注实体类，并使用 @Id 注解来标注主键。 五、使用 ...
springboot集成ElasticSearch
sinat_25112709的博客
03-05 4081
springboot集成ES 7.6.2
spring boot 之 整合 elastic search
最新发布
我叫晨曦啊的博客
05-15 348
Spring Boot整合 ElasticSearch
springboot整合elasticsearch
qq_36779138的博客
12-24 1454
在idea中新建项目，选择spring模板。 选择elasticsearch依赖。 项目的pom文件是这样的。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.a.
Spring集成Elasticsearch
xulong5000的专栏
07-15 1816
依赖组件 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-elasticsearch</artifactId> </dependency> 配置 spring: elasticsearch: rest: uris: - ip1:port
Springboot中使用ElasticSearch
fchen521的博客
05-19 1439
本篇文章主要是为了帮助大家快速上手及了解springboot操作ElasticSearch的一些基本使用api,更多的还是推荐大家去看官方文档
SpringBoot整合Elasticsearch7.2.0的实现方法
08-25
SpringBoot整合Elasticsearch7.2.0的实现方法 在本篇文章中，我们将详细介绍如何将 Spring Boot 与 Elasticsearch 7.2.0 整合的实现方法。该方法主要通过示例代码进行详细的介绍，对大家的学习或者工作具有一定的...
SpringBoot整合Spring Data Elasticsearch的过程详解
08-25
"SpringBoot整合Spring Data Elasticsearch的过程详解" SpringBoot整合Spring Data Elasticsearch是将SpringBoot框架与Elasticsearch搜索引擎进行整合，以实现数据的搜索和索引功能。下面将详细介绍SpringBoot整合...
SpringBoot整合elasticsearch集群
01-07
8.2.8 SpringBoot整合elasticsearch集群 Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。Spring Boot是由Pivotal团队...
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
Spring Boot 整合 Elasticsearch
程序员35
10-16 850
文章目录1 概述1.1 简介1.2 基本概念1.3 常用命令2 创建工程并配置3 使用4 测试 学习在 Spring Boot 中 Elasticsearch。在 Spring Boot 中，使用的 Elasticsearch 实际上是 Spring Data Elasticsearch ， Spring Data 是 Spring 家族的一个子项目，用于简化 SQL 和 NoSQL 的访问，在 Spring Data 中，只要你的方法名称符合规范，它就知道你想干什么，不需要自己再去写 SQL 。 1 概述
SpringBoot整合ElasticSearch
cxmengxin的博客
01-03 1104
SpringBoot整合ElasticSearch
通过Spring Data Elasticsearch操作ES
zhiwenganyong的博客
02-01 6978
Elasticsearch (ES)是一个基于Lucene构建的开源、分布式、RESTful 接口全文搜索引擎，Spring Data是Spring 的一个子项目。用于简化数据库访问，支持NoSQL和关系数据库存储。其主要目标是使数据库的访问变得方便快捷，本文介绍通过Spring Data Elasticsearch操作ES
【Java】SpringBoot快速整合ElasticSearch
m0_64210833的博客
12-29 5394
SpringBoot快速整合ElasticSearch
【应用】SpringBoot 整合 Elasticsearch
情绪瓜皮皮丶的学习之路
01-18 1729
整理总结了 SpringBoot 整合 Elasticsearch 的基本使用
SpringBoot进阶-集成ElasticSearch(二)
Cloud的专栏
08-18 1719
集成ES,我们使用spring-data-es模块，这块API改动挺大的，以前的方法很多都过时了，我现在使用的spring-boot版本是2.3.2 第一步,添加依赖 <!-- ElasticSearch支持 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearc
SpringBoot集成elasticsearch实战
AllenLuoYi的博客
06-09 489
一、添加elasticsearch依赖 二、配置elasticsearch地址 三、编写配置类配置访问对象RestHighLevelClient 四、elasticsearch基本操作（索引创建，文档增删改查，文档批量新增，精确查询、匹配查询）
SpringCloud（10）— Elasticsearch集群
shaopengjie的博客
12-29 1168
单机的 Elasticsearch 做数据存储，必然面临两个问题：海量数据存储问题，单点故障等。
springboot elasticsearch整合
03-16
需要在 pom.xml 文件中添加 Elasticsearch 的依赖，然后在 application.properties 或者 application.yml 文件中配置 Elasticsearch 的连接信息，最后可以使用 Spring Data Elasticsearch 来操作 Elasticsearch。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值