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

elasticsearch 搜索

作者：爱喝兽奶帝天荒 | 2024-07-17 22:20:10

赞

踩

elasticsearch 搜索

目录

1、安装

1）下载：

 2、安装/运行

  3）、安装可视化界面

2、java 使用ES

1、项目pom文件

2、配置文件中es的配置编写

3、创建es的配置类

①将配置文件的属性已对象的方式封装

②ES的配置类： 

4、ES的工具类编写

5、ES的工具类使用：

扩展：（推荐的使用方式）

es的相关概念：

倒排序原理：

倒排索引的基本原理是:

将 一个句子、文章进行分词 得到term，创建倒排序索引，以term为key，句子是否包含来确定评分，计算总分进行排序

具体如下：

1. 通过分析网页内容,提取网页中出现的所有词语,并记录每个词语出现在哪些网页中。

2. 将上述信息倒排过来,以词语为主要索引建立索引。每个词语下面都指向包含该词语的网页列表。

3. 当搜索词输入后,搜索引擎通过倒排索引找到包含每个搜索词的网页,然后计算它们的交集,得到最终结果。

例如：举个简单例子:

假设有3个网页,内容如下:

网页1:我喜欢打篮球和足球   文档1
网页2:我喜欢听音乐和看书  文档2
网页3:我喜欢游泳和跑步     文档3

将上述网页内容进行分词,得到的term如下:

我、喜欢、打、篮球、和、足球
我、喜欢、听、音乐、和、看、书
我、喜欢、游泳、和、跑步

构建标准索引如下:

我:网页1,网页2,网页3
喜欢:网页1,网页2,网页3
打:网页1 
篮球:网页1
和:网页1,网页2,网页3
足球:网页1
听:网页2
音乐:网页2 
看:网页2
书:网页2
游泳:网页3
跑步:网页3

倒排索引如下:

我:网页1,网页2,网页3 
喜欢:网页1,网页2,网页3 
打:网页1 
篮球:网页1
足球:网页1 
和:网页1,网页2,网页3
听:网页2
音乐:网页2 
看:网页2
书:网页2
游泳:网页3
跑步:网页3

当用户输入查询“我喜欢音乐”,搜索引擎会在倒排索引中查找:

我:网页1,网页2,网页3 
喜欢:网页1,网页2,网页3 
音乐:网页2由于只有网页2同时包含我、喜欢和音乐这3个词,

所以,搜索引擎会将网页2返回作为查询结果。

以上：

整个列表 称之为  索引

句子（即 文档）被分词器分词后得到的是 term（term是搜索引擎理解网页和查询的基本单位）

当输入“我爱中国”,搜索引擎根据倒排索引,我→网页1,网页2;爱→网页1,网页2;中国→网页2。取交集,得到结果为网页2。所以,倒排索引通过倒转标准索引的结构,使用词语作为主要索引,指向包含每个词语的网页,加速了搜索引擎的查询检索过程,是分布式搜索引擎的基础

1、安装

1）下载：

官方下载地址： Download Elasticsearch | Elastic

我是去历史版本里下载的 7.10.1版本 

 

 2、安装/运行

下载后，解压缩，运行bin目录的：elasticsearch.bat即可运行

运行后看到如下界面：

然后访问： localhost:9200

说明：安装成功！ 

（坑：之前作者安装了 但是死活访问不了，后面可能是因为安装了node.js才解决，不确定解决的方法） 

额外的配置：

4.打开 config/elasticsearch.yml  ，末尾添加跨域的配置：         

  1. http.cors.enabled: true
  2. http.cors.allow-origin: "*"

修改后记得重新运行elasticsearch.bat
 

  3）、安装可视化界面

1.安装GitHub elasticsearch-head插件: 下载地址：GitHub - mobz/elasticsearch-head: A web front end for an elastic search cluster

2、安装Node.js:下载地址 Download | Node.js

在window的cmd中执行： 

node -v     查看nodejs是否安装成功 
npm -v      查看npm是否安装成功

cd C:\Users\tzcon\Desktop\es\elasticsearch-head-master          进入head目录下

  1. npm install -g grunt-cli          //grunt是一个很方便的构建工具，可以进行打包压缩、测试、执行等等的工作
  2.  
  3. npm install

 启动：可视化界面

grunt server

 这时候可以访问：

http://localhost:9100/

使用：

参考：

 (81条消息) Windows环境下安装ES全文搜素引擎与head插件_我的世界没光的博客-CSDN博客

2、java 使用ES

（请参考：扩展：（推荐的使用方式）） 

项目目录结构：

1、项目pom文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.1.4.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.sxw</groupId>
  12.     <artifactId>springboot-elasticsearch</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>springboot-elasticsearch</name>
  15.     <description>Demo project for Spring Boot</description>
  16.  
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.         <elasticsearch.version>7.10.1</elasticsearch.version>
  20.     </properties>
  21.  
  22.     <dependencies>
  23.         <!--使用springboot的 component装配等注解-->
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-web</artifactId>
  27.         </dependency>
  28.  
  29.         <!--免得写set、get方法-->
  30.         <dependency>
  31.             <groupId>org.projectlombok</groupId>
  32.             <artifactId>lombok</artifactId>
  33.             <optional>true</optional>
  34.         </dependency>
  35.         <!--一会单元测试 java的操作es的函数测试-->
  36.         <dependency>
  37.             <groupId>org.springframework.boot</groupId>
  38.             <artifactId>spring-boot-starter-test</artifactId>
  39.             <scope>test</scope>
  40.         </dependency>
  41.         <!--以下两个都是 es的内容-->
  42.         <dependency>
  43.             <groupId>org.elasticsearch.client</groupId>
  44.             <artifactId>elasticsearch-rest-high-level-client</artifactId>
  45.             <version>7.10.1</version>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>org.elasticsearch</groupId>
  49.             <artifactId>elasticsearch</artifactId>
  50.             <version>7.10.1</version>
  51.         </dependency>
  52.         <!--引入IOUtil-->
  53.         <dependency>
  54.             <groupId>commons-io</groupId>
  55.             <artifactId>commons-io</artifactId>
  56.             <version>2.3</version>
  57.         </dependency>
  58.  
  59.         <!--json字符串的转换-->
  60.         <dependency>
  61.             <groupId>com.alibaba</groupId>
  62.             <artifactId>fastjson</artifactId>
  63.             <version>1.2.4</version>
  64.         </dependency>
  65.         <!--解决配置文件application.yml 的语法不识别-->
  66.         <dependency>
  67.             <groupId>org.springframework.boot</groupId>
  68.             <artifactId>spring-boot-configuration-processor</artifactId>
  69.             <optional>true</optional>
  70.         </dependency>
  71.     </dependencies>
  72.  
  73.     <build>
  74.         <plugins>
  75.             <plugin>
  76.                 <groupId>org.springframework.boot</groupId>
  77.                 <artifactId>spring-boot-maven-plugin</artifactId>
  78.             </plugin>
  79.         </plugins>
  80.     </build>
  81.  
  82. </project>
  83.  
  84.

2、配置文件中es的配置编写

  1. spring:
  2.   rest:
  3.     host: 127.0.0.1
  4.     port: 9200
  5.     protocol: http
  6.     username:
  7.     password:

3、创建es的配置类

①将配置文件的属性已对象的方式封装

  1. package com.sxw.elasticsearch.config;
  2.  
  3. import lombok.Data;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.stereotype.Component;
  6.  
  7. @Data
  8. @Component
  9. @ConfigurationProperties(prefix = "spring.rest")
  10. public class RestProperties {
  11.     private String host;
  12.     private int port;
  13.     private String protocol;
  14.     private String username;
  15.     private String password;
  16. }

②ES的配置类： 

  1. package com.sxw.elasticsearch.config;
  2.  
  3.  
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.http.HttpHost;
  6. import org.apache.http.impl.nio.reactor.IOReactorConfig;
  7. import org.elasticsearch.client.RestClient;
  8.  
  9. import org.elasticsearch.client.RestClientBuilder;
  10. import org.elasticsearch.client.RestHighLevelClient;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.beans.factory.annotation.Qualifier;
  13. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  14. import org.springframework.context.annotation.Bean;
  15. import org.springframework.context.annotation.Configuration;
  16.  
  17.  
  18. @Slf4j
  19. @Configuration
  20. @EnableConfigurationProperties(RestProperties.class)
  21. public class RestClientConfig {
  22.  
  23.     @Autowired
  24.     @Qualifier("restProperties")
  25.     private  RestProperties properties;
  26.  
  27.     @Bean
  28.     public RestHighLevelClient client() {
  29.         RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(properties.getHost(), properties.getPort(), properties.getProtocol()));
  30.         restClientBuilder.setRequestConfigCallback(builder -> {
  31.             // 连接超时（默认为1秒）
  32.             builder.setConnectTimeout(5000);
  33.             // 套接字超时（默认为30秒）
  34.             builder.setSocketTimeout(60000);
  35.             return builder;
  36.         });
  37.         restClientBuilder.setHttpClientConfigCallback(builder -> {
  38.             // 线程数
  39.             builder.setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(1).build());
  40.             return builder;
  41.         });
  42.         return new RestHighLevelClient(restClientBuilder);
  43.     }
  44. }

4、ES的工具类编写

摘抄自网络上：亲测可用

  1. package com.sxw.elasticsearch.util;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import lombok.Data;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.commons.io.IOUtils;
  8. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  9. import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
  10. import org.elasticsearch.action.bulk.BulkRequest;
  11. import org.elasticsearch.action.bulk.BulkResponse;
  12. import org.elasticsearch.action.delete.DeleteRequest;
  13. import org.elasticsearch.action.delete.DeleteResponse;
  14. import org.elasticsearch.action.get.GetRequest;
  15. import org.elasticsearch.action.get.GetResponse;
  16. import org.elasticsearch.action.index.IndexRequest;
  17. import org.elasticsearch.action.index.IndexResponse;
  18. import org.elasticsearch.action.search.SearchRequest;
  19. import org.elasticsearch.action.search.SearchResponse;
  20. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  21. import org.elasticsearch.action.update.UpdateRequest;
  22. import org.elasticsearch.action.update.UpdateResponse;
  23. import org.elasticsearch.client.RequestOptions;
  24. import org.elasticsearch.client.RestClient;
  25. import org.elasticsearch.client.RestHighLevelClient;
  26. import org.elasticsearch.client.indices.CreateIndexRequest;
  27. import org.elasticsearch.client.indices.CreateIndexResponse;
  28. import org.elasticsearch.client.indices.GetIndexRequest;
  29. import org.elasticsearch.common.Strings;
  30. import org.elasticsearch.common.text.Text;
  31. import org.elasticsearch.common.unit.DistanceUnit;
  32. import org.elasticsearch.common.unit.TimeValue;
  33. import org.elasticsearch.common.xcontent.XContentType;
  34. import org.elasticsearch.index.query.BoolQueryBuilder;
  35. import org.elasticsearch.index.query.GeoDistanceQueryBuilder;
  36. import org.elasticsearch.index.query.QueryBuilder;
  37. import org.elasticsearch.index.query.QueryBuilders;
  38. import org.elasticsearch.index.reindex.BulkByScrollResponse;
  39. import org.elasticsearch.index.reindex.DeleteByQueryRequest;
  40. import org.elasticsearch.index.reindex.UpdateByQueryRequest;
  41. import org.elasticsearch.script.Script;
  42. import org.elasticsearch.script.ScriptType;
  43. import org.elasticsearch.search.SearchHit;
  44. import org.elasticsearch.search.aggregations.AggregationBuilder;
  45. import org.elasticsearch.search.aggregations.Aggregations;
  46. import org.elasticsearch.search.aggregations.metrics.Cardinality;
  47. import org.elasticsearch.search.builder.SearchSourceBuilder;
  48. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  49. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  50. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
  51. import org.elasticsearch.search.sort.SortOrder;
  52. import org.springframework.beans.factory.annotation.Autowired;
  53.  
  54. import org.springframework.core.io.ClassPathResource;
  55. import org.springframework.stereotype.Component;
  56. import org.springframework.util.CollectionUtils;
  57. import org.springframework.util.StringUtils;
  58.  
  59. import java.io.*;
  60. import java.net.HttpURLConnection;
  61. import java.net.URL;
  62. import java.net.URLConnection;
  63. import java.nio.charset.StandardCharsets;
  64. import java.util.ArrayList;
  65. import java.util.Collections;
  66. import java.util.List;
  67. import java.util.Map;
  68. import java.util.concurrent.TimeUnit;
  69.  
  70.  
  71. @Slf4j
  72. @Component
  73. @Data
  74. public class RestClientService {
  75.  
  76.     /**
  77.      * ES最大数据限制
  78.      */
  79.     public static final int MAX_DATA_SIZE = 100;
  80.     @Autowired
  81.     private RestHighLevelClient restHighLevelClient;
  82.  
  83.     /********************************************创建mapping********************************************/
  84.     /**
  85.      * 加载文件内容
  86.      *
  87.      * @param path
  88.      * @return
  89.      */
  90.     public String loadText(String path) {
  91.         String textData = null;
  92.         try {
  93.             ClassPathResource classPathResource = new ClassPathResource(path);
  94.             try (InputStream inputStream = classPathResource.getInputStream()) {
  95.                 textData = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
  96.             }
  97.         } catch (Exception e) {
  98.             log.error("load mappping file error, cause {0}", e);
  99.         }
  100.         return textData;
  101.     }
  102.  
  103.     /**
  104.      * 创建mapping映射
  105.      *
  106.      * @param index
  107.      * @param path
  108.      * @return
  109.      */
  110.     public boolean createIndexMapping(String index, String path) {
  111.         PutMappingRequest request = new PutMappingRequest(index);
  112.         request.source(loadText(path), XContentType.JSON);
  113.         try {
  114.             AcknowledgedResponse response = restHighLevelClient.indices().putMapping(request, RequestOptions.DEFAULT);
  115.             return response.isAcknowledged();
  116.         } catch (IOException e) {
  117.             log.error("create index mapping error, cause {0}", e);
  118.         }
  119.         return false;
  120.     }
  121.  
  122.     /********************************************索引(创建，删除，存在)********************************************/
  123.     /**
  124.      * 创建索引,若索引不存在且创建成功,返回true,若同名索引已存在,返回false
  125.      *
  126.      * @param index 索引名称
  127.      * @return
  128.      */
  129.     public boolean createIndex(String index) {
  130.         //创建索引请求
  131.         CreateIndexRequest request = new CreateIndexRequest(index);
  132.         //执行创建请求IndicesClient,请求后获得响应
  133.         try {
  134.             CreateIndexResponse response = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
  135.             return response.isAcknowledged();
  136.         } catch (Exception e) {
  137.             log.error("create index error, cause {0}", e);
  138.         }
  139.         return false;
  140.     }
  141.  
  142.     /**
  143.      * 删除索引,删除成功返回true,删除失败返回false
  144.      *
  145.      * @param index 索引名称
  146.      * @return true/false
  147.      */
  148.     public boolean deleteIndex(String index) {
  149.         if (!existsIndex(index)) {
  150.             log.debug("deleteIndex error, cause: {} not exists", index);
  151.             return false;
  152.         }
  153.         DeleteIndexRequest request = new DeleteIndexRequest(index);
  154.         try {
  155.             AcknowledgedResponse response =restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
  156.             return response.isAcknowledged();
  157.         } catch (Exception e) {
  158.             log.error("delete index error, cause {0}", e);
  159.         }
  160.         return false;
  161.     }
  162.  
  163.  
  164.     /**
  165.      * 判断索引是否存在,若存在返回true,若不存在或出现问题返回false
  166.      *
  167.      * @param index 索引名称
  168.      * @return
  169.      */
  170.     public boolean existsIndex(String index) {
  171.         GetIndexRequest request = new GetIndexRequest(index);
  172.         try {
  173.             restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
  174.         } catch (Exception e) {
  175.             log.error("existsIndex error, cause {0}", e);
  176.         }
  177.         return false;
  178.     }
  179.  
  180.     /********************************************文档(创建，更新，删除，存在)********************************************/
  181.     /**
  182.      * 新增/修改文档信息
  183.      *
  184.      * @param index 索引名称
  185.      * @param id    文档id
  186.      * @param data  数据
  187.      * @return
  188.      */
  189.     public boolean createDocument(String index, String id, JSONObject data) {
  190.         try {
  191.             IndexRequest request = new IndexRequest(index);
  192.             if (id != null && id.length() > 0) {
  193.                 request.id(id);
  194.             }
  195.             request.source(JSON.toJSONString(data), XContentType.JSON);
  196.             IndexResponse response =restHighLevelClient.index(request, RequestOptions.DEFAULT);
  197.             String status = response.status().toString();
  198.             if ("CREATED".equals(status) || "OK".equals(status)) {
  199.                 return true;
  200.             }
  201.         } catch (Exception e) {
  202.             log.error("put data error, cause {0}", e);
  203.         }
  204.         return false;
  205.     }
  206.  
  207.  
  208.     /**
  209.      * 批量插入文档,id是随机的
  210.      *
  211.      * @param index 索引名称
  212.      * @param datas 数据的集合
  213.      * @return
  214.      */
  215.     public boolean createDocuments(String index, List<JSONObject> datas) {
  216.         try {
  217.             BulkRequest bulkRequest = new BulkRequest();
  218.             if (!CollectionUtils.isEmpty(datas)) {
  219.                 for (Object obj : datas) {
  220.                     bulkRequest.add(new IndexRequest(index).source(JSON.toJSONString(obj), XContentType.JSON));
  221.                 }
  222.                 BulkResponse response =restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
  223.                 log.debug("putDataBulk:{}", response);
  224.                 if (!response.hasFailures()) {
  225.                     return true;
  226.                 }
  227.             }
  228.         } catch (Exception e) {
  229.             log.error("put data bulk error, cause {0}", e);
  230.         }
  231.         return false;
  232.     }
  233.  
  234.     /**
  235.      * 更新文档
  236.      *
  237.      * @param index 索引名称
  238.      * @param id    文档id
  239.      * @param data  数据
  240.      * @return
  241.      */
  242.     public boolean updateDocumentById(String index, String id, JSONObject data) {
  243.         try {
  244.             UpdateRequest request = new UpdateRequest(index, id);
  245.             request.doc(JSON.toJSONString(data), XContentType.JSON);
  246.             UpdateResponse response =restHighLevelClient.update(request, RequestOptions.DEFAULT);
  247.             String status = response.status().toString();
  248.             if ("OK".equals(status)) {
  249.                 return true;
  250.             }
  251.         } catch (Exception e) {
  252.             log.error("update data error, cause {0}", e);
  253.         }
  254.         return false;
  255.     }
  256.  
  257.     /**
  258.      * 删除文档
  259.      *
  260.      * @param index 索引名称
  261.      * @param id    文档id
  262.      * @return
  263.      */
  264.     public boolean deleteDocument(String index, String id) {
  265.         try {
  266.             DeleteRequest request = new DeleteRequest(index, id);
  267.             DeleteResponse response =restHighLevelClient.delete(request, RequestOptions.DEFAULT);
  268.             String status = response.status().toString();
  269.             if ("OK".equals(status)) {
  270.                 return true;
  271.             }
  272.         } catch (Exception e) {
  273.             log.error("delete data error, cause {0}", e);
  274.         }
  275.         return false;
  276.     }
  277.  
  278.     /**
  279.      * 批量删除文档
  280.      *
  281.      * @param index 索引名称
  282.      * @param ids   文档id的集合
  283.      * @return
  284.      */
  285.     public boolean deleteDataBulk(String index, List<String> ids) {
  286.         BulkRequest request = new BulkRequest();
  287.         for (String id : ids) {
  288.             request.add(new DeleteRequest().index(index).id(id));
  289.         }
  290.         try {
  291.             BulkResponse response =restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
  292.             return !response.hasFailures();
  293.         } catch (Exception e) {
  294.             log.error("delete data bulk error, cause {0}", e);
  295.         }
  296.         return false;
  297.     }
  298.  
  299.     /**
  300.      * 条件删除
  301.      *
  302.      * @param index        索引名称
  303.      * @param queryBuilder 删除条件
  304.      * @return
  305.      */
  306.     public boolean deleteByQuery(String index, QueryBuilder queryBuilder) {
  307.         DeleteByQueryRequest request = new DeleteByQueryRequest(index);
  308.         request.setRefresh(true);
  309.         request.setQuery(queryBuilder);
  310.         try {
  311.             BulkByScrollResponse response =restHighLevelClient.deleteByQuery(request, RequestOptions.DEFAULT);
  312.             return response.getStatus().getDeleted() > 0;
  313.         } catch (IOException e) {
  314.             log.error("delete by query error, cause {0}", e);
  315.         }
  316.         return false;
  317.     }
  318.  
  319.     /**
  320.      * 条件更新
  321.      *
  322.      * @param index        索引名称
  323.      * @param queryBuilder 更新条件
  324.      * @return
  325.      */
  326.     public boolean updateByQuery(String index, QueryBuilder queryBuilder, String script) {
  327.         UpdateByQueryRequest request = new UpdateByQueryRequest(index);
  328.         request.setConflicts("proceed");
  329.         request.setQuery(queryBuilder);
  330.         request.setScript(new Script(ScriptType.INLINE, "painless", script, Collections.emptyMap()));
  331.         try {
  332.             BulkByScrollResponse response =restHighLevelClient.updateByQuery(request, RequestOptions.DEFAULT);
  333.             return response.getStatus().getUpdated() > 0;
  334.         } catch (IOException e) {
  335.             log.error("update by query error, cause {0}", e);
  336.         }
  337.         return false;
  338.     }
  339.  
  340.     /**
  341.      * 判断文档是否存在
  342.      *
  343.      * @param index 索引名称
  344.      * @param id    文档id
  345.      * @return
  346.      */
  347.     public boolean existsDocument(String index, String id) {
  348.         GetRequest request = new GetRequest(index, id);
  349.         try {
  350.             GetResponse response =restHighLevelClient.get(request, RequestOptions.DEFAULT);
  351.             return response.isExists();
  352.         } catch (Exception e) {
  353.             log.error("existsData error, cause {0}", e);
  354.         }
  355.         return false;
  356.     }
  357.  
  358.     /********************************************文档(查询)********************************************/
  359.     /**
  360.      * 条件查询
  361.      *
  362.      * @param index              索引名称
  363.      * @param queryBuilder       查询条件
  364.      * @param aggregationBuilder 聚合条件
  365.      * @return
  366.      */
  367.     public SearchResponse query(String index, QueryBuilder queryBuilder, AggregationBuilder aggregationBuilder) {
  368.         SearchRequest searchRequest = new SearchRequest(index);
  369.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  370.         searchSourceBuilder.trackTotalHits(true);
  371.         searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
  372.         // 查询条件
  373.         if (queryBuilder != null) {
  374.             searchSourceBuilder.query(queryBuilder);
  375.         }
  376.         // 聚合条件
  377.         if (aggregationBuilder != null) {
  378.             searchSourceBuilder.aggregation(aggregationBuilder);
  379.         }
  380.         searchRequest.source(searchSourceBuilder);
  381.         try {
  382.             restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
  383.         } catch (IOException e) {
  384.             log.error("select distinct count error cause: {0}", e);
  385.         }
  386.         return null;
  387.     }
  388.  
  389.     /**
  390.      * 查询数量
  391.      *
  392.      * @param index        索引名称
  393.      * @param queryBuilder 查询条件
  394.      * @return
  395.      */
  396.     public Long selectCount(String index, QueryBuilder queryBuilder) {
  397.         SearchResponse response = query(index, queryBuilder, null);
  398.         if (response == null) {
  399.             return 0L;
  400.         }
  401.         return response.getHits().getTotalHits().value;
  402.  
  403.     }
  404.  
  405.     /**
  406.      * 聚合查询-返回统计数值
  407.      *
  408.      * @param index              索引名称
  409.      * @param aggName            聚合名称
  410.      * @param queryBuilder       查询条件
  411.      * @param aggregationBuilder 聚合条件
  412.      * @return 统计值
  413.      */
  414.     public Long selectCount(String index, String aggName, QueryBuilder queryBuilder, AggregationBuilder aggregationBuilder) {
  415.         SearchResponse response = query(index, queryBuilder, aggregationBuilder);
  416.         if (response == null) {
  417.             return 0L;
  418.         }
  419.         Aggregations aggregations = response.getAggregations();
  420.         // 根据聚合名称获取统计值
  421.         Cardinality cardinality = aggregations.get(aggName);
  422.         return cardinality.getValue();
  423.     }
  424.  
  425.  
  426.     /**
  427.      * 批量新增
  428.      *
  429.      * @paramrestHighLevelClient
  430.      * @param indexName
  431.      * @param list
  432.      */
  433.     public static void multiAdd(RestHighLevelClient restHighLevelClient, String indexName, List<Object> list) {
  434.         BulkRequest request = new BulkRequest();
  435.         request.timeout("10s");
  436.         //批量请求，批量更新，删除都差不多！！！不设置id就会自动生成随机id，演示为批量插入
  437.         for (int i = 0; i < list.size(); i++) {
  438.             request.add(new IndexRequest(indexName)
  439.                     .id("" + (i + 1))
  440.                     .source(JSON.toJSONString(list.get(i)), XContentType.JSON));
  441.         }
  442.         try {
  443.             BulkResponse response =restHighLevelClient.bulk(request, RequestOptions.DEFAULT);
  444.             log.info("=====> multiAdd()：" + JSONObject.toJSONString(response));
  445.         } catch (IOException e) {
  446.             log.error("=====> multiAdd()出错：" + e.getMessage());
  447.         }
  448.     }
  449.  
  450.  
  451.  
  452.  
  453.     /**
  454.      * 通过ID获取数据
  455.      * @param index  索引，类似数据库
  456.      * @param id     数据ID
  457.      * @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
  458.      * @return
  459.      */
  460.     public Map<String,Object> searchDataById(String index, String id, String fields) throws IOException {
  461.         GetRequest request = new GetRequest();
  462.         request.index(index);
  463.         request.id(id);
  464.         if (!StringUtils.isEmpty(fields)){
  465.             //只查询特定字段。如果需要查询所有字段则不设置该项。
  466.             request.fetchSourceContext(new FetchSourceContext(true,fields.split(","), Strings.EMPTY_ARRAY));
  467.         }
  468.         GetResponse response =restHighLevelClient.get(request, RequestOptions.DEFAULT);
  469.         return response.getSource();
  470.     }
  471.  
  472.  
  473.     /**
  474.      * 根据经纬度查询范围查找location 经纬度字段，distance 距离中心范围KM，lat  lon 圆心经纬度
  475.      * @param index
  476.      * @param longitude
  477.      * @param latitude
  478.      * @param distance
  479.      * @return
  480.      */
  481.     public  SearchResponse geoDistanceQuery(String index,Float  longitude, Float latitude,String distance) throws IOException {
  482.  
  483.         if(longitude == null || latitude == null){
  484.             return null;
  485.         }
  486.         //拼接条件
  487.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  488. //        QueryBuilder isdeleteBuilder = QueryBuilders.termQuery("isdelete", false);
  489.         // 以某点为中心，搜索指定范围
  490.         GeoDistanceQueryBuilder distanceQueryBuilder = new GeoDistanceQueryBuilder("location");
  491.         distanceQueryBuilder.point(latitude, longitude);
  492.         //查询单位：km
  493.         distanceQueryBuilder.distance(distance, DistanceUnit.KILOMETERS);
  494.         boolQueryBuilder.filter(distanceQueryBuilder);
  495. //        boolQueryBuilder.must(isdeleteBuilder);
  496.  
  497.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  498.         searchSourceBuilder.query(boolQueryBuilder);
  499.  
  500.         SearchRequest searchRequest = new SearchRequest(index);
  501.         searchRequest.source(searchSourceBuilder);
  502.  
  503.         SearchResponse searchResponse =restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
  504.         return searchResponse;
  505.     }
  506.  
  507.     /**
  508.      * 获取低水平客户端
  509.      * @return
  510.      */
  511.     public RestClient getLowLevelClient() {
  512.         return restHighLevelClient.getLowLevelClient();
  513.     }
  514.  
  515.     /**
  516.      * 高亮结果集 特殊处理
  517.      * map转对象 JSONObject.parseObject(JSONObject.toJSONString(map), Content.class)
  518.      * @param searchResponse
  519.      * @param highlightField
  520.      */
  521.     private  List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
  522.         //解析结果
  523.         ArrayList<Map<String,Object>> list = new ArrayList<>();
  524.         for (SearchHit hit : searchResponse.getHits().getHits()) {
  525.             Map<String, HighlightField> high = hit.getHighlightFields();
  526.             HighlightField title = high.get(highlightField);
  527.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
  528.             //解析高亮字段,将原来的字段换为高亮字段
  529.             if (title!=null){
  530.                 Text[] texts = title.fragments();
  531.                 String nTitle="";
  532.                 for (Text text : texts) {
  533.                     nTitle+=text;
  534.                 }
  535.                 //替换
  536.                 sourceAsMap.put(highlightField,nTitle);
  537.             }
  538.             list.add(sourceAsMap);
  539.         }
  540.         return list;
  541.     }
  542.  
  543.     /**
  544.      * 查询并分页
  545.      * @param index          索引名称
  546.      * @param query          查询条件
  547.      * @param size           文档大小限制
  548.      * @param fields         需要显示的字段，逗号分隔（缺省为全部字段）
  549.      * @param sortField      排序字段
  550.      * @param highlightField 高亮字段
  551.      * @return
  552.      */
  553.     public  List<Map<String, Object>>  searchListData(String index,
  554.                                                       SearchSourceBuilder query,
  555.                                                       Integer from,
  556.                                                       Integer size,
  557.                                                       String fields,
  558.                                                       String sortField,
  559.                                                       String highlightField) throws IOException {
  560.         SearchRequest request = new SearchRequest(index);
  561.         SearchSourceBuilder builder = query;
  562.         if (!StringUtils.isEmpty(fields)){
  563.             //只查询特定字段。如果需要查询所有字段则不设置该项。
  564.             builder.fetchSource(new FetchSourceContext(true,fields.split(","), Strings.EMPTY_ARRAY));
  565.         }
  566.         from = from <= 0 ? 0 : from*size;
  567.         //设置确定结果要从哪个索引开始搜索的from选项，默认为0
  568.         builder.from(from);
  569.         builder.size(size);
  570.         if (!StringUtils.isEmpty(sortField)){
  571.             //排序字段，注意如果proposal_no是text类型会默认带有keyword性质，需要拼接.keyword
  572.             builder.sort(sortField+".keyword", SortOrder.ASC);
  573.         }
  574.         //高亮
  575.         HighlightBuilder highlight = new HighlightBuilder();
  576.         highlight.field(highlightField);
  577.         //关闭多个高亮
  578.         highlight.requireFieldMatch(false);
  579.         highlight.preTags("<span style='color:red'>");
  580.         highlight.postTags("</span>");
  581.  
  582.         builder.highlighter(highlight);
  583.         //不返回源数据。只有条数之类的数据。
  584. //        builder.fetchSource(false);
  585.         request.source(builder);
  586.         SearchResponse response =restHighLevelClient.search(request, RequestOptions.DEFAULT);
  587.         log.info("result:"+response.getHits().getTotalHits());
  588.         System.out.println(JSON.toJSONString(response.getHits()));
  589.         if (response.status().getStatus() == 200) {
  590.             // 解析对象
  591.             return setSearchResponse(response, highlightField);
  592.         }
  593.         return null;
  594.     }
  595.  
  596. }

5、ES的工具类使用：

  1. package com.sxw.elasticsearch.test;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.sxw.elasticsearch.MyBaseTest;
  6. import com.sxw.elasticsearch.model.Product;
  7. import com.sxw.elasticsearch.util.RestClientService;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.lucene.search.join.ScoreMode;
  10. import org.elasticsearch.action.index.IndexRequest;
  11.  
  12. import org.elasticsearch.client.RestHighLevelClient;
  13.  
  14. import org.elasticsearch.common.xcontent.XContentType;
  15. import org.elasticsearch.index.query.QueryBuilders;
  16. import org.elasticsearch.search.builder.SearchSourceBuilder;
  17. import org.junit.Test;
  18. import org.springframework.beans.factory.annotation.Autowired;
  19. import org.springframework.data.domain.PageRequest;
  20. import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
  21. import org.springframework.data.elasticsearch.core.SearchHit;
  22. import org.springframework.data.elasticsearch.core.SearchHits;
  23. import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
  24. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  25.  
  26.  
  27. import java.io.IOException;
  28. import java.util.*;
  29.  
  30. /**
  31.  * @author wangjianwei
  32.  * * @date 2022/4/19
  33.  */
  34. @Slf4j
  35. public class eeee extends MyBaseTest {
  36.  
  37.     @Autowired
  38.     RestHighLevelClient client;
  39.  
  40.     @Test
  41.     public void aa() throws IOException {
  42.         // Create the "products" index
  43.  
  44.         IndexRequest request = new IndexRequest("posts");
  45.         request.id("1");
  46.         String jsonString = "{" +
  47.                 "\"user\":\"kimchy\"," +
  48.                 "\"postDate\":\"2013-01-30\"," +
  49.                 "\"message\":\"trying out Elasticsearch\"" +
  50.                 "}";
  51.         request.source(jsonString, XContentType.JSON);
  52.  
  53.         System.out.println();
  54.     }
  55.  
  56.     @Autowired
  57.     RestClientService restClientService;
  58.  
  59.  
  60.     @Test
  61.     public void createIndex() {
  62.         boolean blog2 = restClientService.createIndex("blog3");
  63.         System.out.println();
  64.     }
  65.  
  66.  
  67.     //如果没有blog1索引，则会自动创建
  68.     @Test
  69.     public void createDocument() {
  70.         JSONObject data= JSON.parseObject("{\"age\":\"10\",\"name\":\"李四\",\"address\":{\"area1\":\"萧山区\",\"area2\":\"杭州市\"} }");
  71.         boolean blog1 = restClientService.createDocument("blog1","1",data);
  72.         System.out.println(blog1);
  73.     }
  74.  
  75.     //批量插入
  76.     @Test
  77.     public void createDocuments() {
  78.         JSONObject data1= JSON.parseObject("{\"age\":\"10\",\"name\":\"李四11\",\"address\":{\"area1\":\"萧山区11\",\"area2\":\"杭州市\"} }");
  79.         JSONObject data2= JSON.parseObject("{\"age\":\"10\",\"name\":\"李四22\",\"address\":{\"area1\":\"萧山区22\",\"area2\":\"杭州市\"} }");
  80.         ArrayList<JSONObject> arrayList = new ArrayList<>();
  81.         arrayList.add(data1);
  82.         arrayList.add(data2);
  83.         boolean blog1 = restClientService.createDocuments("blog1",arrayList);
  84.         System.out.println(blog1);
  85.     }
  86.  
  87.  
  88.     @Test
  89.     public void existsIndex() {
  90.         boolean blog2 = restClientService.existsIndex("blog3");
  91.         System.out.println(blog2);
  92.     }
  93.  
  94.  
  95.     @Test
  96.     public void deleteIndex() {
  97.         boolean flag = restClientService.deleteIndex("blog3");
  98.         System.out.println(flag);
  99.     }
  100.  
  101.     @Test
  102.     public void deleteDocumentById() {
  103.         boolean flag = restClientService.deleteDocument("blog1","1");
  104.         System.out.println(flag);
  105.     }
  106.  
  107.     @Test
  108.     public void updateDocument() {
  109.         JSONObject data= JSON.parseObject("{\"age\":\"99\",\"name\":\"李四7\",\"address\":{\"area1\":\"萧山区\",\"area2\":\"杭州市1\"} }");
  110.         boolean flag = restClientService.updateDocumentById("blog1","1",data);
  111.         System.out.println(flag);
  112.     }
  113.  
  114.     @Test
  115.     public void searchDataById() throws IOException {
  116.         Map<String, Object> stringObjectMap = restClientService.searchDataById("blog1", "1", "");
  117.         Map<String, Object> stringObjectMap1 = restClientService.searchDataById("blog1", "1", "address");
  118.         System.out.println(stringObjectMap);
  119.     }
  120.  
  121.  
  122.     //复合分页的查询
  123.     @Test
  124.     public void searchListData1() throws IOException {
  125.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  126.         RestHighLevelClient restHighLevelClient = restClientService.getRestHighLevelClient();
  127.         restHighLevelClient.search()
  128.         List<Map<String, Object>> maps = restClientService.searchListData("patpat-products", searchSourceBuilder, 0, 2, "", "", "");
  129.         String datas = JSON.toJSONString(maps);
  130.         System.out.println(datas);
  131.     }
  132.  
  133.  
  134. }

扩展：（推荐的使用方式）

事实上，springboot的自动配置已经有了elasticsearch的配置，我们只需要告诉springboot的es地址、用户、密码、端口就可以了如：

配置好这一行后，spring容器中自动给我们注入了restHighLevelClient  的对象，如果我们想要像其他数据库的常规用途：XXXTemplate。这时Maven引入： 

  1.   <!--如果想要使用ElasticsearchRestTemplate 那就引入此依赖没否则-->
  2.         <dependency>
  3.             <groupId>org.springframework.data</groupId>
  4.             <artifactId>spring-data-elasticsearch</artifactId>
  5.             <version>4.0.9.RELEASE</version>
  6.             <scope>compile</scope>
  7.             <exclusions>
  8.                 <exclusion>
  9.                     <artifactId>transport</artifactId>
  10.                     <groupId>org.elasticsearch.client</groupId>
  11.                 </exclusion>
  12.             </exclusions>
  13.         </dependency>

 源码理解：

使用：

  1.   @Autowired
  2.     // ElasticsearchRestTemplate 类中有 RestHighLevelClient作为属性，我们配置 RestClientConfig 后 会在spring容器中注入了 该属性，
  3.     ElasticsearchRestTemplate elasticsearchRestTemplate;
  4.     //复合分页的查询
  5.     @Test
  6.     public void searchListData() throws IOException {
  7.  
  8.         //模拟参数
  9.         ArrayList<Integer> list = new ArrayList<>();
  10.         list.add(1);
  11.         list.add(2);
  12.         //该条件构造器 各种条件的拼接 类似于mybatis-plus 中的 queryWrapper
  13.         NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
  14.         builder.withPageable(PageRequest.of(0, Integer.parseInt(String.valueOf(1000))));
  15.         builder.withQuery(QueryBuilders.boolQuery()
  16.                                        .must(QueryBuilders.termsQuery("product_id", list))
  17.                                        .must(QueryBuilders.nestedQuery(
  18.                                                "sale_status",
  19.                                                QueryBuilders.boolQuery()
  20.                                                             .must(QueryBuilders.termQuery("sale_status.store_id", 30000))
  21.                                                             .must(QueryBuilders.termQuery("sale_status.status", 11)),
  22.                                                ScoreMode.None)));
  23.         NativeSearchQuery build = builder.build();
  24.         //上面条件器构造好了， 现在要去查哪个 索引呢？ 其实spring注解有简便的方法，在返回的解析类中进行标记，如下：语句
  25.         SearchHits<Product> it = elasticsearchRestTemplate.search(build, Product.class);
  26.         System.out.println("");
  27.  
  28. // //使用elasticsearchRestTemplate查询索引aa的结构
  29.         Map<String, Object> index_name = elasticsearchRestTemplate.indexOps(IndexCoordinates.of("aa")).getMapping();
  30.  
  31.     }

其中： Product为：

 debug结果：

XXQueryBuilder的“翻译”：

es的查询技巧 类比sql： 

sql转es的在线工具：

在线工具：SQL转ElasticSearch DSL - 潇洒哥和黑大帅

好文参考：

（下文中可能由于版本不同 部分语法不同，但基本变化不大）

1、快速上手-聚合分析 | MRCODE-BOOK 

2、bool 组合多个 filter 搜索 | MRCODE-BOOK

扩展：一些语句和区分

  1. 外层的bool查询包含了几个should查询，这意味着满足任何一个内层的bool查询即可匹配。 
    1. bool
    2.     |__should
    3.     |__should
    4.     |__should
    5.  
    6. 3个should只要有一个匹配到就算
  2. 如果bool查询同时包含must或filter子句和should子句，那么即使should子句的条件不被满足，文档也有可能被查出来，只要它们满足must和filter中的条件。在这种情况下，should子句的作用是提高满足其条件的文档的相关性得分（_score），而不是作为硬性的匹配条件 
    1. bool
    2.     |__should (此刻should不是必须匹配了)
    3.     |__must
    4.     |__must
    5.     |__filter
  3. term和filter的区别
    特性term查询filter子句
    目的用于精确匹配字段的值用于过滤文档，确保它们符合某些标准
    评分计算并使用相关性得分（_score）进行排序不计算相关性得分，不影响排序
    性能相对较慢，因为需要计算得分相对较快，因为不计算得分且结果可以被缓存
    缓存通常不缓存查询结果可以缓存结果，提高重复查询的性能
    使用场景当你需要根据精确值进行搜索且关心文档的排名时使用当你只需要过滤文档且不关心文档的排名时使用
    示例{
        "term": {
            "status": "active"
        }
    }    		{
        "bool": {
            "filter": {
                "term": {
                    "status": "active"
                }
            }
        }
    }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/842302
推荐阅读
相关标签

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

  

闽ICP备14008679号