devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【ES一】SpringBoot2.x+ES8.11.1（windows环境）整合_springboot集成es8.11

作者：Monodyee | 2024-05-31 01:13:37

赞

踩

springboot集成es8.11

一、两种整合方式

目前有两种最常用的整合方式，一种是ElasticSearch官方提供的 Java High Level Rest Client，一种是Spring提供的 spring-boot-starter-data-elasticsearch 方式：

1.spring-boot-starter-data-elasticsearch 方式

  • 由 Spring 提供，是 Spring 在 ES 官方接口基础之上的二次封装，使用简单，易于上手；
  • 缺点是更新太慢，SpringBoot 2.2.x 才提供对 es7.x 的支持，版本关联性很大，不易维护；

2. Java High Level Rest Client 方式（推荐）（我使用的）

  • 由ES官方提供，代码语法和DSL语法相似（即Json格式的ES操作语法）；
  • 用法灵活，可以自由使用；
  • SpringBoot 和 ES 版本的关联性较小；

二、开始搭建

项目基础

1.SpringBoot3.x JDK17 Es8.11.1 ik分词 8.11.1（启动报错暂时放弃……）

2.SpringBoot2.x JDK17 Es8.11.1 ik分词 8.11.1（es_work)

windows环境

地址：C:\java\elasticsearch8111

JDK ：ES_JAVA_HOME (JDK17.0.3)

前提了解

es与jdk版本对应：支持一览表 | Elastic

es与Spring Data Elasticsearch 之间版本对应：Spring Data Elasticsearch - Reference Documentation

步骤

1.安装ES

链接：win10+elasticsearch8.12 安装教程_win10 elasticsearch8.12-CSDN博客

下载地址：Elasticsearch 8.11.1 | Elastic

本地地址：C:\java\elasticsearch8111\elasticsearch-8.11.1

注意：环境变量JDK配置正常是JAVA_HOME,es配置里是ES_JAVA_HOME，启动时会报错，所以在环境变量里添加上ES_JAVA_HOM，如果你有其他方法也可以。

默认地址：localhost:9200

账号密码：账号：elastic 密码：自动生成(Sx6+sb3Ags45pNyrfws=)，也可自定义。（忘记密码怎么办？进入es安装目录的bin文件中执行一下命令会返回最新的密码 命令 : elasticsearch-reset-password -u elastic）

2.安装ik分词

链接：本地elasticsearch中文分词器 ik分词器安装及使用_es安装ik分词器-CSDN博客

本地地址：C:\java\elasticsearch8111\elasticsearch-8.11.1\plugins\ik

IK分词器有两种分词模式：ik_max_word（最细粒度拆分）和ik_smart（最粗粒度）模式。

自定义分词bic文件：C:\java\elasticsearch8111\elasticsearch-8.11.1\plugins\ik\config

3.安装客户端Kibana

需要和es版本保持一致

默认地址：http://localhost:5601/   初次访问一般后边还有code拼接

账号密码：es的账号密码

本地地址：C:\java\elasticsearch8111\kibana-8.11.1-windows-x86_64\kibana-8.11.1

学习链接：ElasticSearch——Kibana Windows下的安装和Dev Tools的使用_elastic dev tools-CSDN博客

使用教程：ES8.8生产实践——数据查询与数据可视化(Kibana)_es可视化-CSDN博客

4.JAVA代码

pom.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <groupId>com.es</groupId>
  8.     <artifactId>es-work</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.     <name>es-work</name>
  11.  
  12.     <packaging>jar</packaging>
  13.     <parent>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-parent</artifactId>
  16.         <version>2.4.4</version>
  17.     </parent>
  18.  
  19.     <properties>
  20.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  21.         <junit.version>5.9.1</junit.version>
  22.     </properties>
  23.  
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-web</artifactId>
  28.         </dependency>
  29.  
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-test</artifactId>
  33.             <scope>test</scope>
  34.         </dependency>
  35.  
  36.         <dependency>
  37.             <groupId>org.projectlombok</groupId>
  38.             <artifactId>lombok</artifactId>
  39.             <version>1.18.20</version>
  40.         </dependency>
  41.         <!-- @ConfigurationProperties(prefix = "elasticsearch") 注解依赖      -->
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-configuration-processor</artifactId>
  45.             <optional>true</optional>
  46.         </dependency>
  47.         <!-- 若不存在Spring Data ES的某个版本支持你下的ES版本,则使用  -->
  48.         <!-- ES 官方提供的在JAVA环境使用的依赖 -->
  49.         <dependency>
  50.             <groupId>co.elastic.clients</groupId>
  51.             <artifactId>elasticsearch-java</artifactId>
  52.             <version>8.11.1</version>
  53.         </dependency>
  54.        <!-- 和第一个依赖是一起的,为了解决springboot项目的兼容性问题  -->
  55.         <dependency>
  56.             <groupId>com.fasterxml.jackson.core</groupId>
  57.             <artifactId>jackson-databind</artifactId>
  58.         </dependency>
  59.         <!-- 原来只有前两依赖，但是启动报错找不到依赖，要注意版本号是否兼容  -->
  60.         <dependency>
  61.             <groupId>jakarta.json</groupId>
  62.             <artifactId>jakarta.json-api</artifactId>
  63.             <version>2.0.1</version>
  64.         </dependency>
  65.         <!-- es的客户端，连接，版本号要与ES一致  -->
  66.         <dependency>
  67.             <groupId>org.elasticsearch.client</groupId>
  68.             <artifactId>elasticsearch-rest-client</artifactId>
  69.             <version>8.11.1</version>
  70.         </dependency>
  71.         <!-- lombok -->
  72.         <dependency>
  73.             <groupId>org.projectlombok</groupId>
  74.             <artifactId>lombok</artifactId>
  75.         </dependency>
  76.     </dependencies>
  77.  
  78. </project>
application.yml
  1. server:
  2.   port: 8092
  3.  
  4. spring:
  5. # elasticsearch配置
  6. elasticsearch:
  7.   # 自定义属性---设置是否开启ES,false表不开窍ES
  8.   open: true
  9.   # es集群名称,如果下载es设置了集群名称,则使用配置的集群名称
  10.   clusterName: es
  11.   hosts: 127.0.0.1:9200
  12.   # es 请求方式
  13.   scheme: http
  14.   # es 连接超时时间
  15.   connectTimeOut: 1000
  16.   # es socket 连接超时时间
  17.   socketTimeOut: 30000
  18.   # es 请求超时时间
  19.   connectionRequestTimeOut: 500
  20.   # es 最大连接数
  21.   maxConnectNum: 100
  22.   # es 每个路由的最大连接数
  23.   maxConnectNumPerRoute: 100
  24.   userName: elastic
  25.   password: Sx6+sb3Ags45pNyrfws=
config
  1. package com.es.eswork.config;
  2.  
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.json.jackson.JacksonJsonpMapper;
  5. import co.elastic.clients.transport.ElasticsearchTransport;
  6. import co.elastic.clients.transport.rest_client.RestClientTransport;
  7. import lombok.Data;
  8. import org.apache.http.HttpHost;
  9. import org.apache.http.auth.AuthScope;
  10. import org.apache.http.auth.UsernamePasswordCredentials;
  11. import org.elasticsearch.client.RestClient;
  12. import org.elasticsearch.client.RestClientBuilder;
  13. import org.springframework.boot.context.properties.ConfigurationProperties;
  14. import org.springframework.context.annotation.Bean;
  15. import org.springframework.context.annotation.Configuration;
  16.  
  17. import org.apache.http.client.CredentialsProvider;
  18. import org.apache.http.impl.client.BasicCredentialsProvider;
  19. @Data
  20. @Configuration
  21. @ConfigurationProperties(prefix = "elasticsearch")
  22. public class ElasticSearchConfig {
  23.  
  24.     // 是否开启ES
  25.     private Boolean open;
  26.  
  27.     // es 集群host ip 地址
  28.     private String hosts;
  29.  
  30.     // es用户名
  31.     private String userName;
  32.  
  33.     // es密码
  34.     private String password;
  35.  
  36.     // es 请求方式
  37.     private String scheme;
  38.  
  39.     // es集群名称
  40.     private String clusterName;
  41.  
  42.     // es 连接超时时间
  43.     private int connectTimeOut;
  44.  
  45.     // es socket 连接超时时间
  46.     private int socketTimeOut;
  47.  
  48.     // es 请求超时时间
  49.     private int connectionRequestTimeOut;
  50.  
  51.     // es 最大连接数
  52.     private int maxConnectNum;
  53.  
  54.     // es 每个路由的最大连接数
  55.     private int maxConnectNumPerRoute;
  56.  
  57.     // es api key
  58.     private String apiKey;
  59.  
  60.  
  61.     public RestClientBuilder creatBaseConfBuilder(String scheme){
  62.  
  63.  
  64.         // 1. 单节点ES Host获取
  65.         String host = hosts.split(":")[0];
  66.         String port = hosts.split(":")[1];
  67.  
  68.  
  69.         // The value of the schemes attribute used bynoSafeRestClient() is http
  70.         // but The value of the schemes attribute used by safeRestClient() is https
  71.         HttpHost httpHost = new HttpHost(host, Integer.parseInt(port),scheme);
  72.  
  73.         // 1.1 设置用户名和密码(账号密码连接，xpack.security.enabled: true)
  74.         final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
  75.         credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));
  76.  
  77.  
  78.         // 2. 创建构建器对象
  79.         //RestClientBuilder: ES客户端库的构建器接口,用于构建RestClient实例;允许你配置与Elasticsearch集群的连接,设置请求超时,设置身份验证,配置代理等
  80.         RestClientBuilder builder = RestClient.builder(httpHost);
  81.  
  82.  
  83.  
  84.         // 连接延时配置
  85.         builder.setRequestConfigCallback(requestConfigBuilder -> {
  86.             requestConfigBuilder.setConnectTimeout(connectTimeOut);
  87.             requestConfigBuilder.setSocketTimeout(socketTimeOut);
  88.             requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
  89.             return requestConfigBuilder;
  90.         });
  91.  
  92.         // 3. HttpClient 连接数配置
  93.         builder.setHttpClientConfigCallback(httpClientBuilder -> {
  94.             httpClientBuilder.setMaxConnTotal(maxConnectNum);
  95.             httpClientBuilder.setMaxConnPerRoute(maxConnectNumPerRoute);
  96.             httpClientBuilder.disableAuthCaching();  // 1.1.1 设置账号密码
  97.             httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
  98.             return httpClientBuilder;
  99.         });
  100.  
  101.  
  102.  
  103.         return builder;
  104.     }
  105.  
  106.     /**
  107.      * @function: 创建使用http连接来直接连接ES服务器的客户端
  108.      * 如果@Bean没有指定bean的名称,那么这个bean的名称就是方法名
  109.      */
  110.     @Bean
  111.     public ElasticsearchClient elasticsearchClient(){
  112.         RestClientBuilder builder = creatBaseConfBuilder((scheme == "http")?"http":"http");
  113.         //Create the transport with a Jackson mapper
  114.         ElasticsearchTransport transport = new RestClientTransport(builder.build(), new JacksonJsonpMapper());
  115.         //And create the API client
  116.         ElasticsearchClient esClient = new ElasticsearchClient(transport);
  117.         return esClient;
  118.     }
  119. }
test测试
  1. package com.es.eswork;
  2.  
  3. import com.es.eswork.entity.User;
  4. import com.es.eswork.utils.ElasticsearchHandle;
  5. import lombok.extern.slf4j.Slf4j;
  6. import net.minidev.json.JSONArray;
  7. import org.junit.jupiter.api.Test;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.boot.test.context.SpringBootTest;
  10.  
  11. import java.util.ArrayList;
  12. import java.util.List;
  13.  
  14. @SpringBootTest
  15. @Slf4j
  16. public class EsTestByUtil {
  17.  
  18.  
  19.     @Autowired
  20.     ElasticsearchHandle client;
  21.  
  22.    
  23.     @Test
  24.     public void test() {
  25.         //测试logstash
  26.         log.info("log");
  27.         String indexName = "test_index";
  28.         try {
  29.             boolean b = client.hasIndex(indexName);
  30.             System.out.println(b);
  31.         } catch (IOException e) {
  32.             throw new RuntimeException(e);
  33.         }
  34.     }
  35.  
  36.     @Test
  37.     public void search() {
  38.         List<User> search = client.search("test_index", "hello", 5, "name");
  39.  
  40.         System.out.println(JSONArray.toJSONString(search));
  41.     }
  42.  
  43.     @Test
  44.     public void searchCategoryIds() {
  45.         List<String> ca = new ArrayList<>();
  46.         ca.add("hello");
  47.         List<User> search = client.searchCategoryIds("test_index", "hello", ca, 5);
  48.         System.out.println(JSONArray.toJSONString(search));
  49.     }
  50.  
  51. }
utils
  1. package com.es.eswork.utils;
  2.  
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.elasticsearch._types.FieldValue;
  5. import co.elastic.clients.elasticsearch._types.mapping.Property;
  6. import co.elastic.clients.elasticsearch._types.query_dsl.Query;
  7. import co.elastic.clients.elasticsearch._types.query_dsl.TermsQuery;
  8. import co.elastic.clients.elasticsearch._types.query_dsl.TermsQueryField;
  9. import co.elastic.clients.elasticsearch.core.DeleteResponse;
  10. import co.elastic.clients.elasticsearch.core.GetResponse;
  11. import co.elastic.clients.elasticsearch.core.IndexResponse;
  12. import co.elastic.clients.elasticsearch.core.SearchResponse;
  13. import co.elastic.clients.elasticsearch.core.search.Hit;
  14. import co.elastic.clients.elasticsearch.indices.CreateIndexResponse;
  15. import co.elastic.clients.elasticsearch.indices.DeleteIndexResponse;
  16. import co.elastic.clients.transport.endpoints.BooleanResponse;
  17. import com.es.eswork.entity.User;
  18. import lombok.extern.slf4j.Slf4j;
  19. import org.apache.commons.lang3.StringUtils;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.stereotype.Component;
  22.  
  23. import java.io.IOException;
  24. import java.util.ArrayList;
  25. import java.util.List;
  26. import java.util.Map;
  27.  
  28. @Slf4j
  29. @Component
  30. public class ElasticsearchHandle {
  31.  
  32.     @Autowired
  33.     private ElasticsearchClient client;
  34.  
  35.     /**
  36.      * 判断索引是否存在
  37.      *
  38.      * @param indexName
  39.      * @return
  40.      * @throws IOException
  41.      */
  42.     public boolean hasIndex(String indexName) throws IOException {
  43.         BooleanResponse exists = client.indices().exists(d -> d.index(indexName));
  44.         return exists.value();
  45.     }
  46.  
  47.     /**
  48.      * 删除索引
  49.      *
  50.      * @param indexName
  51.      * @throws IOException
  52.      */
  53.     public boolean deleteIndex(String indexName) throws IOException {
  54.         DeleteIndexResponse response = client.indices().delete(d -> d.index(indexName));
  55.         return true;
  56.     }
  57.  
  58.     /**
  59.      * 创建索引
  60.      *
  61.      * @param indexName
  62.      * @return
  63.      * @throws IOException
  64.      */
  65.     public boolean createIndex(String indexName) {
  66.         try {
  67.             CreateIndexResponse indexResponse = client.indices().create(c -> c.index(indexName));
  68.         } catch (IOException e) {
  69.             log.error("索引创建失败：{}", e.getMessage());
  70.             // throw new ExploException(HttpCode.INDEX_CREATE_ERROR, "创建索引失败");
  71.         }
  72.         return true;
  73.     }
  74.  
  75.     /**
  76.      * 创建索引，不允许外部直接调用
  77.      *
  78.      * @param indexName
  79.      * @param mapping
  80.      * @throws IOException
  81.      */
  82.     private boolean createIndex(String indexName, Map<String, Property> mapping) throws IOException {
  83.         CreateIndexResponse createIndexResponse = client.indices().create(c -> {
  84.             c.index(indexName).mappings(mappings -> mappings.properties(mapping));
  85.             return c;
  86.         });
  87.         return createIndexResponse.acknowledged();
  88.     }
  89.  
  90.  
  91.     /**
  92.      * 重新创建索引,如果已存在先删除
  93.      *
  94.      * @param indexName
  95.      * @param mapping
  96.      */
  97.     public void reCreateIndex(String indexName, Map<String, Property> mapping) {
  98.         try {
  99.             if (this.hasIndex(indexName)) {
  100.                 this.deleteIndex(indexName);
  101.             }
  102.         } catch (IOException e) {
  103.             e.printStackTrace();
  104.             log.error("删除索引失败：{}", e.getMessage());
  105.  
  106.             // throw new ExploException(HttpCode.INDEX_DELETE_ERROR, "删除索引失败");
  107.         }
  108.  
  109.         try {
  110.             this.createIndex(indexName, mapping);
  111.         } catch (IOException e) {
  112.             e.printStackTrace();
  113.             log.error("重新创建索引失败：{}", e.getMessage());
  114.  
  115.             //throw new ExploException(HttpCode.INDEX_CREATE_ERROR, "重新创建索引失败");
  116.         }
  117.     }
  118.  
  119.  
  120.     /**
  121.      * 新增数据
  122.      *
  123.      * @param indexName
  124.      * @throws IOException
  125.      */
  126.     public boolean insertDocument(String indexName, Object obj, String id) {
  127.         try {
  128.             IndexResponse indexResponse = client.index(i -> i
  129.                     .index(indexName)
  130.                     .id(id)
  131.                     .document(obj));
  132.             return true;
  133.         } catch (IOException e) {
  134.             log.error("数据插入ES异常：{}", e.getMessage());
  135.             // throw new ExploException(HttpCode.ES_INSERT_ERROR, "ES新增数据失败");
  136.         }
  137.         return false;
  138.     }
  139.  
  140.     /**
  141.      * 查询数据
  142.      *
  143.      * @param indexName
  144.      * @param id
  145.      * @return
  146.      */
  147.     public GetResponse<User> searchDocument(String indexName, String id) {
  148.  
  149.         try {
  150.             GetResponse<User> getResponse = client.get(g -> g
  151.                             .index(indexName)
  152.                             .id(id)
  153.                     , User.class
  154.             );
  155.             return getResponse;
  156.         } catch (IOException e) {
  157.             log.error("查询ES异常：{}", e.getMessage());
  158.             // throw new ExploException(HttpCode.ES_SEARCH_ERROR, "查询ES数据失败");
  159.         }
  160.         return null;
  161.     }
  162.  
  163.     /**
  164.      * 删除数据
  165.      *
  166.      * @param indexName
  167.      * @param id
  168.      * @return
  169.      */
  170.     public boolean deleteDocument(String indexName, String id) {
  171.         try {
  172.             DeleteResponse deleteResponse = client.delete(d -> d
  173.                     .index(indexName)
  174.                     .id(id)
  175.             );
  176.         } catch (IOException e) {
  177.             log.error("删除Es数据异常：{}", e.getMessage());
  178.             //throw new ExploException(HttpCode.ES_DELETE_ERROR, "数据删除失败");
  179.         }
  180.         return true;
  181.     }
  182.  
  183.  
  184.  
  185.  
  186.     /**
  187.      *
  188.      * 查询满足条件的数据  --User表
  189.      * @param indexName 为索引名称
  190.      * @param query 查询的内容
  191.      * @param top 查询条数
  192.      * @param field 参数
  193.      * @return
  194.      */
  195.     public List<User> search(String indexName, String query, int top,String field) {
  196.         List<User> documentParagraphs = new ArrayList<>();
  197.         try {
  198.             SearchResponse<User> search = client.search(s -> s
  199.                             .index(indexName)
  200.                             .query(q -> q
  201.                                     .match(t -> t
  202.                                             .field(field)
  203.                                             .query(query)
  204.                                     ))
  205.                             .from(0)
  206.                             .size(top)
  207.                             .highlight(h -> h
  208.                                     .fields("name", f -> f
  209.                                             .preTags("<em>")
  210.                                             .postTags("</em>")
  211.                                     )
  212.                             )
  213. //                    .sort(f -> f.field(o -> o.field("docId").order(SortOrder.Desc)))
  214.                     , User.class
  215.             );
  216.             for (Hit<User> hit : search.hits().hits()) {
  217.                 //User user = hit.source();
  218.                 User user = highLight(hit);
  219.                 documentParagraphs.add(user);
  220.  
  221.             }
  222.         } catch (IOException e) {
  223.             log.error("查询ES异常：{}", e.getMessage());
  224.             // throw new ExploException(HttpCode.ES_SEARCH_ERROR, "查询ES数据失败");
  225.         }
  226.         return documentParagraphs;
  227.     }
  228.     /**
  229.      * 高亮数据提取
  230.      */
  231.     private User highLight(Hit<User> hit) {
  232.         User paragraph = hit.source();
  233.         try {
  234.             Map<String, List<String>> highlight = hit.highlight();
  235.             List<String> list = highlight.get("name");
  236.             String join = StringUtils.join(list, "");
  237.             if (StringUtils.isNotBlank(join)) {
  238.                 paragraph.setName(join);
  239.                // paragraph.setAge(hit.score());
  240.  
  241.             }
  242.         } catch (Exception e) {
  243.             log.error("获取ES高亮数据异常：{}", e.getMessage());
  244.         }
  245.         return paragraph;
  246.     }
  247.  
  248.  
  249.  
  250. //    /**
  251. //     *解析高亮数据
  252. //     */
  253. //    Map<String, List<String>> highlight = hit.highlight();
  254. //    List<String> list = highlight.get("name");
  255. //    String join = StringUtils.join(list, "");
  256. //            if (StringUtils.isNotBlank(join)) {
  257. //        paragraph.setContent(join);
  258. //    }
  259.  
  260.  
  261.  
  262.     public List<User> searchCategoryIds(String indexName, String query, List<String> categoryId,int top) {
  263.         List<User> documentParagraphs = new ArrayList<>();
  264.         List<FieldValue> values = new ArrayList<>();
  265.         for (String id : categoryId) {
  266.             values.add(FieldValue.of(id));
  267.         }
  268.         Query categoryQuery = TermsQuery.of(t -> t.field("name.keyword").terms(new TermsQueryField.Builder()
  269.                 .value(values).build()
  270.         ))._toQuery();
  271.  
  272.         try {
  273.             SearchResponse<User> search = client.search(s -> s
  274.                             .index(indexName)
  275.                             .query(q -> q
  276.                                     .bool(b -> b
  277.                                             .must(categoryQuery
  278.                                             )
  279.                                             .should(sh -> sh
  280.                                                     .match(t -> t
  281.                                                             .field("name")
  282.                                                             .query(query)
  283.                                                     )
  284.                                             )
  285.                                     )
  286.                             )
  287.                             .highlight(h -> h
  288.                                     .fields("name", f -> f
  289.                                             .preTags("<em>")
  290.                                             .postTags("</em>")
  291.                                     )
  292.                             )
  293.                             .from(0)
  294.                             .size(top)
  295.                     , User.class
  296.             );
  297.             for (Hit<User> hit : search.hits().hits()) {
  298.                 User pd = hit.source();
  299.                 documentParagraphs.add(pd);
  300.             }
  301.         } catch (IOException e) {
  302.             log.error("查询ES异常：{}", e.getMessage());
  303.             // throw new ExploException(HttpCode.ES_SEARCH_ERROR, "查询ES数据失败");
  304.         }
  305.         return documentParagraphs;
  306.     }
  307.  
  308.     /**
  309.      * 高亮数据提取
  310. //     */
  311. //    private DocumentParagraph highLight(Hit<DocumentParagraph> hit) {
  312. //        DocumentParagraph paragraph = hit.source();
  313. //        try {
  314. //            Map<String, List<String>> highlight = hit.highlight();
  315. //            List<String> list = highlight.get("content");
  316. //            String join = StringUtils.join(list, "");
  317. //            if (StringUtils.isNotBlank(join)) {
  318. //                paragraph.setContent(join);
  319. //                paragraph.setScore(hit.score());
  320. //
  321. //            }
  322. //        } catch (Exception e) {
  323. //            log.error("获取ES高亮数据异常：{}", e.getMessage());
  324. //        }
  325. //        return paragraph;
  326. //    }
  327. //    /**
  328. //     *解析高亮数据
  329. //     */
  330. //    Map<String, List<String>> highlight = hit.highlight();
  331. //    List<String> list = highlight.get("content");
  332. //    String join = StringUtils.join(list, "");
  333. //            if (StringUtils.isNotBlank(join)) {
  334. //        paragraph.setContent(join);
  335. //    }
  336.  
  337. }

5. 过程中遇见的问题

5.1 项目启动时异常，pom依赖缺少

  （原文章中只有前两个依赖，上边代码已添加）

  1. <!-- 若不存在Spring Data ES的某个版本支持你下的ES版本,则使用  -->
  2. <!-- ES 官方提供的在JAVA环境使用的依赖 -->
  3. <dependency>
  4.     <groupId>co.elastic.clients</groupId>
  5.     <artifactId>elasticsearch-java</artifactId>
  6.     <version>8.11.1</version>
  7. </dependency>
  8. <!-- 和第一个依赖是一起的,为了解决springboot项目的兼容性问题  -->
  9. <dependency>
  10.     <groupId>com.fasterxml.jackson.core</groupId>
  11.     <artifactId>jackson-databind</artifactId>
  12. </dependency>
  13. <!-- 原来只有前两依赖，但是启动报错找不到依赖，要注意版本号是否兼容  -->
  14. <dependency>
  15.     <groupId>jakarta.json</groupId>
  16.     <artifactId>jakarta.json-api</artifactId>
  17.     <version>2.0.1</version>
  18. </dependency>
  19. <!-- es的客户端，连接，版本号要与ES一致  -->
  20. <dependency>
  21.     <groupId>org.elasticsearch.client</groupId>
  22.     <artifactId>elasticsearch-rest-client</artifactId>
  23.     <version>8.11.1</version>
  24. </dependency>
5.2 密码连接Es时 

     项目启动后，测试向es新建索引

5.2.1 报错Connet 超时
        原因是是因为开启了 ssl 认证。

        elasticsearch.yml 配置 xpack.security.http.ssl: enabled: false（true改成false)

5.2.2 报错 missing authentication credentials for REST…

        [es/indices.create] failed: [security_exception] missing authentication credentials for REST request [/direct_connect…

        因为设置了账号密码链接，但是config类未配置账号密码，原学习文章未包含以下代码，需在ElasticSearchConfig.class 中加上 1.1 和 1.1.1 配置（上边代码已添加）

  1. // 1.1 设置用户名和密码 (账号密码连接，xpack.security.enabled: true)
  2. final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
  3. credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(userName, password));
  4.  
  5.  
  6. // 3. HttpClient 连接数配置
  7. builder.setHttpClientConfigCallback(httpClientBuilder -> {
  8.     httpClientBuilder.setMaxConnTotal(maxConnectNum);
  9.     httpClientBuilder.setMaxConnPerRoute(maxConnectNumPerRoute);
  10.     httpClientBuilder.disableAuthCaching();  // 1.1.1 设置账号密码
  11.     httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
  12.     return httpClientBuilder;
  13. });
5.3 Kibana 启动报错

        Unable to retrieve version information from Elasticsearch nodes. write EPROTO 18300000:error:0A00010B:SSL routines:ssl3_get_record:wrong version ……

1、不能使用localhost，需要使用私有IP。将Kibana.yml中的elasticsearch.hosts以及elasticsearch.yml中的network.host、discovery.seed_hosts都使用私有IP后，问题解决。

原文链接：[疑难杂症]Kibana报错：Unable to retrieve version information from Elasticsearch nodes-CSDN博客

2、elasticsearch.hosts: ['http://10.24.18.94:9200'] 注意这个地址，可能原来是es.yml配置（目录4.2.1）问题，链接方式成https了，改成http。

ES Elasticsearch.yml的xpack.security.http.ssl.enabled：

● 默认true：

        必须使用https://localhost:9200/访问ES服务+启动Kibana服务会成功+需要使用账号连接+必须使用HTTPS连接

● 若为false：

        必须使用http://localhost:9200/访问ES服务+启动Kibana服务会失败+需要使用账号连接，但必须使用HTTP连接

学习链接：【ElasticSearch8】SpringBoot集成ElasticSearch8.x 基本应用 CRUD操作 环境安装-CSDN博客

SpringBoot集成Elasticsearch8.x（7）|（新版本Java API Client使用完整示例）_springboot集成elasticsearch8.xapi-CSDN博客

三、使用 Logstash 同步海量 MySQL 数据到 ES

待补充…………

总结

| 把学习过程中，使用到的各位优秀博主文章整理到一起，做笔记，并分享。有问题欢迎指出。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/649668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号