介绍

Spirng Boot整合ElasticSearch，通过Java代码操作ElasticSearch。
https://www.elastic.co/guide/en/elasticsearch/client/index.html
image.png
Spring Boot集成ElasticSearch的时候，我们需要引入高阶客户端【elasticsearch-rest-high-level-client】【elasticsearch-rest-client】和【elasticsearch】来操作Elasticsearch，在引入依赖的时候，需要严格注意版本关系，否则在使用过程中会出很多问题。
另外，TransportClient 为代表的ES原生客户端，不能执行原生DSL语句，必须使用它的Java API方法。
最近elasticsearch官网，宣布计划在7.0以后的版本中废除TransportClient。以Java high Level Rest Client为主。
image.png

【客户端开发环境搭建】

1. 创建Maven工程

springboot-highlevel-client

2.pom文件导入依赖

  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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.adong.elasticsearch</groupId>
  8.     <artifactId>springboot-highlevel-client</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.     <parent>
  11.         <groupId>org.springframework.boot</groupId>
  12.         <artifactId>spring-boot-starter-parent</artifactId>
  13.         <version>2.2.2.RELEASE</version>
  14.         <relativePath/>
  15.     </parent>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  21.     <dependencies>
  23.         <!--elasticsearch的高级别rest客户端-->
  24.         <dependency>
  25.             <groupId>org.elasticsearch.client</groupId>
  26.             <artifactId>elasticsearch-rest-high-level-client</artifactId>
  27.             <version>6.8.1</version>
  28.         </dependency>
  29.         <!--elasticsearch的rest客户端-->
  30.         <dependency>
  31.             <groupId>org.elasticsearch.client</groupId>
  32.             <artifactId>elasticsearch-rest-client</artifactId>
  33.             <version>6.8.1</version>
  34.         </dependency>
  35.         <!--elasticsearch的核心jar包-->
  36.         <dependency>
  37.             <groupId>org.elasticsearch</groupId>
  38.             <artifactId>elasticsearch</artifactId>
  39.             <version>6.8.1</version>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter</artifactId>
  44.         </dependency>
  46.         <!--json转换的jar包-->
  47.         <dependency>
  48.             <groupId>com.fasterxml.jackson.core</groupId>
  49.             <artifactId>jackson-databind</artifactId>
  50.             <version>2.9.9</version>
  51.         </dependency>
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-devtools</artifactId>
  56.             <scope>runtime</scope>
  57.             <optional>true</optional>
  58.         </dependency>
  59.         <dependency>
  61.             <groupId>org.springframework.boot</groupId>
  62.             <artifactId>spring-boot-configuration-processor</artifactId>
  63.             <optional>true</optional>
  64.         </dependency>
  65.         <dependency>
  67.             <groupId>org.projectlombok</groupId>
  68.             <artifactId>lombok</artifactId>
  69.             <optional>true</optional>
  70.         </dependency>
  72.         <dependency>
  73.             <groupId>org.springframework.boot</groupId>
  74.             <artifactId>spring-boot-starter-test</artifactId>
  75.             <scope>test</scope>
  76.         </dependency>
  77.     </dependencies>
  79.     <build>
  80.         <plugins>
  81.             <plugin>
  82.                 <groupId>org.springframework.boot</groupId>
  83.                 <artifactId>spring-boot-maven-plugin</artifactId>
  84.             </plugin>
  85.         </plugins>
  86.     </build>
  89. </project>

3.配置文件

  1. elasticsearch:
  2.   host: 127.0.0.1
  3.   port: 9200
  5. logging:
  6.   level:
  7.     com.adong.es: debug

4.主启动类

  1. @SpringBootApplication
  2. public class ElasticSearchMainApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(ElasticSearchMainApplication.class, args);
  5.     }
  7. }

5.配置类

  1. package com.adong.es.config;
  3. import lombok.Data;
  4. import org.apache.http.HttpHost;
  5. import org.elasticsearch.client.RestClient;
  6. import org.elasticsearch.client.RestClientBuilder;
  7. import org.elasticsearch.client.RestHighLevelClient;
  8. import org.springframework.boot.context.properties.ConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.stereotype.Component;
  13. @Configuration
  14. @ConfigurationProperties(prefix = "elasticsearch") // 读取配置文件内容
  15. @Component
  16. @Data //安装Lombok插件
  17. public class ElasticSearchConfig {
  19.     private String host;
  20.     private Integer port;
  22.     @Bean
  23.     public RestHighLevelClient client() {
  24.         RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
  25.         RestHighLevelClient restHighLevelClient = new RestHighLevelClient(builder);
  26.         return restHighLevelClient;
  27.     }
  29. }

【索引库操作】

索引库操作
目标：使用ElasticSearch的高阶客户端，编写Java代码，操作索引库
分析：Java high level客户端的操作，是通过发送RESTful接口调用的方式处理请求。

  1. package com.adong.es.test;
  3. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  4. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  5. import org.elasticsearch.client.RequestOptions;
  6. import org.elasticsearch.client.RestHighLevelClient;
  7. import org.elasticsearch.client.indices.CreateIndexRequest;
  8. import org.elasticsearch.client.indices.CreateIndexResponse;
  9. import org.elasticsearch.client.indices.GetIndexRequest;
  10. import org.elasticsearch.client.indices.GetIndexResponse;
  11. import org.junit.Test;
  12. import org.junit.runner.RunWith;
  13. import org.springframework.boot.test.context.SpringBootTest;
  14. import org.springframework.test.context.junit4.SpringRunner;
  17. import javax.annotation.Resource;
  18. import java.io.IOException;
  20. @RunWith(SpringRunner.class)
  21. @SpringBootTest
  22. public class IndexTest {
  24.     //@Autowired
  25.     @Resource
  26.     private RestHighLevelClient client;
  28.     /**
  29.      * 目标：创建索引库
  30.      * 1.创建请求对象 设置索引库name
  31.      * 2.客户端发送请求，获取响应对象
  32.      * 3.打印响应对象中的返回结果
  33.      * 4.关闭客户端，释放连接资源
  34.      */
  35.     @Test
  36.     public void create() throws IOException {
  37.         //1.创建请求对象，创建索引的请求
  38.         CreateIndexRequest request = new CreateIndexRequest("shopping");
  39.         //2.客户端发送请求，获取响应对象
  40.         CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
  41.         //3.打印响应对象中的返回结果
  42.         //返回index信息
  43.         System.out.println("index:" + response.index());
  44.         //acknowledged代表创建成功
  45.         System.out.println("acknowledged:" + response.isAcknowledged());
  46.         //4.关闭客户端，释放连接资源
  47.         client.close();
  48.     }
  51.     //查看索引库
  52.     @Test
  53.     public void getIndex() throws IOException {
  54.         //1.创建请求对象：查询索引库
  55.         GetIndexRequest request = new GetIndexRequest("shopping");
  56.         //2.客户端执行请求发送，返回响应对象
  57.         GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
  58.         //3.打印结果信息
  59.         System.out.println("aliases:" + response.getAliases());
  60.         System.out.println("mappings:" + response.getMappings());
  61.         System.out.println("settings:" + response.getSettings());
  62.         //4.关闭客户端，释放连接资源
  63.         client.close();
  64.     }
  66.     //删除索引库
  67.     @Test
  68.     public void deleteIndex() throws IOException {
  69.         //1.创建请求对象
  70.         DeleteIndexRequest request = new DeleteIndexRequest("shopping");
  71.         //2.客户端发送请求，获取响应对象
  72.         AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
  73.         //3.打印结果信息
  74.         System.out.println("ack:" + response.isAcknowledged());
  75.         //4.关闭客户端，释放连接资源
  76.         client.close();
  77.     }
  79. }

【配置映射】

RestHighLevelClient配置映射，与kibana略有区别。在客户端中配置映射，不支持设置类型type。不设置type，并不代表没有，而是默认的type为_doc。
映射操作：
1.配置映射，一共2种方式：
第一种：使用XContentBuilder,构建请求体
第二种：使用JSON字符串
2.查看映射配置

  1. package com.adong.es.test;
  3. import org.elasticsearch.action.support.master.AcknowledgedResponse;
  4. import org.elasticsearch.client.RequestOptions;
  5. import org.elasticsearch.client.RestHighLevelClient;
  6. import org.elasticsearch.client.indices.GetMappingsRequest;
  7. import org.elasticsearch.client.indices.GetMappingsResponse;
  8. import org.elasticsearch.client.indices.PutMappingRequest;
  9. import org.elasticsearch.common.xcontent.XContentBuilder;
  10. import org.elasticsearch.common.xcontent.XContentFactory;
  11. import org.elasticsearch.common.xcontent.XContentType;
  12. import org.junit.Test;
  13. import org.junit.runner.RunWith;
  14. import org.springframework.boot.test.context.SpringBootTest;
  15. import org.springframework.test.context.junit4.SpringRunner;
  17. import javax.annotation.Resource;
  18. import java.io.IOException;
  20. @RunWith(SpringRunner.class)
  21. @SpringBootTest
  22. public class MappingTest {
  24.     @Resource
  25.     private RestHighLevelClient client;
  27.     /**
  28.      * 目标：配置映射。第一种方式，使用XContentBuilder,构建请求体
  29.      * 1.创建请求对象：配置映射
  30.      * 设置索引库name
  31.      * 设置配置映射请求体
  32.      * 2.客户端发送请求，获取响应对象
  33.      * 3.打印响应结果
  34.      */
  35.     @Test
  36.     public void putMapping01() throws IOException {
  39.         //1.创建请求对象：配置映射
  40.         PutMappingRequest request = new PutMappingRequest("shopping01");
  41.         //构建请求体
  42.         XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
  43.         jsonBuilder
  44.                 .startObject()
  45.                     .startObject("properties")
  46.                         .startObject("title")
  47.                             .field("type", "text")
  48.                             .field("analyzer", "ik_max_word")
  49.                         .endObject()
  50.                         .startObject("subtitle")
  51.                             .field("type", "text")
  52.                             .field("analyzer", "ik_max_word")
  53.                         .endObject()
  54.                         .startObject("images")
  55.                             .field("type", "keyword")
  56.                             .field("index", false)
  57.                         .endObject()
  58.                         .startObject("price")
  59.                             .field("type", "float")
  60.                         .endObject()
  61.                     .endObject()
  62.                 .endObject();
  63.         //设置请求体，source("请求体json构建器对象");
  64.         request.source(jsonBuilder);
  65.         //2.客户端发送请求，获取响应对象
  66.         AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
  68.         //3.打印响应结果
  69.         System.out.println("acknowledged：：" + response.isAcknowledged());
  70.     }
  72.     /**
  73.      * 目标：配置映射。第二种方式，使用JSON字符串
  74.      * 1.创建请求对象：配置映射
  75.      * 设置索引库name
  76.      * 设置配置映射请求体
  77.      * 2.客户端发送请求，获取响应对象
  78.      * 3.打印响应结果
  79.      */
  80.     @Test
  81.     public void putMapping02() throws IOException {
  82.         //1.创建请求对象：配置映射
  83.         PutMappingRequest request = new PutMappingRequest("shopping02");
  84.         //设置请求体，source("请求体json字符串"，"请求体的数据类型");
  87.         String s = "{\"properties\":{\"title\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"subtitle\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"price\":{\"type\":\"float\"},\"images\":{\"type\":\"keyword\",\"index\":false}}}";
  89.         request.source(s, XContentType.JSON);
  90.         //2.客户端发送请求，获取响应对象
  91.         AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
  92.         //3.打印响应结果
  93.         System.out.println("acknowledged::" + response.isAcknowledged());
  94.     }
  96.     /**
  97.      * 查看映射
  98.      * 1.创建请求对象：查看映射
  99.      * 设置索引库name
  100.      * 2.客户端发送请求，获取响应对象
  101.      * 3.打印响应结果
  102.      */
  103.     @Test
  104.     public void getMapping() throws IOException {
  105.         //1.创建请求对象：查看映射
  106.         GetMappingsRequest request = new GetMappingsRequest();
  107.         //设置索引库name
  108.         request.indices("shopping01");
  109.         //2.客户端发送请求，获取响应对象
  110.         GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT);
  111.         //3.打印响应结果
  112.         System.out.println("mappings::" + response.mappings());
  113.         System.out.println("Source::" + response.mappings().get("shopping01").getSourceAsMap());
  114.     }
  116. }

【文档操作】

创建Bean对象 :

  1. package com.adong.es.entities;
  3. import lombok.*;
  5. @Data
  6. @NoArgsConstructor
  7. @AllArgsConstructor
  8. @ToString
  9. @Builder
  10. public class Product {
  11.     private Long id;//商品唯一标识
  12.     private String title;//商品名称
  13.     private Double price;//商品价格
  14.     private String images;//图片地址
  15. }

测试类 : 

  1. package com.adong.es.test;
  3. import com.adong.es.entities.Product;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import org.elasticsearch.action.bulk.BulkRequest;
  6. import org.elasticsearch.action.bulk.BulkResponse;
  7. import org.elasticsearch.action.delete.DeleteRequest;
  8. import org.elasticsearch.action.delete.DeleteResponse;
  9. import org.elasticsearch.action.get.GetRequest;
  10. import org.elasticsearch.action.get.GetResponse;
  11. import org.elasticsearch.action.index.IndexRequest;
  12. import org.elasticsearch.action.index.IndexResponse;
  13. import org.elasticsearch.action.update.UpdateRequest;
  14. import org.elasticsearch.action.update.UpdateResponse;
  15. import org.elasticsearch.client.RequestOptions;
  16. import org.elasticsearch.client.RestHighLevelClient;
  17. import org.elasticsearch.common.xcontent.XContentType;
  18. import org.junit.Test;
  19. import org.junit.runner.RunWith;
  20. import org.springframework.boot.test.context.SpringBootTest;
  21. import org.springframework.test.context.junit4.SpringRunner;
  23. import javax.annotation.Resource;
  24. import java.io.IOException;
  26. /**
  27.  * 目标：文档的操作
  28.  * 1.新增文档
  29.  * 2.修改
  30.  * 3.根据id查询文档
  31.  * 4.删除
  32.  * 5.批量
  33.  */
  34. @RunWith(SpringRunner.class)
  35. @SpringBootTest
  36. public class DocumentTest {
  38.     @Resource
  39.     private RestHighLevelClient client;
  41.     //新增文档
  42.     @Test
  43.     public void saveDoc() throws IOException {
  44.         //1.创建请求对象(创建索引库CreateIndexRequest)，索引库名称、类型名称、主键id
  45.         IndexRequest request = new IndexRequest().index("shopping01").type("_doc").id("2");
  47.         //方式1：写一个Product对象将对象转为json字符串
  48.         Product product = Product.builder().id(1L).title("小米手机").price(1999.0).build();
  49.         ObjectMapper objectMapper = new ObjectMapper();
  50.         String productJson = objectMapper.writeValueAsString(product);
  51.         request.source(productJson, XContentType.JSON);
  53.         //方式2：直接在source中写入key-value参数
  54.         //request.source(XContentType.JSON, "id", 2L,"title", "小米手机",  "price", "3999");
  56.         //2.客户端发送请求，获取响应对象
  57.         IndexResponse response = client.index(request, RequestOptions.DEFAULT);
  58.         //3.打印结果信息
  59.         System.out.println("_index:" + response.getIndex());
  60.         System.out.println("_type:" + response.getType());
  61.         System.out.println("_id:" + response.getId());
  62.         System.out.println("_result:" + response.getResult());
  63.     }
  65.     //修改文档,不是覆盖修改
  66.     @Test
  67.     public void update() throws IOException {
  68.         //1.创建请求对象(创建索引库CreateIndexRequest)，索引库名称、类型名称、主键id
  69.         UpdateRequest request = new UpdateRequest().index("shopping01").type("_doc").id("2");
  70.         //设置请求体
  71.         request.doc(XContentType.JSON, "id", "2", "title", "小米手机", "price", "2999");
  73.         //2.客户端发送请求，获取响应对象
  74.         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
  75.         ////3.打印结果信息
  76.         System.out.println("_index:" + response.getIndex());
  77.         System.out.println("_type:" + response.getType());
  78.         System.out.println("_id:" + response.getId());
  79.         System.out.println("_result:" + response.getResult());
  80.     }
  82.     //查询文档
  83.     @Test
  84.     public void getDoc() throws IOException {
  85.         //1.创建请求对象
  86.         GetRequest request = new GetRequest().index("shopping01").type("_doc").id("2");
  87.         //2.客户端发送请求，获取响应对象
  88.         GetResponse response = client.get(request, RequestOptions.DEFAULT);
  89.         ////3.打印结果信息
  90.         System.out.println("_index:" + response.getIndex());
  91.         System.out.println("_type:" + response.getType());
  92.         System.out.println("_id:" + response.getId());
  93.         System.out.println("source:" + response.getSourceAsString());
  94.     }
  96.     //删除文档
  97.     @Test
  98.     public void deleteDoc() throws IOException {
  99.         //创建请求对象
  100.         DeleteRequest request = new DeleteRequest().index("shopping01").type("_doc").id("1");
  101.         //客户端发送请求，获取响应对象
  102.         DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
  103.         //打印信息
  104.         System.out.println(response.toString());
  105.     }
  107.     //批量新增操作
  108.     @Test
  109.     public void bulkSave() throws IOException {
  110.         //创建请求对象
  111.         BulkRequest request = new BulkRequest();
  112.         request.add(new IndexRequest().index("shopping01").type("_doc").id("1").source(XContentType.JSON, "title", "小米手机"));
  113.         request.add(new IndexRequest().index("shopping01").type("_doc").id("2").source(XContentType.JSON, "title", "苹果手机"));
  114.         request.add(new IndexRequest().index("shopping01").type("_doc").id("3").source(XContentType.JSON, "title", "华为手机"));
  115.         //客户端发送请求，获取响应对象
  116.         BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
  117.         //打印结果信息
  118.         System.out.println("took:" + responses.getTook());
  119.         System.out.println("items:" + responses.getItems());
  120.     }
  122.     //批量删除操作
  123.     @Test
  124.     public void bulkDelete() throws IOException {
  125.         //创建请求对象
  126.         BulkRequest request = new BulkRequest();
  127.         request.add(new DeleteRequest().index("shopping01").type("_doc").id("1"));
  128.         request.add(new DeleteRequest().index("shopping01").type("_doc").id("2"));
  129.         request.add(new DeleteRequest().index("shopping01").type("_doc").id("3"));
  130.         //客户端发送请求，获取响应对象
  131.         BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
  132.         //打印结果信息
  133.         System.out.println("took:" + responses.getTook());
  134.         System.out.println("items:" + responses.getItems());
  135.     }
  137. }

【请求体查询】

  1. package com.adong.es.test;
  4. import org.elasticsearch.action.bulk.BulkRequest;
  5. import org.elasticsearch.action.bulk.BulkResponse;
  6. import org.elasticsearch.action.index.IndexRequest;
  7. import org.elasticsearch.action.search.SearchRequest;
  8. import org.elasticsearch.action.search.SearchResponse;
  9. import org.elasticsearch.client.RequestOptions;
  10. import org.elasticsearch.client.RestHighLevelClient;
  11. import org.elasticsearch.common.unit.Fuzziness;
  12. import org.elasticsearch.common.xcontent.XContentType;
  13. import org.elasticsearch.index.query.BoolQueryBuilder;
  14. import org.elasticsearch.index.query.QueryBuilders;
  15. import org.elasticsearch.search.SearchHit;
  16. import org.elasticsearch.search.SearchHits;
  17. import org.elasticsearch.search.builder.SearchSourceBuilder;
  18. import org.elasticsearch.search.sort.SortOrder;
  19. import org.junit.Test;
  20. import org.junit.runner.RunWith;
  21. import org.springframework.boot.test.context.SpringBootTest;
  22. import org.springframework.test.context.junit4.SpringRunner;
  24. import javax.annotation.Resource;
  25. import java.io.IOException;
  27. @RunWith(SpringRunner.class)
  28. @SpringBootTest
  29. public class RequestBodyTest {
  31.     @Resource
  32.     private RestHighLevelClient client;
  34.     /**
  35.      * 初始化查询数据
  36.      */
  37.     @Test
  38.     public void initData() throws IOException {
  39.         //批量新增操作
  40.         BulkRequest request = new BulkRequest();
  41.         request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "小米手机", "images", "http://www.gulixueyuan.com/xm.jpg", "price", 1999.0));
  42.         request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "小米电视", "images", "http://www.gulixueyuan.com/xmds.jpg", "price", 2999.0));
  43.         request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "华为手机", "images", "http://www.gulixueyuan.com/hw.jpg", "price", 4999.0, "subtitle", "小米"));
  44.         request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "apple手机", "images", "http://www.gulixueyuan.com/appletl.jpg", "price", 5999.00));
  45.         request.add(new IndexRequest().type("_doc").index("shopping01").source(XContentType.JSON, "title", "apple", "images", "http://www.gulixueyuan.com/apple.jpg", "price", 3999.00));
  46.         BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
  47.         System.out.println("took::" + response.getTook());
  48.         System.out.println("Items::" + response.getItems());
  49.     }
  51.     //请求体查询-基本查询
  52.     //1.创建请求对象
  53.     //2.客户端发送请求，获取响应对象
  54.     //3.打印结果信息
  55.     @Test
  56.     public void basicQuery() throws IOException {
  57.         //1.创建请求对象
  58.         SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
  59.         //构建查询的请求体
  60.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  61.         //查询所有
  62.         //sourceBuilder.query(QueryBuilders.matchAllQuery());//
  63.         //match查询，带分词器的查询
  64.         //sourceBuilder.query(QueryBuilders.matchQuery("title","小米手机").operator(Operator.AND));
  65.         //term查询：不带分词器，查询条件作为关键词
  66.         sourceBuilder.query(QueryBuilders.termQuery("price", "1999"));
  67.         //TODO ...multi_match：多个字段的match查询
  68.         //TODO ...terms查询：多个关键词去匹配
  69.         request.source(sourceBuilder);
  70.         //2.客户端发送请求，获取响应对象
  71.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  72.         //3.打印结果信息
  73.         printResult(response);
  74.     }
  76.     /**
  77.      * 打印结果信息
  78.      */
  79.     private void printResult(SearchResponse response) {
  80.         SearchHits hits = response.getHits();
  81.         System.out.println("took:" + response.getTook());
  82.         System.out.println("timeout:" + response.isTimedOut());
  83.         System.out.println("total:" + hits.getTotalHits());
  84.         System.out.println("MaxScore:" + hits.getMaxScore());
  85.         System.out.println("hits========>>");
  86.         for (SearchHit hit : hits) {
  87.             //输出每条查询的结果信息
  88.             System.out.println(hit.getSourceAsString());
  89.         }
  90.         System.out.println("<<========");
  91.     }
  93.     /**
  94.      * 目标：查询的字段过滤，分页，排序
  95.      *
  96.      * @throws IOException
  97.      */
  98.     @Test
  99.     public void fetchSourceAndSortAndByPage() throws IOException {
  100.         //1.创建请求对象
  101.         SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
  102.         //构建查询的请求体
  103.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  104.         //查询所有
  105.         sourceBuilder.query(QueryBuilders.matchAllQuery());
  107.         //分页信息
  108.         //当前页其实索引(第一条数据的顺序号)，from
  109.         sourceBuilder.from(2);
  110.         //每页显示多少条size
  111.         sourceBuilder.size(2);
  113.         //排序信息,参数一：排序的字段，参数二：顺序ASC升序，降序DESC
  114.         sourceBuilder.sort("price", SortOrder.ASC);
  116.         //查询字段过滤
  117.         String[] excludes = {};
  118.         String[] includes = {"title", "subtitle", "price"};
  119.         sourceBuilder.fetchSource(includes, excludes);
  121.         request.source(sourceBuilder);
  122.         //2.客户端发送请求，获取响应对象
  123.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  124.         //3.打印结果信息
  125.         printResult(response);
  126.     }
  128.     /**
  129.      * 高级查询
  130.      */
  131.     @Test
  132.     public void boolAndRangeAndFuzzyQuery() throws IOException {
  133.         //1.创建请求对象
  134.         SearchRequest request = new SearchRequest().indices("shopping01").types("_doc");
  135.         //构建查询的请求体
  136.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  137.         //高级查询的三种方式：
  138.         //-----------------------------------------------------------------------------
  139. //        //bool查询：查询title中必须包含小米，一定不含有电视，应该含有手机的所有商品
  140.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  141. //        //must
  142. //        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
  143. //        //must not
  144. //        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
  145. //        //should
  146. //        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
  147. //        sourceBuilder.query(boolQueryBuilder);
  148.         //-----------------------------------------------------------------------------
  149.         //范围查询：查询价格大于3千，小于5千的所有商品
  150. //        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
  151. //        //#### gt 大于(greater than)
  152. //        rangeQuery.gt("3000");
  153. //        //#### lt 小于(less than)
  154. //        rangeQuery.lt("5000");
  155. //        //#### gte 大于等于(greater than equals)
  156. //        //#### lte 小于等于(less than equals)
  157. //        sourceBuilder.query(rangeQuery);
  158.         //-----------------------------------------------------------------------------
  159.         //模糊查询：查询包含apple关键词的所有商品，完成模糊查询cpple
  160.         sourceBuilder.query(QueryBuilders.fuzzyQuery("title", "cpple").fuzziness(Fuzziness.ONE));
  161.         //-----------------------------------------------------------------------------
  163.         request.source(sourceBuilder);
  164.         //2.客户端发送请求，获取响应对象
  165.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  166.         //3.打印结果信息
  167.         printResult(response);
  168.     }
  170. }

【高亮查询】

  1. package com.adong.es.test;
  4. import org.elasticsearch.action.search.SearchRequest;
  5. import org.elasticsearch.action.search.SearchResponse;
  6. import org.elasticsearch.client.RequestOptions;
  7. import org.elasticsearch.client.RestHighLevelClient;
  8. import org.elasticsearch.index.query.QueryBuilders;
  9. import org.elasticsearch.index.query.TermsQueryBuilder;
  10. import org.elasticsearch.search.SearchHit;
  11. import org.elasticsearch.search.SearchHits;
  12. import org.elasticsearch.search.builder.SearchSourceBuilder;
  13. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  14. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
  15. import org.junit.Test;
  16. import org.junit.runner.RunWith;
  17. import org.springframework.boot.test.context.SpringBootTest;
  18. import org.springframework.test.context.junit4.SpringRunner;
  20. import javax.annotation.Resource;
  21. import java.io.IOException;
  22. import java.util.Map;
  24. @RunWith(SpringRunner.class)
  25. @SpringBootTest
  26. public class HighLightTest {
  28.     @Resource
  29.     private RestHighLevelClient client;
  31.     /**
  32.      * 高亮查询，对查询关键词进行高亮
  33.      * 1.创建请求对象：高亮查询
  34.      * 设置索引库name
  35.      * 设置类型type
  36.      * 2.创建查询请求体构建器
  37.      * 设置请求体
  38.      * 3.客户端发送请求，获取响应对象
  39.      * 4.打印响应结果
  40.      */
  41.     @Test
  42.     public void highLighterQuery() throws IOException {
  43.         //1.创建请求对象
  44.         SearchRequest request = new SearchRequest().types("_doc").indices("shopping01");
  45.         //2.创建查询请求体构建器
  46.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  47.         //构建查询方式：高亮查询
  48.         TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("title", "apple");
  49.         //设置查询方式
  50.         sourceBuilder.query(termsQueryBuilder);
  51.         //构建高亮字段
  52.         HighlightBuilder highlightBuilder = new HighlightBuilder();
  53.         highlightBuilder.preTags("<font color='red'>");//设置标签前缀
  54.         highlightBuilder.postTags("</font>");//设置标签后缀
  55.         highlightBuilder.field("title");//设置高亮字段
  56.         //设置高亮构建对象
  57.         sourceBuilder.highlighter(highlightBuilder);
  58.         //设置请求体
  59.         request.source(sourceBuilder);
  60.         //3.客户端发送请求，获取响应对象
  61.         SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  63.         //4.打印响应结果
  64.         SearchHits hits = response.getHits();
  65.         System.out.println("took::" + response.getTook());
  66.         System.out.println("time_out::" + response.isTimedOut());
  67.         System.out.println("total::" + hits.getTotalHits());
  68.         System.out.println("max_score::" + hits.getMaxScore());
  69.         System.out.println("hits::::>>");
  70.         for (SearchHit hit : hits) {
  71.             String sourceAsString = hit.getSourceAsString();
  72.             System.out.println(sourceAsString);
  73.             //打印高亮结果
  74.             Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  75.             System.out.println(highlightFields);
  76.         }
  77.         System.out.println("<<::::");
  78.     }
  79. }