springboot项目elsearch工具类实现

已于 2022-05-07 17:14:34 修改
阅读量2.9k 收藏 2
点赞数
文章标签： elasticsearch spring boot java 后端
于 2022-04-21 10:47:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaotianxia/article/details/124315902
版权
该博客介绍了如何在SpringBoot项目中集成Elasticsearch(ELK)来存储和查询日志。通过配置EsRestClientConfig创建REST高阶客户端，并在HighLevelRestUtil类中封装了索引创建、删除、查询、分页查询等常见操作。博客还提醒注意，分页查询使用了简单的from+size方法，适用于小数据量，对于深度查询和大数据量应使用更高效的搜索策略。
摘要由CSDN通过智能技术生成

项目中用到了es，通过ELK存储日志，然后通过系统界面查询，对此es常用操作做了封装，不多说，直接上代码。

环境：jdk(1.8)+es(7.15.2)+springboot(2.3.5.RELEASE)

1、pom.xml

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.15.2</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>7.6.2</version>
</dependency>
<dependency>
     <groupId>org.elasticsearch</groupId>
     <artifactId>elasticsearch</artifactId>
     <version>7.6.2</version>
</dependency>

2、EsRestClientConfig.java

package net.wfl.framework.boot.tools.es;

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.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * ES配置类
 *
 * @author wangfenglei
 */
@ConditionalOnProperty(value = "wfl.base.tools.es.switch", havingValue = "true", matchIfMissing = false)
@Component
public class EsRestClientConfig {
    @Value("${wfl.base.tools.es.ip}")
    private String hostname;
    @Value("${wfl.base.tools.es.port}")
    private int port;
    @Value("${wfl.base.tools.es.username}")
    private String username;
    @Value("${wfl.base.tools.es.password}")
    private String password;

    /**
     * 创建es restHighLevelClient
     *
     * @return 客户端
     */
    @ConditionalOnProperty(value = "wfl.base.tools.es.switch", havingValue = "true", matchIfMissing = false)
    @Bean
    public RestHighLevelClient restHighLevelClient() {
        final CredentialsProvider credentialsProvider =
                new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(username, password));

        RestClientBuilder builder = RestClient.builder(
                new HttpHost(hostname, port))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(
                            HttpAsyncClientBuilder httpClientBuilder) {
                        httpClientBuilder.disableAuthCaching();
                        return httpClientBuilder
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        return new RestHighLevelClient(builder);
    }
}

3、HighLevelRestUtil.java

package net.wfl.framework.boot.tools.es;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
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.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ES工具类
 *
 * @author wangfenglei
 */
@Slf4j
@Component
@ConditionalOnProperty(value = "wfl.base.tools.es.switch", havingValue = "true", matchIfMissing = false)
public class HighLevelRestUtil {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 判断索引是否存在
     *
     * @param index 索引
     * @return 成功标识
     */
    public boolean checkIndex(String index) {
        try {
            return restHighLevelClient.indices().exists(new GetIndexRequest(index), RequestOptions.DEFAULT);
        } catch (Exception e) {
            log.error(e.toString(), e);
            return Boolean.FALSE;
        }
    }

    /**
     * 创建索引
     *
     * @param indexName 索引名称
     * @param columnMap 列
     * @return 创建索引成功标识
     */
    public boolean createIndex(String indexName, Map<String, Object> columnMap) {
        try {
            if (!checkIndex(indexName)) {
                CreateIndexRequest request = new CreateIndexRequest(indexName);
                if (columnMap != null && columnMap.size() > 0) {
                    Map<String, Object> source = new HashMap<>();
                    source.put("properties", columnMap);
                    request.mapping(source);
                }
                this.restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
            }
            return Boolean.TRUE;
        } catch (Exception e) {
            log.error(e.toString(), e);
            return Boolean.FALSE;
        }
    }

    /**
     * 删除索引
     *
     * @param indexName 索引名称
     * @return 删除成功标识
     */
    public boolean deleteIndex(String indexName) {
        try {
            if (checkIndex(indexName)) {
                DeleteIndexRequest request = new DeleteIndexRequest(indexName);
                AcknowledgedResponse response = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
                return response.isAcknowledged();
            }
        } catch (Exception e) {
            log.error(e.toString(), e);
        }

        return Boolean.FALSE;
    }

    /**
     * 获取ES信息
     *
     * @return Es信息
     */
    public SearchResponse getEsInfo() throws Exception {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // SearchRequest
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.source(searchSourceBuilder);
        // 查询ES
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        return searchResponse;
    }

    /**
     * 获取总数
     *
     * @param indexList    索引
     * @param queryBuilder 查询条件
     * @return 总数
     * @throws Exception 异常
     */
    public long getCount(List<String> indexList, QueryBuilder queryBuilder) throws Exception {
        // 通过CountRequest查询获得count
        CountRequest countRequest = new CountRequest();
        if (null != indexList) {
            // 绑定索引名
            countRequest.indices(indexList.toArray(new String[indexList.size()]));
        }

        countRequest.query(queryBuilder);
        CountResponse countResponse = restHighLevelClient.count(countRequest, RequestOptions.DEFAULT);
        // 获取总数
        long total = countResponse.getCount();

        return total;
    }

    /**
     * 从ES分页查询数据列表
     *
     * @param indexList  索引列表
     * @param page       分页信息
     * @param keyword    关键字
     * @param clazz      类
     * @param orderField 排序字段
     * @param fieldNames 查询字段
     * @param <T>        泛型
     * @return 数据列表
     * @throws Exception 异常
     */
    public <T> Page<T> pageList(List<String> indexList, Page<T> page, String keyword, Class<T> clazz, String orderField, String... fieldNames) throws Exception {
        if (StringUtils.isEmpty(keyword)) {
            throw new Exception("The keywork is blank!");
        }
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 分页采用简单的from + size分页，适用数据量小的，了解更多分页方式可自行查阅资料
        searchSourceBuilder.from((int) ((page.getCurrent() - 1) * page.getSize())).size((int) page.getSize());
        QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery(keyword, fieldNames);
        searchSourceBuilder.query(queryBuilder);
        long total = getCount(indexList, queryBuilder);

        if (StringUtils.isNotEmpty(orderField)) {
            // 排序，根据ID倒叙
            searchSourceBuilder.sort(orderField, SortOrder.DESC);
        }

        // SearchRequest
        SearchRequest searchRequest = null == indexList ? new SearchRequest() : new SearchRequest(indexList.toArray(new String[indexList.size()]));
        searchRequest.source(searchSourceBuilder);
        // 查询ES
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchResponse.getHits();
        // 遍历封装列表对象
        List<T> resultList = new ArrayList<>();
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit searchHit : searchHits) {
            resultList.add(JSON.parseObject(searchHit.getSourceAsString(), clazz));
        }

        Page<T> resultPage = new Page<>(page.getCurrent(), page.getSize());
        resultPage.setTotal(total);
        resultPage.setRecords(resultList);

        return resultPage;
    }

    /**
     * 从ES分页查询数据列表
     *
     * @param indexList    索引列表
     * @param page         分页信息
     * @param queryBuilder 查询条件
     * @param orderField   排序字段
     * @param <T>          泛型
     * @return 分页信息
     * @throws Exception 异常
     */
    public <T> Page<T> pageList(List<String> indexList, Page<T> page, QueryBuilder queryBuilder, String orderField, Class<T> clazz) throws Exception {
        // 获取总数
        long total = getCount(indexList, queryBuilder);

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        // 分页采用简单的from + size分页，适用数据量小的，了解更多分页方式可自行查阅资料
        searchSourceBuilder.from((int) ((page.getCurrent() - 1) * page.getSize())).size((int) page.getSize());
        //设置查询条件
        searchSourceBuilder.query(queryBuilder);

        if (StringUtils.isNotEmpty(orderField)) {
            // 排序，倒叙
            searchSourceBuilder.sort(orderField, SortOrder.DESC);
        }

        // SearchRequest
        SearchRequest searchRequest = null == indexList ? new SearchRequest() : new SearchRequest(indexList.toArray(new String[indexList.size()]));
        searchRequest.source(searchSourceBuilder);
        // 查询ES
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchResponse.getHits();

        // 遍历封装列表对象
        List<T> resultList = new ArrayList<>();
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit searchHit : searchHits) {
            resultList.add(JSON.parseObject(searchHit.getSourceAsString(), clazz));
        }

        Page<T> resultPage = new Page<>(page.getCurrent(), page.getSize());
        resultPage.setTotal(total);
        resultPage.setRecords(resultList);

        return resultPage;
    }

    /**
     * 查询数据列表，不分页，慎用
     *
     * @param indexList    索引列表
     * @param queryBuilder 查询条件
     * @param <T>          泛型
     * @return 数据列表
     * @throws Exception 异常
     */
    public <T> List<T> getList(List<String> indexList, QueryBuilder queryBuilder) throws Exception {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(queryBuilder);
        // SearchRequest
        SearchRequest searchRequest = null == indexList ? new SearchRequest() : new SearchRequest(indexList.toArray(new String[indexList.size()]));
        searchRequest.source(searchSourceBuilder);
        // 查询ES
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits hits = searchResponse.getHits();
        // 遍历封装列表对象
        List<T> resultList = new ArrayList<>();
        SearchHit[] searchHits = hits.getHits();

        for (SearchHit searchHit : searchHits) {
            resultList.add(JSON.parseObject(searchHit.getSourceAsString(), (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]));
        }

        return resultList;
    }

    /**
     * 根据ID查询
     *
     * @param index 索引
     * @param id    id
     * @return 返回数据
     */
    public <T> T getById(String index, String id) throws Exception {
        // GetRequest
        GetRequest getRequest = null == index ? new GetRequest() : new GetRequest(index, id);
        // 查询ES
        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        T result = JSON.parseObject(getResponse.getSourceAsString(), (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
        return result;
    }

    /**
     * 保存文档
     *
     * @param index 索引
     * @param entry 数据类
     * @param <T>   泛型
     * @return 是否成功
     * @throws Exception 异常
     */
    public <T> int save(String index, T entry) throws Exception {
        if (null == index) {
            throw new Exception("The index is null!");
        }
        // IndexRequest
        IndexRequest indexRequest = new IndexRequest(index);
        String id = getId(entry);

        String source = JSON.toJSONString(entry);
        indexRequest.id(id).source(source, XContentType.JSON);
        // 操作ES
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        return indexResponse.status().getStatus();
    }


    /**
     * 保存文档
     *
     * @param index     索引
     * @param entryList 数据列表
     * @param <T>       泛型
     * @return 是否成功
     * @throws Exception 异常
     */
    public <T> int saveBatch(String index, List<T> entryList) throws Exception {
        if (null == index) {
            throw new Exception("The index is null!");
        }

        BulkRequest request = new BulkRequest();
        String id;

        for (T entry : entryList) {
            id = getId(entry);
            request.add(new IndexRequest(index).id(id).source(JSON.toJSONString(entry), XContentType.JSON));
        }

        //设置刷新策略
        request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);
        // 操作ES批量插入，此为同步写入，如果存在性能问题，可考虑自行封装异步批量插入
        BulkResponse bulkResponse = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
        return bulkResponse.status().getStatus();
    }

    /**
     * 修改数据
     *
     * @param index 索引
     * @param entry 数据类型
     * @param <T>   数据类型
     * @return 修改成功标识
     * @throws Exception 异常
     */
    public <T> int update(String index, T entry) throws Exception {
        if (null == index) {
            throw new Exception("The index is null!");
        }

        Field field = entry.getClass().getDeclaredField("id");

        if (null == field) {
            throw new Exception(" The class is not exist id!");
        }

        field.setAccessible(true);
        String id = field.get(entry).toString();

        UpdateRequest updateRequest = new UpdateRequest(index, id);
        updateRequest.doc(JSON.toJSONString(entry), XContentType.JSON);
        // 操作ES
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        return updateResponse.status().getStatus();
    }

    /**
     * 删除文档
     *
     * @param index 索引
     * @param id    id
     * @return 删除成功标识
     * @throws Exception 异常
     */
    public int deleteById(String index, String id) throws Exception {
        if (null == index) {
            throw new Exception("The index is null!");
        }

        // DeleteRequest
        DeleteRequest deleteRequest = new DeleteRequest(index, id);
        // 操作ES
        DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        return deleteResponse.status().getStatus();
    }

    /**
     * 根据添加批量删除
     *
     * @param indexList    索引列表
     * @param queryBuilder 查询条件
     * @return 删除条数
     * @throws Exception 异常
     */
    public long deleteByQuery(List<String> indexList, QueryBuilder queryBuilder) throws Exception {
        DeleteByQueryRequest deleteRequest = new DeleteByQueryRequest();

        if (CollectionUtils.isNotEmpty(indexList)) {
            deleteRequest.indices(indexList.toArray(new String[indexList.size()]));
        }

        deleteRequest.setQuery(queryBuilder);
        // 操作ES删除
        BulkByScrollResponse response = restHighLevelClient.deleteByQuery(deleteRequest, RequestOptions.DEFAULT);
        return response.getStatus().getDeleted();
    }

    /**
     * 获取ID
     *
     * @param entry 数据类
     * @param <T>   泛型
     * @return ID
     * @throws Exception 异常
     */
    private <T> String getId(T entry) {
        try {
            Field field = entry.getClass().getDeclaredField("id");
            if (null == field || null == field.get(entry)) {
                return IdWorker.getIdStr();
            } else {
                field.setAccessible(true);
                return field.get(entry).toString();
            }
        } catch (Exception e) {
            return IdWorker.getIdStr();
        }
    }
}

说明：实现的分页查询使用的是from+size查询，对于深度查询和获取大量结果查询会有比较严重的问题。深度查询请使用search after查询，大量结果获取请使用scroll查询，用到可以自行封装。

guaotianxia
关注
【SpringBoot系列】 Spring Boot 中事半功倍的一些工具类
我是香菜
02-06 4167
Spring Boot 中事半功倍的一些工具类
spring boot 2.x 整合es 7.x 代码 + esUtil工具类.zip
11-30
spring boot 2.1.4.RELEASE 整合 elasticsearch 7.3.0 rest-high-level-client 方式 esUti 查询工具类 包含 查询 （单/多字段匹配查询、根据id/索引查询、多字段匹配一个值,模糊查询、范围查询、判断文档是否存在） 修改（部分更新 、新增或者更新 批量插入） 删除 （根据Id删除数据、批量删除） 方法 下载可运行 工具类方法测试已通过
Elasticsearch学习，请先看这一篇！
热门推荐
铭毅天下Elasticsearch
08-18 23万+
题记：Elasticsearch研究有一段时间了，现特将Elasticsearch相关核心知识、原理从初学者认知、学习的角度，从以下9个方面进行详细梳理。欢迎讨论……0. 带着问题上路——ES是如何产生的？（1）思考：大规模数据如何检索？如：当系统数据量上了10亿、100亿条的时候，我们在做系统架构的时候通常会从以下角度去考虑问题： 1）用什么数据库好？(mysql、sybase、oracle、达
ElasticSearch在SpringBoot中的操作
最新发布
m0_63948786的博客
09-14 852
在之前学习ES的api时,总觉得很繁琐,并且极不熟悉,所以重新学习,并且封装工具类,用于处理通用的响应结果,最终以达到巩固的目的目录前言ES http操作Gitee地址常用操作索引操作文档操作常用查询操作常见参数设置常见组合类型工具类封装分页参数请求实体ES聚合请求实体ES通用响应实体ES结构解析工具类API操作文档操作批量删除批量保存批量更新修改常用查询操作bool多条件组合match内容匹配match_all匹配全部multi_match多字段匹配range范围匹配function_score得分控制。
elsearch
weixin_30363981的博客
09-12 317
1.ElasticSearch是性能优化的分布式全文搜索引擎，存储数据的载体是文档（Document），它的优势在于搜索速度快和支持聚合操作，在更新文档时，基本上能够达到实时搜索。ElasticSearch引擎总是按照文档标识来更新数据，并发控制是通过顺序的版本ID（version）实现的，控制写-写、写-读冲突，实现数据弱一致性。 2.在编入索引时，索引操作支持参数op_type，用于指定...
springboot整合ElasticSearch（工具类、测试调用）
知道的越多 不知道的就越多
03-29 7410
1、引入依赖 <properties> <java.version>1.8</java.version> <log4j2.version>2.17.0</log4j2.version> <axis1.version>1.4</axis1.version> <elasticsearch.version>7.3.2</elasticsearch.v
Springboot连接 集成 操作ElasticSearch（自定义工具类快捷操作）
qq_43077369的博客
04-28 618
1.项目pom.xml文件引入依赖 pom.xml <!--本人使用的springboot是2.4.1--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.1</version> <r
springboot项目实现商品订单项目
07-03
在本项目中，"springboot项目实现商品订单项目" 是一个专门为初学者设计的实践教程，旨在帮助他们理解和掌握SpringBoot框架在构建电子商务系统中的应用。这个项目涉及到多个关键的技术和概念，包括Java编程、...
springboot空白项目自用
07-08
9. **测试**：SpringBoot提供了`spring-boot-starter-test`模块，包含了JUnit、Mockito、Spring Test等测试工具，方便进行单元测试和集成测试。 在"ctj"这个压缩包中，可能包含了上述提到的一些基本项目结构和配置...
SpringBoot项目基于springboot医疗报销系统的设计与实现.zip
04-14
采用前后端分离架构，前端可能使用Angular、React或Vue.js等现代JavaScript框架构建用户友好的界面，而后端则通过SpringBoot实现业务逻辑处理、安全认证、数据校验等功能。系统可能还整合了如Spring Security等框架...
SpringBoot项目视频网站系统的设计与实现.zip
04-14
技术实现上，后端使用SpringBoot简化配置和部署流程，SpringMVC处理Web请求和响应，MyBatis或Hibernate作为ORM工具与MySQL或其他数据库交互。前端可能采用Angular、React或Vue.js等现代JavaScript框架构建动态用户...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
03-03
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、高亮显示、逻辑查询、过滤查询、分组查询等等。并且已经过生产环境验证，各位可放心使用。如有不对之处欢迎在博客中留言交流。谢谢！ 欢迎各位大神添加微信公众号：“愿为最亮星”，我们将在这一起探讨Java技术。
ElasticSearch第七篇:SpringBoot集成ES
weixin_38109191的博客
02-23 688
第一步：pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <gro.
SpringBoot结合elasticsearch
Tony 小哥的博客
12-10 171
SpringBoot 结合Ela
【二十】springboot整合ElasticSearch实战（万字篇）
weixin_56995925的博客
04-01 1万+
学习springboot整合ElasticSearch7.X版本，实现小案例，springboot整合ElasticSearch实战（万字篇）
Elastic Search搜索引擎如何在在SpringBoot中实践
LeZiJie的博客
11-24 503
实验环境 ES版本：5.3.0 spring bt版本：1.5.9 首先当然需要安装好elastic search环境，最好再安装上可视化插件 elasticsearch-head来便于我们直观地查看数据。 Spring工程创建 这部分没有特殊要交代的，但有几个注意点一定要当心 注意在新建项目时记得勾选web和NoSQL中的Elasticsearch依赖，来张图说明一下吧： 项目自动生成以后pom.xml中会自动添加spring-boot-starter-data-elasticsearch的依
springboot整合es
蒯厅博客
05-12 728
引入相关依赖 <properties> <java.version>1.8</java.version> <elasticsearch.version>7.6.1</elasticsearch.version> </properties> <dependencies> <!-- 解析网页--> <dependency
springBoot整合ES搜索引擎，以及ES工具类，ES安装包，ES安装教程
sinat_43097407的博客
08-21 553
springBoot整合ES搜索引擎，ES工具类，java整合ES搜索引擎，ES安装包，ES安装教程
springboot整合ES 综合案例--京东搜索
qq_55682798的博客
08-16 673
1.1创建一个Springboot工程并加入相关的依赖。1.2 创建一个配置，获取ES工具类对象。2.3 索引操作--判断索引是否存在。2.1 操作索引---创建索引。2.4 操作文档---添加文档。2.6 判断索引文档是否存在。2.2操作索引--删除索引。2.5 查询文档--id。2.9 批量添加文档。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值