es 集群 shards es集群至少要几个节点

01.集群简介

单点的问题

• 单台服务器，往往都有最大的负载能力，超过这个阈值，服务器性能就会大大降低甚至不可用。
• 单点的elasticsearch也是一样，那单点的es服务器存在哪些可能出现的问题呢？

• 单台机器存储容量有限
• 单服务器容易出现单点故障，无法实现高可用
• 单服务的并发处理能力有限

• 所以，为了应对这些问题，我们需要对elasticsearch搭建集群
• 集群中节点数量没有限制，大于等于2个节点就可以看做是集群了。
• 一般出于高性能及高可用方面来考虑集群中节点数量都是3个以上。

相关概念

• 集群 cluster

• 一个集群就是由一个或多个节点组织在一起，它们共同持有整个的数据，并一起提供索引和搜索功能。
• 一个集群由一个唯一的名字标识，这个名字默认就是“Elasticsearch”。
• 这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群

• 节点 node

• 一个节点是集群中的一个服务，作为集群的一部分，它存储数据，参与集群的索引和搜索功能。
• 和集群类似，一个节点也是由一个名字来标识的。
• 这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务对应于Elasticsearch集群中的哪些节点。
• 一个节点可以通过配置集群名称的方式来加入一个指定的集群。
• 默认情况下，每个节点都会被安排加入到一个叫做“Elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“Elasticsearch”的集群中。
• 在一个集群里，只要你想，可以拥有任意多个节点。

• 分片和复制 shards&replicas(副本)

• 为了解决索引占用空间过大(1TB以上)这个问题，Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。
• 当你创建一个索引的时候，你可以指定你想要的分片的数量。
• 为了提高分片高可用，Elasticsearch允许创建分片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。
• 默认情况下，Elasticsearch中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片（1个完全拷贝），这样的话每个索引总共就有10个分片。
• ElasticSearch7.x之后，如果不指定索引分片，默认会创建1个分片

02.搭建ES集群

实现步骤

• Elasticsearch-cluster文件夹
• 将Elasticsearch压缩包解压到该文件夹并复制两份（共三份），分别命名为node1，node2，node3，如果有data目录记得删掉
• 分别配置config\elasticsearch.yml文件，将以下代码分别加在该配置文件的末尾，注意编码为UTF-8

node1节点：

#节点1的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-1
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9201
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9301
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

node2节点

#节点2的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-2
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9202
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9302
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

node3节点：

#节点3的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-3
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9203
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9303
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

启动各个节点服务器

• 分别点击每个节点下的elasticsearch.bat

03.整合到SpringBoot

what：是什么

• Spring Boot集成Elasticsearch的时候，我们需要引入高阶客户端

• elasticsearch-rest-high-level-client
• elasticsearch-rest-client
• elasticsearch

• 来操作Elasticsearch，在引入起步依赖的时候，需要严格注意Elasticsearch和起步依赖的版本关系，否则在使用过程中会出很多问题

搭建步骤：

• 创建SpringBoot的项目，勾选starter配置
• 配置Maven依赖坐标
• 将ElasticSearch的客户端对象，注入Spring的容器
• 配置ElasticSearch，服务地址，端口号

搭建过程：

• 创建SpringBoot的项目，勾选starter配置：勾选starter，开发者工具、Lombok、配置文件映射处理器
• 配置Maven依赖坐标

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--elasticsearch的高级别rest客户端-->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>6.8.0</version>
    </dependency>
    <!--elasticsearch的rest客户端-->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-client</artifactId>
        <version>6.8.0</version>
    </dependency>
    <!--elasticsearch的核心jar包-->
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>6.8.0</version>
    </dependency>
</dependencies>

• 创建ElasticSearchConfig类：将ElasticSearch的客户端对象，注入Spring的容器

package com.lxgzhw.config;

import lombok.Data;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
@ConfigurationProperties(prefix = "elasticsearch")
@Component
@Data
public class ElasticSearchConfig {

    private String host;
    private Integer port;

    //初始化RestHighLevelClient
    @Bean(destroyMethod = "close")
    public RestHighLevelClient client() {
        //RestClient客户端构建器对象
        RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(host, port, "http"));
        //操作es的高级rest客户端对象
        RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);
        return restHighLevelClient;
    }
    //getter ,setter,toString..省略
}

修改配置文件：配置ElasticSearch，服务地址，端口号

# es服务地址
elasticsearch.host=127.0.0.1
# es服务端口
elasticsearch.port=9201
# 配置日志级别,开启debug日志
logging.level.com.lxgzhw=debug

04.新增索引库

目标：使用ElasticSearch的高阶客户端，编写Java代码，创建索引库

分析：

• Java high level客户端的操作，是模仿我们通过发送请求调用RESTful接口调用的方式，本质还是请求获取响应。
• 创建测试类：Demo01IndexOperationTests

package com.lxgzhw;

import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class Demo01IndexOperationTests {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：创建索引库
     * 1.创建请求对象
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应对象中的返回结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void create() throws IOException {
        //1.创建请求对象，创建索引的请求
        CreateIndexRequest request = new CreateIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        //3.打印响应对象中的返回结果
        //返回index信息
        System.out.println("index:" + response.index());
        //acknowledged代表创建成功
        System.out.println("acknowledged:" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }

}

• 发送请求中，传入请求对象的同时还设置了一个RequestOptions对象的静态成员变量DEFAULT。其含义是，配置当前请求选项为默认值。
• 其中RequestOptions对象的作用是用来配置请求，主要配置项目有请求头，缓冲区大小(默认100M)，异常处理器(warningsHandler)。默认情况下，缓冲区大小100MB，请求头及异常处理器为空。

05.查看索引库

package com.lxgzhw;

import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class Demo01IndexOperationTests {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：创建索引库
     * 1.创建请求对象
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应对象中的返回结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void create() throws IOException {
        //1.创建请求对象，创建索引的请求
        CreateIndexRequest request = new CreateIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        //3.打印响应对象中的返回结果
        //返回index信息
        System.out.println("index:" + response.index());
        //acknowledged代表创建成功
        System.out.println("acknowledged:" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }

    /**
     * 查询索引
     * 1.创建请求对象：查看索引库
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void getIndex() throws IOException {
        //1.创建请求对象：查看索引库
        GetIndexRequest request = new GetIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("aliases: " + response.getAliases());
        System.out.println("settings: " + response.getSettings());
        System.out.println("mappings: " + response.getMappings());
        //4.关闭客户端，释放连接资源
        client.close();
    }

}

06.删除索引库

package com.lxgzhw;

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class Demo01IndexOperationTests {

    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：创建索引库
     * 1.创建请求对象
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应对象中的返回结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void create() throws IOException {
        //1.创建请求对象，创建索引的请求
        CreateIndexRequest request = new CreateIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        //3.打印响应对象中的返回结果
        //返回index信息
        System.out.println("index:" + response.index());
        //acknowledged代表创建成功
        System.out.println("acknowledged:" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }

    /**
     * 查询索引
     * 1.创建请求对象：查看索引库
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void getIndex() throws IOException {
        //1.创建请求对象：查看索引库
        GetIndexRequest request = new GetIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("aliases: " + response.getAliases());
        System.out.println("settings: " + response.getSettings());
        System.out.println("mappings: " + response.getMappings());
        //4.关闭客户端，释放连接资源
        client.close();
    }

    /**
     * 删除索引
     * 1.创建请求对象：删除索引库
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     * 4.关闭客户端，释放连接资源
     */
    @Test
    public void delete() throws IOException {
        //1.创建请求对象：删除索引库
        DeleteIndexRequest request = new DeleteIndexRequest("lxgzhw");
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged：：" + response.isAcknowledged());
        //4.关闭客户端，释放连接资源
        client.close();
    }
}

07.配置映射

创建测试类：Demo02MappingOperation

• RestHighLevelClient配置映射，与kibana略有区别。
• 在客户端中配置映射，不支持设置类型type。
• 不设置type，并不代表没有，而是默认的type为_doc。
• 注意：记得先执行一下之前的创建索引操作，否则会不存在报错

package com.lxgzhw;

import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo02MappingOperation {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：配置映射。第一种方式，使用XContentBuilder,构建请求体
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMappingMethodOne() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("lxgzhw");
        //构建请求体
        XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
        jsonBuilder.startObject()
                .startObject("properties")
                .startObject("title")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("subtitle")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("category")
                .field("type", "keyword")
                .endObject()
                .startObject("brand")
                .field("type", "keyword")
                .endObject()
                .startObject("images")
                .field("type", "keyword").field("index", false)
                .endObject()
                .startObject("price")
                .field("type", "float")
                .endObject()
                .endObject()
                .endObject();
        //设置请求体，source("请求体json构建器对象");
        request.source(jsonBuilder);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged：：" + response.isAcknowledged());
    }

    /**
     * 目标：配置映射。第二种方式，使用JSON字符串
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMappingMethodTwo() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("lxgzhw");
        //设置请求体，source("请求体json字符串"，"请求体的数据类型");
        request.source("{\"properties\":{\"title\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"subtitle\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"category\":{\"type\":\"keyword\"},\"brand\":{\"type\":\"keyword\"},\"price\":{\"type\":\"float\"},\"images\":{\"type\":\"keyword\",\"index\":false}}}", XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged::" + response.isAcknowledged());
    }
}

08.查看映射

package com.lxgzhw;

import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.GetMappingsResponse;
import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo02MappingOperation {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：配置映射。第一种方式，使用XContentBuilder,构建请求体
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMappingMethodOne() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("lxgzhw");
        //构建请求体
        XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
        jsonBuilder.startObject()
                .startObject("properties")
                .startObject("title")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("subtitle")
                .field("type", "text").field("analyzer", "ik_max_word")
                .endObject()
                .startObject("category")
                .field("type", "keyword")
                .endObject()
                .startObject("brand")
                .field("type", "keyword")
                .endObject()
                .startObject("images")
                .field("type", "keyword").field("index", false)
                .endObject()
                .startObject("price")
                .field("type", "float")
                .endObject()
                .endObject()
                .endObject();
        //设置请求体，source("请求体json构建器对象");
        request.source(jsonBuilder);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged：：" + response.isAcknowledged());
    }

    /**
     * 目标：配置映射。第二种方式，使用JSON字符串
     * 1.创建请求对象：配置映射
     * 设置索引库name
     * 设置配置映射请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void putMappingMethodTwo() throws IOException {
        //1.创建请求对象：配置映射
        PutMappingRequest request = new PutMappingRequest("lxgzhw");
        //设置请求体，source("请求体json字符串"，"请求体的数据类型");
        request.source("{\"properties\":{\"title\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"subtitle\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"category\":{\"type\":\"keyword\"},\"brand\":{\"type\":\"keyword\"},\"price\":{\"type\":\"float\"},\"images\":{\"type\":\"keyword\",\"index\":false}}}", XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        AcknowledgedResponse response = client.indices().putMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("acknowledged::" + response.isAcknowledged());
    }

    /**
     * 查看映射
     * 1.创建请求对象：查看映射
     * 设置索引库name
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void getMapping() throws IOException {
        //1.创建请求对象：查看映射
        GetMappingsRequest request = new GetMappingsRequest();
        //设置索引库name
        request.indices("lxgzhw");
        //2.客户端发送请求，获取响应对象
        GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("mappings::" + response.mappings());
        System.out.println("Source::" + response.mappings().get("lxgzhw").getSourceAsMap());
    }
}

09.创建文档

创建实体类：Goods.java

package com.lxgzhw.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Goods {
    private Long id;//商品的唯一标识
    private String title;//标题
    private String subtitle;//子标题
    private String category;//分类
    private String brand;//品牌
    private Double price;//价格
    private String images;//图片地址
    //...getter , setter , toString
}

创建测试类：Demo03DocumentOperationTests

package com.lxgzhw;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.lxgzhw.pojo.Goods;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo03DocumentOperationTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：新增文档
     * 1.创建请求对象：新增文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，不设置随机生成
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void createDoc() throws IOException {
        //1.创建请求对象：新增文档
        IndexRequest request = new IndexRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "小米手机", "小米", "手机", "小米", 19999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.source(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }
}

10.修改文档

主键id相同，修改数据

package com.lxgzhw;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.lxgzhw.pojo.Goods;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo03DocumentOperationTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：新增文档
     * 1.创建请求对象：新增文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，不设置随机生成
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void createDoc() throws IOException {
        //1.创建请求对象：新增文档
        IndexRequest request = new IndexRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "小米手机", "小米", "手机", "小米", 19999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.source(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }

    /**
     * 修改文档
     * 1.创建请求对象：修改文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，必须设置
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void updateDoc() throws IOException {
        //1.创建请求对象：修改文档
        UpdateRequest request = new UpdateRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "大米手机", "炒米", "手机", "小米", 999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.doc(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }
}

11.根据id查询文档

package com.lxgzhw;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.lxgzhw.pojo.Goods;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo03DocumentOperationTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：新增文档
     * 1.创建请求对象：新增文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，不设置随机生成
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void createDoc() throws IOException {
        //1.创建请求对象：新增文档
        IndexRequest request = new IndexRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "小米手机", "小米", "手机", "小米", 19999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.source(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }

    /**
     * 修改文档
     * 1.创建请求对象：修改文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，必须设置
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void updateDoc() throws IOException {
        //1.创建请求对象：修改文档
        UpdateRequest request = new UpdateRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "大米手机", "炒米", "手机", "小米", 999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.doc(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }

    /**
     * 根据id查询文档
     * 1.创建请求对象：根据id查询文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void getDoc() throws IOException {
        //1.创建请求对象：根据id查询文档
        GetRequest request = new GetRequest();
        //设置索引库name
        request.index("lxgzhw");
        //设置类型type
        request.type("_doc");
        //设置主键id
        request.id("1");
        //2.客户端发送请求，获取响应对象
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("_source：：" + response.getSourceAsString());
    }
}

12.删除文档

package com.lxgzhw;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.lxgzhw.pojo.Goods;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo03DocumentOperationTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：新增文档
     * 1.创建请求对象：新增文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，不设置随机生成
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void createDoc() throws IOException {
        //1.创建请求对象：新增文档
        IndexRequest request = new IndexRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "小米手机", "小米", "手机", "小米", 19999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.source(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }

    /**
     * 修改文档
     * 1.创建请求对象：修改文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id，必须设置
     * 设置请求体
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void updateDoc() throws IOException {
        //1.创建请求对象：修改文档
        UpdateRequest request = new UpdateRequest();
        //设置索引库名称
        request.index("lxgzhw");
        //设置type类型
        request.type("_doc");
        //设置主键id
        request.id("1");
        //构造Goods对象
        Goods good = new Goods(1l, "大米手机", "炒米", "手机", "小米", 999.0, "http://image.leyou.com/12479122.jpg");
        //对象转json
        String goodJsonStr = new ObjectMapper().writeValueAsString(good);
        //设置请求体.source("json请求字符串","请求体的数据类型");
        request.doc(goodJsonStr, XContentType.JSON);
        //2.客户端发送请求，获取响应对象
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("result：：" + response.getResult());
    }

    /**
     * 根据id查询文档
     * 1.创建请求对象：根据id查询文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void getDoc() throws IOException {
        //1.创建请求对象：根据id查询文档
        GetRequest request = new GetRequest();
        //设置索引库name
        request.index("lxgzhw");
        //设置类型type
        request.type("_doc");
        //设置主键id
        request.id("1");
        //2.客户端发送请求，获取响应对象
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("_source：：" + response.getSourceAsString());
    }

    /**
     * 删除文档
     * 1.创建请求对象：删除文档
     * 设置索引库name
     * 设置类型type
     * 设置主键id
     * 2.客户端发送请求，获取响应对象
     * 3.打印响应结果
     */
    @Test
    public void deleteDoc() throws IOException {
        //1.创建请求对象：删除文档
        DeleteRequest request = new DeleteRequest();
        request.index("lxgzhw");
        request.id("1");
        request.type("_doc");
        //2.客户端发送请求，获取响应对象
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        //3.打印响应结果
        System.out.println("_index：：" + response.getIndex());
        System.out.println("_type：：" + response.getType());
        System.out.println("_id：：" + response.getId());
        System.out.println("_result：：" + response.getResult());
    }
}

13.批量操作bulk

创建测试类：Demo04BulkOperationTests.java

package com.lxgzhw;

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo04BulkOperationTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：批量新增
     * 1.创建请求对象：批量操作
     * 2.批量操作中设置多个新增对象IndexRequest
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void createDoc() throws IOException {
        //1.创建请求对象：批量操作
        BulkRequest request = new BulkRequest();
        //2.批量操作中设置多个新增对象IndexRequest
        IndexRequest addRequestOne = new IndexRequest().id("1").type("_doc").index("lxgzhw").source(XContentType.JSON, "id", 1L, "title", "大米手机", "category", "手机", "brand", "小米", "price", "2699.00", "images", "http://baidu.com");
        request.add(addRequestOne);
        IndexRequest addRequestTwo = new IndexRequest().id("2").type("_doc").index("lxgzhw").source(XContentType.JSON, "id", 2L, "title", "大米手机", "category", "手机", "brand", "小米", "price", "2699.00", "images", "http://baidu.com");
        request.add(addRequestTwo);
        //3.客户端发送请求，获取响应对象
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        System.out.println("took::" + response.getTook());
        System.out.println("Items::" + response.getItems());
    }

    /**
     * 目标：批量删除
     * 1.创建请求对象：批量删除
     * 2.批量操作中设置多个删除对象DeleteRequest
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void bulkDelete() throws IOException {
        //1.创建请求对象：批量删除
        BulkRequest request = new BulkRequest();
        //2.批量操作中设置多个删除对象DeleteRequest
        request.add(new DeleteRequest().id("1").type("_doc").index("lxgzhw"));
        request.add(new DeleteRequest().id("2").type("_doc").index("lxgzhw"));
        //3.客户端发送请求，获取响应对象
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        System.out.println("took::" + response.getTook());
        System.out.println("Items::" + response.getItems());
    }
}

14.模拟数据

创建测试类：InitDataTests.java

package com.lxgzhw;

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class InitDataTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 初始化查询数据
     */
    @Test
    public void initData() throws IOException {
        //批量新增操作
        BulkRequest request = new BulkRequest();
        request.add(new IndexRequest().type("_doc").index("lxgzhw").source(XContentType.JSON, "title", "大米手机", "images", "http://image.leyou.com/12479122.jpg", "price", 3288, "category", "手机", "brand", "小米"));
        request.add(new IndexRequest().type("_doc").index("lxgzhw").source(XContentType.JSON, "title", "小米手机", "images", "http://image.leyou.com/12479122.jpg", "price", 2699, "category", "手机", "brand", "小米"));
        request.add(new IndexRequest().type("_doc").index("lxgzhw").source(XContentType.JSON, "title", "小米电视4A", "images", "http://image.leyou.com/12479122.jpg", "price", 4288, "category", "手机", "brand", "小米"));
        request.add(new IndexRequest().type("_doc").index("lxgzhw").source(XContentType.JSON, "title", "华为手机", "images", "http://image.leyou.com/12479122.jpg", "price", 5288, "subtitle", "小米", "category", "手机", "brand", "小米"));
        request.add(new IndexRequest().type("_doc").index("lxgzhw").source(XContentType.JSON, "title", "apple手机", "images", "http://image.leyou.com/12479122.jpg", "price", 5899.00, "category", "手机", "brand", "小米"));
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println("took::" + response.getTook());
        System.out.println("Items::" + response.getItems());
    }
}

15.匹配查询(matchAll)

创建测试类：Demo05RequestBodyQueryBasicTests.java

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo05RequestBodyQueryBasicTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询所有
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchAllQuery() throws IOException {
        //1.创建请求对象：查询所有
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：matchAll
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }
}

16.匹配查询(match)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo05RequestBodyQueryBasicTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询所有
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchAllQuery() throws IOException {
        //1.创建请求对象：查询所有
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：matchAll
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 匹配查询，带分词器的查询
     * 分词后关键词之间的关系，or(默认)，and
     * 1.创建请求对象：匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchQuery() throws IOException {
        //1.创建请求对象：匹配查询
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //匹配查询，设置分词后关键词的查询关系，默认是or
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "小米手机")
                .operator(Operator.AND);
        sourceBuilder.query(matchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    //打印结果信息
    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }
}

17.匹配查询(multi_match)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo05RequestBodyQueryBasicTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询所有
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchAllQuery() throws IOException {
        //1.创建请求对象：查询所有
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：matchAll
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 匹配查询，带分词器的查询
     * 分词后关键词之间的关系，or(默认)，and
     * 1.创建请求对象：匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchQuery() throws IOException {
        //1.创建请求对象：匹配查询
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //匹配查询，设置分词后关键词的查询关系，默认是or
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "小米手机")
                .operator(Operator.AND);
        sourceBuilder.query(matchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    //打印结果信息
    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 多字段匹配查询，查询title和subtitle
     * 1.创建请求对象：多字段匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void mulitMatchQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：多字段匹配查询
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("小米", "title", "subtitle");
        sourceBuilder.query(multiMatchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }
}

18.关键词精确匹配查询(term)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo05RequestBodyQueryBasicTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询所有
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchAllQuery() throws IOException {
        //1.创建请求对象：查询所有
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：matchAll
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 匹配查询，带分词器的查询
     * 分词后关键词之间的关系，or(默认)，and
     * 1.创建请求对象：匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchQuery() throws IOException {
        //1.创建请求对象：匹配查询
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //匹配查询，设置分词后关键词的查询关系，默认是or
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "小米手机")
                .operator(Operator.AND);
        sourceBuilder.query(matchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    //打印结果信息
    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 多字段匹配查询，查询title和subtitle
     * 1.创建请求对象：多字段匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void mulitMatchQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：多字段匹配查询
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("小米", "title", "subtitle");
        sourceBuilder.query(multiMatchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    /**
     * 关键词精确查询
     * 1.创建请求对象：关键词精确查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void termQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：关键词精确查询
        sourceBuilder.query(QueryBuilders.termQuery("title", "小米"));
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }
}

19.多关键词精确匹配查询(terms)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo05RequestBodyQueryBasicTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询所有
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchAllQuery() throws IOException {
        //1.创建请求对象：查询所有
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：matchAll
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 匹配查询，带分词器的查询
     * 分词后关键词之间的关系，or(默认)，and
     * 1.创建请求对象：匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void matchQuery() throws IOException {
        //1.创建请求对象：匹配查询
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //匹配查询，设置分词后关键词的查询关系，默认是or
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "小米手机")
                .operator(Operator.AND);
        sourceBuilder.query(matchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    //打印结果信息
    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 多字段匹配查询，查询title和subtitle
     * 1.创建请求对象：多字段匹配查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void mulitMatchQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：多字段匹配查询
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("小米", "title", "subtitle");
        sourceBuilder.query(multiMatchQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    /**
     * 关键词精确查询
     * 1.创建请求对象：关键词精确查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void termQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：关键词精确查询
        sourceBuilder.query(QueryBuilders.termQuery("title", "小米"));
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    /**
     * 多关键词精确查询
     * 1.创建请求对象：多关键词精确查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void termsQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式：多关键词精确查询
        sourceBuilder.query(QueryBuilders.termsQuery("title", "手机", "小米"));
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }
}

20.结果过滤，排序，分页

创建测试类：Demo06RequestBodyQueryIncludesTests.java

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo06RequestBodyQueryIncludesTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 查询结果的排除
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void includesSources() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //设置查询方式
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //设置过滤条件，包含和排除
        String[] includes = {"title", "price", "images"};
        String[] excludes = {"images"};
        sourceBuilder.fetchSource(includes, excludes);
        //设置排序
        FieldSortBuilder sortBuilder = SortBuilders.fieldSort("price");
        //设置排序降序
        sortBuilder.order(SortOrder.DESC);
        sourceBuilder.sort(sortBuilder);
        //设置分页
        sourceBuilder.from(0);//当前页起始索引
        sourceBuilder.size(5);//每页显示多少条
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }
}

21.布尔查询(bool)

目标：查询title中必须包含小米，一定不含有电视，应该含有手机的所有商品

创建测试类：Demo07QueryHighLevelTests.java

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo07QueryHighLevelTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：布尔查询，多条件组合查询
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void boolQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //必须包含小米
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
        //必须不含电视
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
        //应该含有手机
        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
        //设置查询方式
        sourceBuilder.query(boolQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }
}

22.范围查询(range)

目标：查询价格大于2千，小于4千的所有商品

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo07QueryHighLevelTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：布尔查询，多条件组合查询
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void boolQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //必须包含小米
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
        //必须不含电视
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
        //应该含有手机
        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
        //设置查询方式
        sourceBuilder.query(boolQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 范围查询
     * 1.创建请求对象：范围查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void rangeQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：范围查询
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");
        //大于2千
        rangeQueryBuilder.gt(2000);
        //小于4千
        rangeQueryBuilder.lt(4000);
        //设置查询方式
        sourceBuilder.query(rangeQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }
}

23.模糊查询(fuzzy)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FuzzyQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
public class Demo07QueryHighLevelTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：布尔查询，多条件组合查询
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void boolQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //必须包含小米
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
        //必须不含电视
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
        //应该含有手机
        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
        //设置查询方式
        sourceBuilder.query(boolQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 范围查询
     * 1.创建请求对象：范围查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void rangeQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：范围查询
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");
        //大于2千
        rangeQueryBuilder.gt(2000);
        //小于4千
        rangeQueryBuilder.lt(4000);
        //设置查询方式
        sourceBuilder.query(rangeQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    /**
     * 模糊查询，查询包含apple关键词的所有商品，完成模糊查询appla
     * 1.创建请求对象：模糊查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void fuzzyQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().types("_doc").indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：模糊查询
        FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("title", "appla");
        //设置偏差值
        fuzzyQueryBuilder.fuzziness(Fuzziness.ONE);
        //设置查询方式
        sourceBuilder.query(fuzzyQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }
}

24.高亮查询(Highlighter)

package com.lxgzhw;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.Map;

@SpringBootTest
public class Demo07QueryHighLevelTests {
    //注入ES客户端对象
    @Autowired
    private RestHighLevelClient client;

    /**
     * 目标：布尔查询，多条件组合查询
     * 1.创建请求对象：查询所有
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void boolQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //必须包含小米
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "小米"));
        //必须不含电视
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("title", "电视"));
        //应该含有手机
        boolQueryBuilder.should(QueryBuilders.matchQuery("title", "手机"));
        //设置查询方式
        sourceBuilder.query(boolQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    public void printResult(SearchResponse response) {
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
        }
        System.out.println("<<::::");
    }

    /**
     * 范围查询
     * 1.创建请求对象：范围查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void rangeQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest();
        request.types("_doc");
        request.indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：范围查询
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("price");
        //大于2千
        rangeQueryBuilder.gt(2000);
        //小于4千
        rangeQueryBuilder.lt(4000);
        //设置查询方式
        sourceBuilder.query(rangeQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }

    /**
     * 模糊查询，查询包含apple关键词的所有商品，完成模糊查询appla
     * 1.创建请求对象：模糊查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void fuzzyQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().types("_doc").indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：模糊查询
        FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("title", "appla");
        //设置偏差值
        fuzzyQueryBuilder.fuzziness(Fuzziness.ONE);
        //设置查询方式
        sourceBuilder.query(fuzzyQueryBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.打印响应结果
        printResult(response);
    }


    /**
     * 高亮查询，对查询关键词进行高亮
     * 1.创建请求对象：高亮查询
     * 设置索引库name
     * 设置类型type
     * 2.创建查询请求体构建器
     * 设置请求体
     * 3.客户端发送请求，获取响应对象
     * 4.打印响应结果
     */
    @Test
    public void highLighterQuery() throws IOException {
        //1.创建请求对象
        SearchRequest request = new SearchRequest().types("_doc").indices("lxgzhw");
        //2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //构建查询方式：高亮查询
        TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("title", "小米");
        //设置查询方式
        sourceBuilder.query(termsQueryBuilder);
        //构建高亮字段
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<font color='red'>");//设置标签前缀
        highlightBuilder.postTags("</font>");//设置标签后缀
        highlightBuilder.field("title");//设置高亮字段
        //设置高亮构建对象
        sourceBuilder.highlighter(highlightBuilder);
        //设置请求体
        request.source(sourceBuilder);
        //3.客户端发送请求，获取响应对象
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("took::" + response.getTook());
        System.out.println("time_out::" + response.isTimedOut());
        System.out.println("total::" + hits.getTotalHits());
        System.out.println("max_score::" + hits.getMaxScore());
        System.out.println("hits::::>>");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
            //打印高亮结果
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields);
        }
        System.out.println("<<::::");
    }
}