SpringBoot集成elasticsearch

最新推荐文章于 2025-03-30 08:55:47 发布
最新推荐文章于 2025-03-30 08:55:47 发布
阅读量307 收藏
点赞数
分类专栏： ElasticSearch 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/miaochenfly/article/details/116753243
版权

SpringBoot集成elasticsearch

1. 引入jar包

//elastic search
compile('org.elasticsearch:elasticsearch:7.10.1')
compile('org.elasticsearch.client:elasticsearch-rest-client:7.10.1')
compile('org.elasticsearch.client:elasticsearch-rest-high-level-client:7.10.1')

2. 配置项

elasticsearch.schema=http
elasticsearch.address=  127.0.0.1:9200
elasticsearch.userName= ""
elasticsearch.password= ""
elasticsearch.connectTimeout= 10000
elasticsearch.socketTimeout= 10000
elasticsearch.connectionRequestTimeout= 10000
elasticsearch.maxConnectNum= 100
elasticsearch.maxConnectPerRoute= 100
management.health.elasticsearch.enabled=false

3. esConfig

@Configuration
public class EsConfig {
    /**
     * 协议
     */
    @Value("${elasticsearch.schema:http}")
    private String schema;

    /**
     * 集群地址，如果有多个用“,”隔开
     */
    @Value("${elasticsearch.address}")
    private String address;

    @Value("${elasticsearch.userName}")
    private String userName;

    @Value("${elasticsearch.password}")
    private String password;
    /**
     * 连接超时时间
     */
    @Value("${elasticsearch.connectTimeout:5000}")
    private int connectTimeout;

    /**
     * Socket 连接超时时间
     */
    @Value("${elasticsearch.socketTimeout:10000}")
    private int socketTimeout;

    /**
     * 获取连接的超时时间
     */
    @Value("${elasticsearch.connectionRequestTimeout:5000}")
    private int connectionRequestTimeout;

    /**
     * 最大连接数
     */
    @Value("${elasticsearch.maxConnectNum:100}")
    private int maxConnectNum;

    /**
     * 最大路由连接数
     */
    @Value("${elasticsearch.maxConnectPerRoute:100}")
    private int maxConnectPerRoute;

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        // 拆分地址
        List<HttpHost> hostLists = new ArrayList<>();
        String[] hostList = address.split(",");
        for (String addr : hostList) {
            String host = addr.split(":")[0];
            String port = addr.split(":")[1];
            hostLists.add(new HttpHost(host, Integer.parseInt(port), schema));
        }
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));
        // 转换成 HttpHost 数组
        HttpHost[] httpHost = hostLists.toArray(new HttpHost[]{});
        // 构建连接对象
        RestClientBuilder builder = RestClient.builder(httpHost);
        // 异步连接延时配置
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectTimeout(connectTimeout);
            requestConfigBuilder.setSocketTimeout(socketTimeout);
            requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
            return requestConfigBuilder;
        });
        // 异步连接数配置
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(maxConnectNum);
            httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
            httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            return httpClientBuilder;
        });
        return new RestHighLevelClient(builder);

    }
}

4. elasticTools

//elasticsearchEntity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ElasticSearchEntity {
    /**
     * 主键标识，用户ES持久化
     */
    private String id;

    /**
     * JSON对象，实际存储数据
     */
    private Map data;
}

@Slf4j
@Component
public class ElasticSearch {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * @param idxName 索引名称
     * @param idxSQL  索引描述
     * @return void
     * @throws
     * @See
     * @date 2019/10/17 17:30
     * @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();
        }
    }

    /**
     * @param idxName 索引名称
     * @param builder 索引描述
     * @return void
     * @throws
     * @See
     * @date 2019/10/17 17:30
     * @since
     */
    public void createIndex2(String idxName, XContentBuilder builder) {
        try {
            if (!this.indexExist(idxName)) {
                //log.error(" idxName={} 已经存在,idxSql={}", idxName, builder);
                return;
            }
            CreateIndexRequest request = new CreateIndexRequest(idxName);
            GetIndexRequest getIndexRequest = new GetIndexRequest(idxName);
            buildSetting(request);
            request.mapping(builder);
//            request.settings() 手工指定Setting
            boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
            if (!exists) {
                CreateIndexResponse res = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
                if (!res.isAcknowledged()) {
                    log.info("初始化失败");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 断某个index是否存在
     *
     * @param idxName index名
     * @return boolean
     * @throws
     * @See
     * @date 2019/10/17 17:27
     * @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是否存在
     *
     * @param idxName index名
     * @return boolean
     * @throws
     * @See
     * @date 2019/10/17 17:27
     * @since
     */
    public boolean isExistsIndex(String idxName) throws Exception {
        return restHighLevelClient.indices().exists(new GetIndexRequest(idxName), RequestOptions.DEFAULT);
    }

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

    /**
     * @param idxName index
     * @param entity  对象
     * @return void
     * @throws
     * @See
     * @date 2019/10/17 17:27
     * @since
     */
    public void insertOrUpdateOne(String idxName, ElasticSearchEntity entity) {
        IndexRequest request = new IndexRequest(idxName, "_doc");
        log.info("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);
        }
    }


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

    /**
     * 异步批量插入，并执行回调方法
     *
     * @param idxName
     * @param list
     * @param consumer
     */
    public void insertBatchAsync(String idxName, List<ElasticSearchEntity> list, BiConsumer consumer, Object param) {
        BulkRequest request = new BulkRequest();
        list.parallelStream().forEach(item -> request.add(new IndexRequest(idxName, "_doc").id(item.getId())
                .source(item.getData(), XContentType.JSON)));
        try {
            if (!CollectionUtils.isEmpty(request.requests())) {
                restHighLevelClient.bulkAsync(request, RequestOptions.DEFAULT, getActionListener(consumer, list, param));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void insertBatchAsync(String idxName, List<JSONObject> list, Consumer<List<JSONObject>> consumer) {
        BulkRequest request = new BulkRequest();
        list.forEach(item -> request.add(new IndexRequest(idxName, "_doc").id(item.getString("msgid"))
                .source(item, XContentType.JSON)));
        try {
            if (!CollectionUtils.isEmpty(request.requests())) {
                restHighLevelClient.bulkAsync(request, RequestOptions.DEFAULT, getActionListener(consumer, list));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void updateBatch(String idxName, List<ElasticSearchEntity> list) {
        BulkRequest request = new BulkRequest();
        list.forEach(item -> request.add(new UpdateRequest(idxName, item.getId()).upsert(item.getData(), XContentType.JSON)));
        try {
            if (!CollectionUtils.isEmpty(request.requests())) {
                restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

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

    /**
     * @param idxName index
     * @param builder 查询参数
     * @param c       结果类对象
     * @return java.util.List<T>
     * @throws
     * @See
     * @date 2019/10/17 17:14
     * @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);
            long totalHits = response.getHits().getTotalHits().value;
            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);
        }
    }

    public <T> PageInfo<T> searchPage(String idxName, SearchSourceBuilder builder, int pageNum, int pageSize, Class<T> c) {
        SearchRequest request = new SearchRequest(idxName);
        request.source(builder);
        try {
            SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            int totalHits = (int) response.getHits().getTotalHits().value;
            SearchHit[] hits = response.getHits().getHits();
            List<T> res = new ArrayList<>(hits.length);
            for (SearchHit hit : hits) {
                //解析高亮字段
                //获取当前命中的对象的高亮的字段
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                HighlightField hghlightContent = highlightFields.get("text.content");
                String newName = "";
                if (hghlightContent != null) {
                    //获取该高亮字段的高亮信息
                    Text[] fragments = hghlightContent.getFragments();
                    //将前缀、关键词、后缀进行拼接
                    for (Text fragment : fragments) {
                        newName += fragment;
                    }
                }
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                sourceAsMap.put("content", newName);
                res.add(JSON.parseObject(JSONObject.toJSONString(sourceAsMap), c));
            }
            // 封装分页
            PageInfo<T> page = new PageInfo<>();
            page.setList(res);
            page.setPageNum(pageNum);
            page.setPageSize(pageSize);
            page.setTotal(totalHits);
            page.setPages(totalHits == 0 ? 0 : (totalHits % pageNum == 0 ? totalHits / pageNum : (totalHits / pageNum) + 1));
            page.setHasNextPage(page.getPageNum() < page.getPages());
            return page;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除index
     *
     * @param idxName
     * @return void
     * @throws
     * @See
     * @date 2019/10/17 17:13
     * @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);
        }
    }


    /**
     * @param idxName
     * @param builder
     * @return void
     * @throws
     * @See
     * @date 2019/10/17 17:13
     * @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);
        }
    }

    public ActionListener getActionListener(Consumer consumer, List<JSONObject> list) {
        return new ActionListener() {
            @Override
            public void onResponse(Object o) {
                consumer.accept(list);
            }

            @Override
            public void onFailure(Exception e) {
                log.warn("work with es failed, exception={}", ExceptionUtils.getStackTrace(e));
            }
        };
    }

    public ActionListener getActionListener(BiConsumer consumer, List<ElasticSearchEntity> list, Object param) {
        return new ActionListener() {
            @Override
            public void onResponse(Object o) {
                consumer.accept(list, param);
            }

            @Override
            public void onFailure(Exception e) {
                log.warn("work with es failed, exception={}", ExceptionUtils.getStackTrace(e));
            }
        };
    }

    public XContentBuilder getFinanceMapping() throws IOException {
        // 创建 会话文本Mapping
        XContentBuilder xContentBuilder = XContentFactory.jsonBuilder()
                .startObject()
                .startObject("properties")
                .startObject("msgid")
                .field("type", "keyword")
                .endObject()
                .startObject("seq")
                .field("type", "long")
                .endObject()
                .startObject("action")
                .field("type", "keyword")
                .endObject()
                .startObject("from")
                .field("type", "keyword")
                .endObject()
                .startObject("roomid")
                .field("type", "keyword")
                .endObject()
                .startObject("msgtime")
                .field("type", "long")
                .endObject()
                .startObject("msgtype")
                .field("type", "keyword")
                .endObject()
                .endObject()
                .endObject();
        return xContentBuilder;
    }
}

5. 注意点

elasticsearchentity中的map，可采用fastjson进行转换JSON.parseObject(JSON.toJSONString(xxx,Map.class));

参考：

https://gitee.com/LinkWeChat/link-wechat

springboot集成elasticsearch
m0_67391518的博客
08-02 397
Springboot集成elasticsearch有多种方式，如TransportClient、RestHighLevelClient等等；但是官方已经停止更新TransportClient并且在elasticsearch8.0之后已经弃用，所以本人使用的是RestHighLevelClient。
Spring Boot整合Elasticsearch
null
04-14 1909
引入成功后，这里注意检查引入的jar包版本号，尽量保证与elasticsearch版本号一致，否则可能会出现莫名奇怪的问题。如图所示，程序引入的是7.17.15，但是我们使用的elasticsearch版本是7.17.18，所以这里做下修改。重启elasticsearch、elasticsearch-head，刷新页面，连接成功。查看elasticsearch-head，文档创建成功，能够成功查询到。运行，成功查询文档信息，打印信息如下。运行，成功创建文档，打印信息如下。运行，成功打印查询的索引信息。
Springboot集成Elasticsearch
最新发布
2301_80163888的博客
03-30 320
注意依赖的兼容问题，Spring Boot 2.7.x 支持 Elasticsearch 7.x。Spring Boot 3.x 支持 Elasticsearch 8.x。Spring Data Elasticsearch 不会自动创建索引。三、创建一个与 Elasticsearch 索引对应的实体类，并使用注解定义映射关系。五、创建一个service服务层（我直接写实现类了）六、创建一个controller控制层。
【SpringBoot】SpringBoot集成ElasticSearch
DreamSun的博客
05-05 1962
它定义了用于创建、检查存在性、删除索引、添加、修改和删除文档，以及搜索文档的方法。需要注意的是，这段代码中的 RestHighLevelClient 实例是一个单例对象，只需要在应用程序启动时创建一次即可，因此这个类应该被配置为一个 Spring Bean，以便在需要时注入到其他类中使用。其中 RestHighLevelClient 是 Elasticsearch Java 客户端的高级别别名，是基于 LowLevelClient 之上的封装，提供了一些更加方便的方法和功能。
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
04-18
本实例属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、...
最新版本springboot集成elasticsearch
05-25
一般来说我们开发Elasticsearch会选择使用集成springboot，在网上找的springboot集成elasticsearch文章几乎都是extends ElasticsearchRepository的方式来实现。但是新版本ElasticsearchRepository里的方法基本上已经...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用
11-12
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、...
springboot 集成elasticsearch ,api的使用
08-02
在本文中，我们将深入探讨如何将Spring Boot与Elasticsearch集成，并使用其API进行数据操作。Elasticsearch是一个流行的开源搜索引擎，它提供了实时、分布式、容错能力的搜索和数据分析功能。Spring Boot则是一个...
springBoot集成elasticsearch
weixin_52380943的博客
06-29 200
1.ES安装网址官网 https://www.elastic.co/cn/downloads/elasticsearch 2.引入ES，maven依赖 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId>
springboot 集成elasticsearch
future-wy
12-18 368
百度云下载地址：链接：https://pan.baidu.com/s/11y5zGKJDsyb8f_ScLasPTQ 提取码：xut1 复制这段内容后打开百度网盘手机App，操作更方便哦 1、介绍 ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多用户能力的全文搜索 引擎，基于 RESTfulweb 接口。Elasticsearch 是用 Java 开发的，并作为 Apache 许可条款下的 开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时..
spring data elasticsearch的 @Documnet 和 @Field 注解
热门推荐
浮生若梦
07-19 4万+
@Documnet 注解 public @interface Document { String indexName();//索引库的名称，个人建议以项目的名称命名 String type() default “”;//类型，个人建议以实体的名称命名 short shards() default 5;//默认分区数 short replicas() default 1;//每个分区默认的...
Springboot中集成ElasticSearch
林老师带你学编程
07-25 3111
昨天给大家介绍了一下ElasticSearch代码结构设计，今天给大家介绍一下ElasticSearch怎么集成到Spring boot中，不知道大家记不记得以前我也写过它们的整合，但今天要说的模式和以前的不一样（具体区别大家可以对照的看看，这边就不详细介绍了）。 1.我们首先引入ElasticSearch的相关依赖，pom文件的依赖如下所示： &lt;!-- elasticsearch ...
SpringBoot整合Elasticsearch
Qynwang的博客
04-21 3255
查看maven中的依赖，如果发现elasticsearch版本不是自己想要的，比如说发现是 elasticsearch-这是spring-boot-starter-parent中SpringBoot设定的elasticsearch版本为。这里使用的Elasticsearch版本是7.4.2。2. 配置 application.yml 文件。解决办法是在项目的pom.xml文件中。3. 启动 SpringBoot 项目。重新启动SpringBoot即可成功。
SpringBoot集成Elasticsearch案例实战解析
- **项目依赖管理**：通常会使用Maven或Gradle来管理项目依赖，集成Elasticsearch时需要添加相应的Spring Data Elasticsearch依赖以及Elasticsearch客户端的依赖。 - **配置文件设置**：在Spring Boot项目中，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值