搜索数据库 - ElasticSearch
搜索数据库 - ElasticSearch

ElasticSearch - Java操作

1. 项目准备
- 1. Elasticsearch 项目配置
- 2. 客户端连接及操作
2. 索引操作
3. 文档操作
4. 高级查询
5. 聚合查询

# 1. 项目准备

Elasticsearch 软件是由 Java 语言开发的，所以也可以通过 Java API 的方式对 Elasticsearch 服务进行访问

# 1. Elasticsearch 项目配置

# 1.1 推荐的官方 Java 客户端：`elasticsearch-java`

依赖配置：

<dependency>
    <groupId>co.elastic.clients</groupId>
    <artifactId>elasticsearch-java</artifactId>
    <version>7.17.16</version>
</dependency>

1
2
3
4
5

特点：

官方推荐：elasticsearch-java 是 Elasticsearch 8.x 及以后版本的推荐 Java 客户端。
简洁易用：只需要一个依赖即可完成大部分操作，提供简化的接口。
类型安全：提供强类型 API，可以轻松将 Java 对象与 Elasticsearch 文档进行交互。
内置序列化和反序列化：自动将 Java 对象转换为 JSON，无需手动处理序列化。
轻量：相较于以前的客户端，它更加轻量且高效，减少了手动配置和管理的复杂性。

兼容性说明：

虽然这是 Elasticsearch 8.x 官方推荐的客户端，但它同样兼容 Elasticsearch 7.x 的大部分功能，因此适用于较旧版本的 Elasticsearch。

# 1.2 旧的客户端：`elasticsearch-rest-high-level-client`

依赖配置：

<dependencies>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>7.15.2</version>
    </dependency>
    <!-- elasticsearch 的客户端 -->
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
        <version>7.15.2</version>
    </dependency>
    <!-- elasticsearch 依赖 2.x 的 log4j -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.8.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.8.2</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.3</version>
    </dependency>
    <!-- junit 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

特点：

依赖较多：使用 elasticsearch-rest-high-level-client 时，需要引入日志库（如 log4j）和序列化库（如 jackson-databind），相对复杂。
资源管理麻烦：需要手动管理 HTTP 连接池、日志、序列化等底层资源。
逐步被淘汰：从 Elasticsearch 8.x 开始，官方逐渐不再推荐使用该客户端。

# 1.3 新旧客户端对比

特点	`elasticsearch-java`	`elasticsearch-rest-high-level-client`
复杂度	简单，单一依赖即可	依赖多，需手动引入日志、序列化库等
类型安全	提供强类型 API，支持类型安全操作	部分操作仍然需要手动构建 JSON 字符串
序列化/反序列化	内置序列化，自动处理	需要手动引入 `jackson` 序列化库
性能与资源管理	轻量高效，简化资源管理	需要手动处理 HTTP 连接池、日志等
版本支持	ElasticSearch 7.x 和 8.x	主要用于 Elasticsearch 7.x
未来发展	官方推荐，未来的首选客户端	逐步淘汰，ElasticSearch 8.x 不再推荐

# 2. 客户端连接及操作

# 2.1 使用 `elasticsearch-java` 连接客户端

package com.example.es;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;

public class EsClientConnection {

    public static void main(String[] args) throws Exception {
        // 创建底层的 RestClient
        RestClient restClient = RestClient.builder(new HttpHost("localhost", 9200)).build();

        // 创建传输层
        ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 创建 Elasticsearch 客户端
        ElasticsearchClient client = new ElasticsearchClient(transport);

        // 可以在此执行查询、索引等操作...

        // 关闭客户端
        transport.close();
        restClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

注释详解：

RestClient：底层的 HTTP 客户端，用于发送请求到 Elasticsearch 服务。
ElasticsearchTransport：负责将 HTTP 请求和响应转换为 Elasticsearch 所能理解的格式。
ElasticsearchClient：官方推荐的高层次客户端，封装了常见的 Elasticsearch 操作。

# 2.2 使用 `RestHighLevelClient` 连接客户端

package com.example.es;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

public class EsTestClient {

    public static void main(String[] args) throws IOException {
        // 使用 RestHighLevelClient 连接 Elasticsearch
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );

        // 关闭客户端
        client.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注释详解：

RestHighLevelClient 是 7.x 版本中较高级的客户端，它基于底层的 RestClient，需要手动管理连接、日志等。

# 2. 索引操作

ES 服务器正常启动后，可以通过 Java API 客户端对象对 ES 索引进行操作

# 1. 创建索引

创建索引是 Elasticsearch 操作的基础。我们可以通过 CreateIndexRequest 类构建创建索引的请求，并通过 indices().create() 方法将请求发送到 Elasticsearch 服务。

代码示例：

package com.kbt.index;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;

import java.io.IOException;

/**
 * @author scholar
 * @date 2021/11/15
 * @description 创建 Elasticsearch 索引
 */
public class EsIndexCreate {

    public static void main(String[] args) throws IOException {
        // 1. 连接 Elasticsearch 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
       
        // 2. 构建创建索引的请求对象，指定索引名为 "user"
        CreateIndexRequest request = new CreateIndexRequest("user");

        // 3. 发送请求，创建索引
        CreateIndexResponse response = esClient.indices().create(request, RequestOptions.DEFAULT);

        // 4. 判断索引是否创建成功
        boolean acknowledged = response.isAcknowledged();
        System.out.println("索引创建状态：" + acknowledged);

        // 5. 关闭 Elasticsearch 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

代码说明：

RestHighLevelClient：连接到 Elasticsearch 的客户端对象。
CreateIndexRequest：用于构建创建索引的请求，"user" 是索引名称。
CreateIndexResponse：响应对象，包含创建索引的结果。
isAcknowledged()：返回 true 表示索引创建成功。

执行该代码后，如果返回 true，则索引已成功创建。

结果示例：

索引创建状态：true

# 2. 查看索引

查看已创建的索引可以帮助我们了解索引的别名、映射、配置信息。通过 GetIndexRequest 类可以获取指定索引的详细信息。

代码示例：

package com.kbt.index;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;

import java.io.IOException;

/**
 * @description 查询 Elasticsearch 索引信息
 */
public class EsIndexQuery {

    public static void main(String[] args) throws IOException {
        // 1. 连接 Elasticsearch 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        
        // 2. 构建获取索引的请求对象，指定索引名为 "user"
        GetIndexRequest request = new GetIndexRequest("user");

        // 3. 发送请求，获取索引的详细信息
        GetIndexResponse response = esClient.indices().get(request, RequestOptions.DEFAULT);

        // 4. 输出索引的别名、映射和配置信息
        System.out.println("索引别名：" + response.getAliases());
        System.out.println("索引映射：" + response.getMappings());
        System.out.println("索引配置：" + response.getSettings());

        // 5. 关闭 Elasticsearch 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

代码说明：

GetIndexRequest：用于构建获取索引信息的请求，指定要查询的索引名称 "user"。
GetIndexResponse：响应对象，包含索引的别名、映射和配置。
getAliases()：获取索引的别名。
getMappings()：获取索引的映射信息（即字段和数据类型）。
getSettings()：获取索引的配置，例如分片和副本配置。

返回结果：

索引别名：{}
索引映射：{user={properties={}}}
索引配置：{index.number_of_replicas=1, index.number_of_shards=1}

1
2
3

# 3. 删除索引

如果某个索引不再需要，可以通过 DeleteIndexRequest 类删除该索引。

代码示例：

package com.kbt.index;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;

import java.io.IOException;

/**
 * @description 删除 Elasticsearch 索引
 */
public class EsIndexDelete {

    public static void main(String[] args) throws IOException {
        // 1. 连接 Elasticsearch 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http"))
        );
        
        // 2. 构建删除索引的请求对象，指定要删除的索引名 "user"
        DeleteIndexRequest request = new DeleteIndexRequest("user");

        // 3. 发送删除索引请求，获取响应
        AcknowledgedResponse response = esClient.indices().delete(request, RequestOptions.DEFAULT);

        // 4. 判断索引是否成功删除
        System.out.println("删除索引状态：" + response.isAcknowledged());

        // 5. 关闭 Elasticsearch 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

代码说明：

DeleteIndexRequest：用于构建删除索引的请求，指定要删除的索引 "user"。
AcknowledgedResponse：响应对象，返回删除操作的结果。
isAcknowledged()：返回 true 表示索引删除成功。

返回结果：

删除索引状态：true

# 4. 总结

关于 Elasticsearch 索引操作，核心方法均是通过相应的 Request 类与 Elasticsearch 服务器进行交互。操作的步骤包括：

连接 Elasticsearch 客户端。
构建请求对象（如 CreateIndexRequest、GetIndexRequest、DeleteIndexRequest）。
通过 indices() 方法执行创建、查询、删除等操作。
处理服务器返回的响应对象（如 CreateIndexResponse、GetIndexResponse、AcknowledgedResponse）。
最后关闭客户端连接。

通过这些 API，我们可以轻松管理 Elasticsearch 中的索引，实现高效的数据存储和查询操作。

# 3. 文档操作

# 1. 新增文档

首先需要创建一个实体类：User

package com.kbt.pojo;

/**
 * @description 用户实体类
 */
public class User {
    private String username; // 用户名
    private int age;         // 年龄
    private String sex;       // 性别

    public User(String username, int age, String sex) {
        this.username = username;
        this.age = age;
        this.sex = sex;
    }

    // Getters 和 Setters
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public String getSex() { return sex; }
    public void setSex(String sex) { this.sex = sex; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

创建数据，添加到文档中

package com.kbt.doc;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.kbt.pojo.User;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;

/**
 * @author scholar
 * @date 2021/11/15 17:16
 * @description ES 文档的创建
 */
public class EsDocCreate {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        IndexRequest request = new IndexRequest();
        request.index("user").id("1001");
        // 创建数据对象
        User user = new User("可乐",18,"男");
        // 数据转换为 Json 字符串格式
        ObjectMapper objectMapper = new ObjectMapper();
        String userJsonStr = objectMapper.writeValueAsString(user);
        // 添加文档数据，数据格式为 Json 格式
        request.source(userJsonStr, XContentType.JSON);
        // 客户端发送请求，获取响应对象
        IndexResponse response = esClient.index(request, RequestOptions.DEFAULT);
        System.out.println("创建的索引：" + response.getIndex());
        System.out.println("创建的 id：" + response.getId());
        System.out.println("创建的结果：" + response.getResult());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

结果：

笔记

你会发现，响应对象的方法里，使用 getXXX 获取某些数据中，XXX 就是之前 Postman 返回结果的 Key 名

# 2. 修改文档

/**
 * @author scholar
 * @date 2021/11/15 17:16
 * @description ES 文档的修改
 */
public class EsDocUpdate {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        UpdateRequest request = new UpdateRequest();
        // 配置修改参数
        request.index("user").id("1001");
        //  设置请求体，对数据进行修改
        request.doc(XContentType.JSON, "sex", "女");
        // 客户端发送请求，获取响应对象
        UpdateResponse response = esClient.update(request, RequestOptions.DEFAULT);
        System.out.println("创建的索引：" + response.getIndex());
        System.out.println("创建的 id：" + response.getId());
        System.out.println("修改的结果：" + response.getResult());


        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

返回结果：

# 3. 查询文档

15/**
 * @author scholar
 * @date 2021/11/15 17:16
 * @description ES 文档的创建
 */
public class EsDocQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建请求对象
        GetRequest request = new GetRequest();
        request.index("user").id("1001");
        // 客户端发送请求，获取响应对象
        GetResponse response = esClient.get(request, RequestOptions.DEFAULT);
        System.out.println("创建的索引：" + response.getIndex());
        System.out.println("创建的 id：" + response.getId());
        System.out.println("查询的结果：" + response.getSourceAsString());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

返回的结果：

# 4. 删除文档

/**
 * @author scholar
 * @date 2021/11/15 17:16
 * @description ES 文档的删除
 */
public class EsDocDelete {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        DeleteRequest request = new DeleteRequest();
        // 配置修改参数
        request.index("user").id("1001");
        // 客户端发送请求，获取响应对象
        DeleteResponse response = esClient.delete(request, RequestOptions.DEFAULT);
        System.out.println("响应内容：" + response.toString());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

返回结果：

# 5. 批量新增

public class EsDocCreateBatch {

  public static void main(String[] args) throws IOException {
      // 连接 ES 客户端
      RestHighLevelClient esClient = new RestHighLevelClient(
          RestClient.builder(new HttpHost("localhost",9200,"http")));

      BulkRequest request = new BulkRequest();
      ObjectMapper objectMapper = new ObjectMapper();
      // 创建数据对象
      request.add(new IndexRequest().index("user").id("1001").source(objectMapper.writeValueAsString(new User("可乐", 18, "男")), XContentType.JSON));
      request.add(new IndexRequest().index("user").id("1002").source(objectMapper.writeValueAsString(new User("冰糖", 20, "女")), XContentType.JSON));
      request.add(new IndexRequest().index("user").id("1003").source(objectMapper.writeValueAsString(new User("雪梨", 22, "女")), XContentType.JSON));
      request.add(new IndexRequest().index("user").id("1004").source(objectMapper.writeValueAsString(new User("酸橙", 24, "男")), XContentType.JSON));
      request.add(new IndexRequest().index("user").id("1005").source(objectMapper.writeValueAsString(new User("蜜桃", 30, "女")), XContentType.JSON));
      // 客户端发送请求，获取响应对象
      BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
      System.out.println("响应时间：" + response.getTook());
      System.out.println("创建的内容：" + Arrays.toString(response.getItems()));

      // 关闭 ES 客户端
      esClient.close();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class EsDocCreateBatch {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        BulkRequest request = new BulkRequest();
        // 创建数据对象
        User user = new User("可乐","18","男");
        request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "username","可乐","age",18,"sex","男"));
        request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "username","冰糖","age",20,"sex","女"));
        request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "username","雪梨","age",22,"sex","女"));
        request.add(new IndexRequest().index("user").id("1004").source(XContentType.JSON, "username","酸橙","age",24,"sex","男"));
        request.add(new IndexRequest().index("user").id("1005").source(XContentType.JSON, "username","蜜桃","age",26,"sex","女"));
        // 客户端发送请求，获取响应对象
        BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
        System.out.println("响应时间：" + response.getTook());
        System.out.println("创建的内容：" + Arrays.toString(response.getItems()));


        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Make sure to add code blocks to your code group

返回结果：

创建内容无法打印完整的数据，只能打印数据的地址。

# 6. 批量删除

public class EsDocDeleteBatch {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        BulkRequest request = new BulkRequest();
        // 配置修改参数
        request.add(new DeleteRequest().index("user").id("1001"));
        request.add(new DeleteRequest().index("user").id("1002"));
        request.add(new DeleteRequest().index("user").id("1003"));
        request.add(new DeleteRequest().index("user").id("1004"));
        request.add(new DeleteRequest().index("user").id("1005"));
        // 客户端发送请求，获取响应对象
        BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
        //打印结果信息
        System.out.println("响应时间:" + response.getTook());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 7. 总结

增删改查操作格式：

连接 ES 客户端
创建一个 XXXRequest 对象，其中 XXX 代表增删改查
给该对象设置索引和文档
调用 .XXX请求，传入参数，其中 XXX 代表增删改查

# 4. 高级查询

# 1. 查询准备

本内容都是查询相关，所以需要插入几条数据

public class EsDocCreateBatch {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        BulkRequest request = new BulkRequest();
        ObjectMapper objectMapper = new ObjectMapper();
        // 创建数据对象
        request.add(new IndexRequest().index("user").id("1001").source(objectMapper.writeValueAsString(new User("可乐", 18, "男")), XContentType.JSON));
        request.add(new IndexRequest().index("user").id("1002").source(objectMapper.writeValueAsString(new User("冰糖", 20, "女")), XContentType.JSON));
        request.add(new IndexRequest().index("user").id("1003").source(objectMapper.writeValueAsString(new User("雪梨", 22, "女")), XContentType.JSON));
        request.add(new IndexRequest().index("user").id("1004").source(objectMapper.writeValueAsString(new User("酸橙", 24, "男")), XContentType.JSON));
        request.add(new IndexRequest().index("user").id("1005").source(objectMapper.writeValueAsString(new User("蜜桃", 30, "女")), XContentType.JSON));
        // 客户端发送请求，获取响应对象
        BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
        System.out.println("响应时间：" + response.getTook());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 2. 查询所有索引数据

public class EsQueryAll {
    
    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 查询所有数据
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }

        // 关闭java ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

indices(参数) 的参数可以是多个索引。

返回结果：

# 3. term查询

查询某个字段，查询条件为关键字，如果查询分词，则会报错，在问题查看

public class EsTermQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        SearchRequest request = new SearchRequest();
        request.indices("user");
        
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.termQuery("age", "18"));
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }

        // 关闭 ES 客户端
        esClient.close();
    }
} sourceBuilder.query(QueryBuilders.termsQuery("age", "18","20","22"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

返回结果：

# 4. terms查询

public class EsTermQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        SearchRequest request = new SearchRequest();
        request.indices("user");
        
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.termsQuery("age", "18","20","22"));
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

返回结果：

# 5.分页查询

public class EsPagesQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        // 分页查询
        // 当前页其实索引(第一条数据的顺序号)，from
        sourceBuilder.from(0);
        // 每页显示多少条 size
        sourceBuilder.size(2);
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

查询两条数据，从第一条开始

返回结果：

# 6. 排序查询

public class EsSortQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        // 排序
        sourceBuilder.sort("age", SortOrder.ASC);
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
        // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 7. 过滤字段

public class EsFilterQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery());
        //查询字段过滤
        String[] excludes = {};
        String[] includes = {"username", "age"};
        sourceBuilder.fetchSource(includes, excludes);
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

返回结果：

# 8. Bool查询

public class EsBoolQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 必须包含
        boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
        // 一定不含
        boolQueryBuilder.mustNot(QueryBuilders.matchQuery("useername", "可乐"));
        // 可能包含
        boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));
        sourceBuilder.query(boolQueryBuilder);
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

返回结果：

# 9. 范围查询

public class EsRangeQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
        // 大于等于
        rangeQuery.gte("18");
        // 小于等于
        rangeQuery.lte("24");
        sourceBuilder.query(rangeQuery);
        request.source(sourceBuilder);
        SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("took:" + response.getTook());
        System.out.println("timeout:" + response.isTimedOut());
        System.out.println("total:" + hits.getTotalHits());
        System.out.println("MaxScore:" + hits.getMaxScore());

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

返回结果：

# 10. 模糊查询

public class EsFuzzyQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 创建搜索请求对象
        SearchRequest request = new SearchRequest();
        request.indices("user");
        // 构建查询的请求体
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.fuzzyQuery("age",2).fuzziness(Fuzziness.ONE));
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 查询匹配
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            // 输出每条查询的结果信息
            System.out.println(hit.getSourceAsString());
        }
        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

返回结果：

# 11. 高亮查询

public class EsHeightQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 高亮查询
        SearchRequest request = new SearchRequest().indices("user");
        // 2.创建查询请求体构建器
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 构建查询方式：高亮查询
        sourceBuilder.query(QueryBuilders.termsQuery("age","18","20"));
        // 构建高亮字段
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.preTags("<font color='red'>");// 设置标签前缀
        highlightBuilder.postTags("</font>");// 设置标签后缀
        highlightBuilder.field("age");// 设置高亮字段
        //设置高亮构建对象
        sourceBuilder.highlighter(highlightBuilder);
        // 3.客户端发送请求，获取响应对象
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        //4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println("响应时间：" + response.getTook());
        System.out.println("是否超时：" + response.isTimedOut());
        System.out.println("命中数量：" + hits.getTotalHits());
        System.out.println("MaxScore：" + hits.getMaxScore());
        System.out.println("详细数据：");
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            System.out.println(sourceAsString);
            // 打印高亮结果
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            System.out.println(highlightFields);
        }
        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

返回结果：

# 5. 聚合查询

# 1. 最大年龄

public class EsArrgQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 高亮查询
        SearchRequest request = new SearchRequest().indices("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(AggregationBuilders.max("maxAge").field("age"));
        // 3.客户端发送请求，获取响应对象
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 4.打印响应结果
        System.out.println(response);

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 2. 分组统计

public class EsArrgQuery {

    public static void main(String[] args) throws IOException {
        // 连接 ES 客户端 
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http")));

        // 高亮查询
        SearchRequest request = new SearchRequest().indices("user");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(AggregationBuilders.terms("ageGroupby").field("age"));
        // 3.客户端发送请求，获取响应对象
        SearchResponse response = esClient.search(request.source(sourceBuilder), RequestOptions.DEFAULT);
        // 4.打印响应结果
        SearchHits hits = response.getHits();
        System.out.println(response);

        // 关闭 ES 客户端
        esClient.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 3. 聚合查询问题

Exception in thread "main" ElasticsearchStatusException[Elasticsearch exception [type=search_phase_execution_exception, 
reason=all shards failed]]; nested: ElasticsearchException[Elasticsearch exception [type=illegal_argument_exception, 
reason=Text fields are not optimised for operations that require per-document field data like aggregations and sorting, so 
these operations are disabled by default. Please use a keyword field instead. Alternatively, set fielddata=true on [age] 
in order to load field data by uninverting the inverted index. Note that this can use significant memory.]]; nested: 
ElasticsearchException[Elasticsearch exception [type=illegal_argument_exception, reason=Text fields are not optimised for 
operations that require per-document field data like aggregations and sorting, so these operations are disabled by 
default. Please use a keyword field instead. Alternatively, set fielddata=true on [age] in order to load field data by 
uninverting the inverted index. Note that this can use significant memory.]];

1
2
3
4
5
6
7
8
9

说明查询的字段是 text 类型，所以报错，只有 keyword 类型的字符串可以分组聚合查询。

编辑此页

上次更新: 2024/12/28, 18:32:08

← ElasticSearch - 分词器 ElasticSearch - 多框架集成→

ElasticSearch - Java操作

# 1. 项目准备

# 1. Elasticsearch 项目配置

# 1.1 推荐的官方 Java 客户端：elasticsearch-java

# 1.2 旧的客户端：elasticsearch-rest-high-level-client

# 1.3 新旧客户端对比

# 2. 客户端连接及操作

# 2.1 使用 elasticsearch-java 连接客户端

# 2.2 使用 RestHighLevelClient 连接客户端

# 2. 索引操作

# 1. 创建索引

# 2. 查看索引

# 3. 删除索引

# 4. 总结

# 3. 文档操作

# 1. 新增文档

# 2. 修改文档

# 3. 查询文档

# 4. 删除文档

# 5. 批量新增

# 6. 批量删除

# 7. 总结

# 4. 高级查询

# 1. 查询准备

# 2. 查询所有索引数据

# 3. term查询

# 4. terms查询

# 5.分页查询

# 6. 排序查询

# 7. 过滤字段

# 8. Bool查询

# 9. 范围查询

# 10. 模糊查询

# 11. 高亮查询

# 5. 聚合查询

# 1. 最大年龄

# 2. 分组统计

# 3. 聚合查询问题

# 1.1 推荐的官方 Java 客户端：`elasticsearch-java`

# 1.2 旧的客户端：`elasticsearch-rest-high-level-client`

# 2.1 使用 `elasticsearch-java` 连接客户端

# 2.2 使用 `RestHighLevelClient` 连接客户端