ElasticSearch 8 学习笔记总结(六)

已于 2023-11-16 13:50:25 修改
阅读量2.4k 收藏 13
点赞数 1
分类专栏： 中间件 文章标签： elasticsearch 学习 java
于 2023-03-09 20:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_Holmes/article/details/129370358
版权

文章目录

一. ES8 的Java API 环境准备

ES8 废除了Type的概念。为了适应这种数据结构的改变，ES官方从1.7版本开始建议使用新的Elasticsearch Java Client。

搭建maven环境：

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <elastic.version>8.6.2</elastic.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.elasticsearch.plugin</groupId>
        <artifactId>x-pack-sql-jdbc</artifactId>
        <version>8.6.2</version>
    </dependency>
    <dependency>
        <groupId>co.elastic.clients</groupId>
        <artifactId>elasticsearch-java</artifactId>
        <version>${elastic.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.3</version>
    </dependency>
    <dependency>
        <groupId>jakarta.json</groupId>
        <artifactId>jakarta.json-api</artifactId>
        <version>2.0.1</version>
    </dependency>
</dependencies>

获取客户端对象：

因为，服务注册的是基于https的安全elasticsearch服务认证，所以，将之前的证书进行一个转换：

# 生成es-api-ca.crt证书，之前没有密码设置。
openssl pkcs12 -in elastic-stack-ca.p12 -clcerts -nokeys -out es-api-ca.crt

将生成的证书放到项目里面。
在这里插入图片描述

创建连接对象：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

public class ESClient {

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
    }

    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        RestClientTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        ElasticsearchClient client = new ElasticsearchClient(transport);
        // 异步客户端对象
        ElasticsearchAsyncClient asyncClient = new ElasticsearchAsyncClient(transport);

        // fixme 同步是需要关闭的，而异步是不需要关闭的。
        transport.close();
    }

}

二. ES8 的Java API 索引操作

ES Java的API相关操作：

  • 采用构造器形式来创建所需要的对象。
  • 通过lambda来创建。

对象形式操作：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.indices.*;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

public class ESClient {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // 操作索引
        operationIndex();
    }
    // 操作索引
    private static void operationIndex() throws Exception{
        // 获取索引客户端对象
        ElasticsearchIndicesClient indices = client.indices();
        // 判断索引是否存在
        ExistsRequest existsRequest = new ExistsRequest.Builder().index(INDEX_HOLMES).build();
        final boolean flg = indices.exists(existsRequest).value();
        if (flg){
            System.out.println("索引" + INDEX_HOLMES + "已经存在！");
        } else {
            // 创建索引
            // CreateIndexRequest构造方法已经私有化了，所以需要采用构建器方式来构建对象。ES的API对象基本上都采用构建器的方式创建对象。
            CreateIndexRequest request = new CreateIndexRequest.Builder()
                    .index(INDEX_HOLMES)
                    .build();
            final CreateIndexResponse createIndexResponse = indices.create(request);
            System.out.println("创建索引的响应对象" + createIndexResponse);
        }
        // 查询索引
        GetIndexRequest getIndexRequest = new GetIndexRequest.Builder().index(INDEX_HOLMES).build();
        final GetIndexResponse getIndexResponse = indices.get(getIndexRequest);
        // IndexState itholmes = getIndexResponse.get("itholmes");
        System.out.println("查询的响应结果：" + getIndexResponse);
        // 删除索引
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest.Builder().index(INDEX_HOLMES).build();
        DeleteIndexResponse delete = indices.delete(deleteIndexRequest);
        System.out.println("索引删除成功：" + delete);
        // fixme 同步是需要关闭的，而异步是不需要关闭的。
        transport.close();
    }

    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

lambda方式创建索引：（推荐使用，代码简洁）

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.indices.*;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import co.elastic.clients.util.ObjectBuilder;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.function.Function;

public class ESClient {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // lambda方式 操作索引
        operationIndexLambda();
    }
    // fixme 操作索引 Lambda方式 其实就是提供了两种方式
    private static void operationIndexLambda() throws Exception{
        // 获取索引客户端对象
        ElasticsearchIndicesClient indices = client.indices();
        // 检查索引是否存在
        boolean flg = indices.exists(req -> req.index(INDEX_HOLMES)).value();
        if (flg){
            System.out.println("索引" + INDEX_HOLMES + "已经存在！");
        } else {
            // 创建索引
            final CreateIndexResponse createIndexResponse = indices.create(req -> req.index(INDEX_HOLMES));
            System.out.println("创建索引的响应对象：" + createIndexResponse);
        }
        // 查询索引
        final GetIndexResponse getIndexResponse = indices.get(req -> req.index(INDEX_HOLMES));
        System.out.println("查询的响应结果：" + getIndexResponse.get("itholmes"));
        // 删除索引
        DeleteIndexResponse deleteIndexResponse = indices.delete(req -> req.index(INDEX_HOLMES));
        System.out.println("索引删除成功：" + deleteIndexResponse);
        // fixme 同步是需要关闭的，而异步是不需要关闭的。
        transport.close();
    }
   
    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

三. ES8 的Java API 文档操作

1. 文档的 插入 批量插入 删除等操作

文档对象形式操作：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.Result;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.CreateOperation;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.ArrayList;
import java.util.List;

public class ESClient2 {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // fixme 文档操作
        operateDocument();
    }
    // 对象操作文档
    public static void operateDocument() throws Exception{
        // 创建对象数据
        User user = new User();
        user.setId(1001);
        user.setName("zhangsan");
        user.setAge(30);
        CreateRequest<User> createRequest = new CreateRequest.Builder<User>()
                .index(INDEX_HOLMES)
                .id("1001")
                .document(user)
                .build();

        // 增加文档
        CreateResponse createResponse = client.create(createRequest);
        System.out.println("文档创建的响应对象：" + createResponse);

        // 批量添加数据
        List<BulkOperation> opts = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            CreateOperation<User> optObj = new CreateOperation.Builder<User>()
                    .index(INDEX_HOLMES)
                    .id("200" + i)
                    .document(new User(2000 + i,"张三" + i,30 + i))
                    .build();
            BulkOperation opt = new BulkOperation.Builder()
                    .create(optObj)
                    .build();
            opts.add(opt);
        }
        BulkRequest bulkRequest = new BulkRequest.Builder()
                .operations(opts)
                .build();
        final BulkResponse bulk = client.bulk(bulkRequest);
        System.out.println("批量新增数据的响应：" + bulk);

        // 文档删除
        DeleteRequest deleteRequest = new DeleteRequest.Builder()
                .index(INDEX_HOLMES)
                .id("2001")
                .build();
        DeleteResponse delete = client.delete(deleteRequest);
        System.out.println("删除后的响应：" + delete);
        // 关闭transport
        transport.close();
    }

    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

lambda形式：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.Result;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.CreateOperation;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.ArrayList;
import java.util.List;

public class ESClient2 {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // fixme 文档操作
        operateDocumentLambda();
    }

    // lambda操作文档
    public static void operateDocumentLambda() throws Exception{
        // 增加文档
        Result result = client.create(
                req ->
                        req.index(INDEX_HOLMES).id("1001").document(new User(1001, "张三", 30))
        ).result();
        System.out.println("文档创建的响应对象：" + result);

        // 批量添加数据
        ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            users.add(new User(3000 + i , "lisi" + i ,30 + i));
        }
        BulkResponse bulk = client.bulk(
                req -> {
                    users.forEach(
                            u -> {
                                req.operations(
                                        b -> b.create(
                                                d -> d.index(INDEX_HOLMES)
                                                        .id(u.getId().toString())
                                                        .document(u)
                                        )
                                );
                            }
                    );
                    return req;
                }
        );
        System.out.println("批量新增数据的响应：" + bulk);

        // 文档删除
        DeleteResponse delete = client.delete(
                req -> req.index(INDEX_HOLMES).id("3001")
        );
        System.out.println("删除后的响应：" + delete);
        // 关闭transport
        transport.close();
    }

    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

2. 文档的查询

对象形式操作：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.Result;
import co.elastic.clients.elasticsearch._types.query_dsl.MatchQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.CreateOperation;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.ArrayList;
import java.util.List;

public class ESClient3 {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // fixme 文档查询操作
        queryDocument();
    }

    // 文档查询操作
    public static void queryDocument() throws Exception{

        MatchQuery matchQuery = new MatchQuery.Builder()
                .field("age").query(30)
                .build();

        Query query = new Query.Builder()
                .match(matchQuery)
                .build();

        SearchRequest searchRequest = new SearchRequest.Builder()
                .query(query) // 传递条件
                .build();

        SearchResponse<Object> search = client.search(searchRequest, Object.class);

        System.out.println(search);

        transport.close();
    }

    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

lambda操作：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.Result;
import co.elastic.clients.elasticsearch._types.query_dsl.MatchQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkOperation;
import co.elastic.clients.elasticsearch.core.bulk.CreateOperation;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.util.ArrayList;
import java.util.List;

public class ESClient3 {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // fixme 文档查询操作
        queryDocumentLambda();
    }

    // 文档查询操作
    public static void queryDocumentLambda() throws Exception{

        SearchResponse<Object> search = client.search(
                req -> {
                    req.query(
                            q -> q.match(
                                    m -> m.field("name").query("zhangsan")
                            )
                    );
                    return req;
                },
                Object.class
        );

        System.out.println(search);

        transport.close();
    }

    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}

四、异步客户端操作

进行异步相关操作：

package com.itholmes.elasticsearch.api;

import co.elastic.clients.elasticsearch.ElasticsearchAsyncClient;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import javax.net.ssl.SSLContext;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

public class ESClient3 {

    private static ElasticsearchClient client;

    private static ElasticsearchAsyncClient asyncClient;

    private static ElasticsearchTransport transport;

    public static final String INDEX_HOLMES = "itholmes";

    public static void main(String[] args) throws Exception{
        // 初始化ES服务器的连接
        initESConnection();
        // fixme 异步文档查询操作
        asyncClientOperation();
    }

    public static void asyncClientOperation() throws Exception{
        asyncClient.indices().create(
                req -> req.index("newindex")
        ).thenApply( // 此处可以处理一下，resp返回值
            resp -> resp.acknowledged()
        ).whenComplete( // 当完成时，调用的回调
                (resp,error) -> {
                    System.out.println("回调方法");
                    if (resp != null){
                        System.out.println(resp);
                    } else {
                        error.printStackTrace();
                    }
                }
        );
        System.out.println("主线程代码...");
    }

    // 初始化ES服务器的连接
    public static void initESConnection() throws Exception{
        final BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        // 声明ES当前登录的账号密码
        credentialsProvider.setCredentials(AuthScope.ANY,new UsernamePasswordCredentials("elastic","3j=JYpywv=jMtQB+XIXS"));
        // 证书的路径
        Path caCertificatePath = Paths.get("E:\\itholmes\\demo\\itholmes-es8\\certs\\es-api-ca.crt");
        // x.509 , pkcs12都是 证书的算法
        CertificateFactory factory = CertificateFactory.getInstance("x.509");
        Certificate trustedCa;
        try (InputStream is = Files.newInputStream(caCertificatePath)){
            trustedCa = factory.generateCertificate(is);
        }
        KeyStore trustStore = KeyStore.getInstance("pkcs12");
        trustStore.load(null,null);
        trustStore.setCertificateEntry("ca",trustedCa);
        SSLContextBuilder sslContextBuilder = SSLContexts.custom()
                .loadTrustMaterial(trustStore,null);
        SSLContext sslContext = sslContextBuilder.build();
        RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.43.133", 9200, "https"))
                .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                    @Override
                    public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                        return httpClientBuilder.setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .setDefaultCredentialsProvider(credentialsProvider);
                    }
                });

        // 创建客户端
        RestClient restClient = builder.build();
        // 通过客户端，创建传输对象
        transport = new RestClientTransport(restClient, new JacksonJsonpMapper());

        // 同步客户端对象
        client = new ElasticsearchClient(transport);
        // 异步客户端对象
        asyncClient = new ElasticsearchAsyncClient(transport);
    }

}
xupengboo
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ElasticSearch学习笔记1
08-08
ElasticSearch学习笔记1 ElasticSearch是基于Lucene的搜索服务器，它提供了高性能的全文搜索功能，支持开箱即用的集群化扩展。ElasticSearch可以通过标准的REST API或特定于编程语言的客户端库与之交互。 一、什么...
ElasticSearch_Windows实现搜索学习笔记.pdf
09-25
总结来说，Elasticsearch因其分布式、实时和易用的特性，成为许多企业和项目的首选搜索和分析引擎，广泛应用于日志分析、商业智能、内容搜索等场景。随着大数据时代的到来，Elasticsearch的重要性愈发凸显，其强大的...
ElasticSearch 8.x 弃用了 High Level REST Client，移除了 Java Transport Client，推荐使用 Elasticsearch Java API
qq_19283249的博客
01-11 3226
从 ElasticSearch 7.0.0 版本开始，ElasticSearch 官方就不建议使用 TransportClient 客户端了，推荐使用 High Level REST Client 客户端了。 然后接下来，从 ElasticSearch 7.15.0 版本开始，ElasticSearch 官方就不建议使用 High Level REST 客户端了，推荐使用 ElasticSearch-java 客户端了。
java 操作 elasticsearch 8 单机版
最新发布
咬一口空气榨汁机的博客
05-26 1143
本篇使用的elasticsearch版本为8.13.4，jdk版本为17，单机版的elasticsearch最近做了个需求是文章查重的，使用了向量数据库搭配elasticsearch做了这个需求，由于甲方比较追求新的东西，所以不得已使用了8.13.4的版本，做个记录方便以后参考。
springboot集成elasticsearch8.X（8.11） 最新版的Java API Client 接口
weixin_53021967的博客
12-27 1850
springboot集成Elasticsearch的使用，Elasticsearch版本为8.11版本，springboot版本为2.6.13，使用的是最新版的Java API Client 接口
[elastic 8.x]java客户端连接elasticsearch与操作索引与文档
m0_67713667的博客
11-05 1987
/
Elasticsearch8.x版本Java客户端Elasticsearch Java API 如何并发修改
lnn112233的博客
03-18 697
并发控制，一般有两种方案，悲观锁和乐观锁，其中悲观锁是默认每次更新操作肯定会冲突，所以每次操作都要先获取锁，操作完毕再释放锁，适用于写比较多的场景。而乐观锁是默认每次更新操作都不会冲突，所以在更新前和更新后都不需要获取锁和释放锁的操作，所以效率更高，适合于读多写少的场景中。
Elasticsearch：使用最新的 Elasticsearch Java client 8.0 来创建索引并搜索
热门推荐
Elastic 中国社区官方博客
03-30 1万+
这篇文章，我来详细地描述如何使用最新的 Elasticsearch Java client 8.0 来创建索引并进行搜索。最新的 Elasticsearch Java client API 和之前的不同。在之前的一些教程中，我们使用 High Level API来进行操作。在官方文档中，已经显示为 deprecated。 前提条件 Java 8 及以后的版本 一个 JSON 对象映射库，允许你的应用程序类与 Elasticsearch API 无缝集成。 Java 客户端支持 Jackson 或像
Elasticsearch之原理详解
上善若泪
12-06 362
是使用 编写的一种开源搜索引擎，它在内部使用 做索引与搜索，通过对 的封装，隐藏了 的复杂性，取而代之的提供一套简单一致的 然而， 不仅仅是 ，并且也不仅仅只是一个全文搜索引擎。它可以被下面这样准确的形容：官网对 的介绍是 是一个分布式、可扩展、近实时的搜索与数据分析引擎。其中主要有如下几个核心术语需要理解：和是 中很重要的两种数据结构，是实现快速检索的重要基石。和是分两部分存储的，而上 支持 级全文搜索，当索引上的数据量太大的时候， 通过水平拆分的方式将一个索引上的数据拆分出来分配到不同
Elasticsearch 8.9 服务端接收创建索引和查询索引信息源码
胖墩的IT博客
11-07 502
至于下面创建索引和查询索引信息的入口如何找到的，可以。
express-mongoose-es8-rest-api：使用Express并支持ES6，ES7，ES8，Mongoose，JWT身份验证和Standardjs linting的Node.js开发Rest api的样板
02-03
Express猫鼬ES8-REST-API 描述 支持Express，Mongoose，Mysql，JWT，ES6，ES7，ES8的Nodejs样板开发REST API 产品特点 通过 7.支持ES6，ES7，ES8 通过JWT进行身份验证，每用户具有动态秘密 JWT中间件，用于经过身份验证的路由管理 使用请求验证 使用asyncWrapper在整个路由中进行一次try-catch的async-await 代码使用和预提交使用Git挂钩 使用 ， ， 集成测试 使用自动启动服务器 在使用 应用程序级别errorHandler 通过管理环境 代码覆盖率 使用保护api端点，从而增加了必要的安全标头 添加了对具有异步等待功能的数据库（如和支持 使用和具有磁盘和S3存储的灵活 入门 克隆存储库 > git clone https://github.com/vibhasfl/express-mongoose-es8-rest-api.git > cd express-mongoose-es8-rest-api 安装纱 > npm i -g yarn 安装项目依赖项 > yarn 设置
Kibana学习笔记
01-20
以下是对Kibana学习笔记的详细解释： 1. **配置** Kibana的配置涉及到对服务器地址、安全性和数据源的设定。配置文件一般位于Kibana安装目录下，可以通过编辑`kibana.yml`进行修改。在配置中，可能需要启用SSL以...
Android-Notes:Android学习笔记总结
06-01
《Android学习笔记总结》 Android，作为全球最广泛使用的移动操作系统，是许多开发者的重要战场。这份"Android-Notes"的学习笔记旨在系统性地梳理Android开发中的关键知识点，帮助初学者和有经验的开发者巩固和深化...
nodejs-learning：nodejs学习笔记，总结
02-15
"学习笔记"部分可能会包含对Node.js核心概念的解释，如事件循环、回调函数、模块系统、进程和线程等。事件循环是Node.js异步编程的核心，理解它的工作原理对于优化代码和避免回调地狱至关重要。模块系统允许我们按需...
Elasticsearch8常用查询api，java ElasticsearchClient写法和原生Rest DSL写法
王某Fly的博客
02-06 2350
【代码】Elasticsearch8常用查询api，java ElasticsearchClient写法和原生Rest DSL写法。
ES 08 - 配置Elasticsearch的映射 (mapping)
xiangjai的专栏
10-15 1179
目录 1 映射的相关概念 1.1 什么是映射 1.2 映射的组成 1.3 元字段 1.4 字段的类型 2 如何配置mapping 2.1 创建mapping 2.2 更新mapping 2.3 查看mapping 1 映射的相关概念 1.1 什么是映射 (1) 映射(mapping): 定义index的元数据, 指定要索引并存储的文档的字段类型. 也就是说映射决定了Elasticsearch在建立倒排索引、进行检索时对文档采取的相关策略, 如数字类型、日期类型、文本类型等等.
elasticsearch 8.0 python使用API操作
vincent_duan的专栏
05-06 2882
1. 初始化es from elasticsearch import Elasticsearch es = Elasticsearch([{'host': '192.168.171.81', 'port': 9200}], timeout=3600) 2. 创建index request_body={ "mappings": { "properties": { "name": {"type": "keyword"}, "age": {"t
Es8.12Java基本操作
s1213_24548的博客
01-28 516
Java代码中操作ES8.1.2 基本操作 查询，添加删除 更新等操作
elasticsearch 学习笔记
08-19
elasticsearch 学习笔记包括以下内容: 一、Elasticsearch概述: - Elasticsearch是一种开源的分布式搜索和分析引擎，可以用于快速搜索、分析和存储大量的结构化和非结构化数据。 - Elasticsearch与Solr相比有一些区别，包括用户、开发和贡献者社区的规模和成熟度等方面。 二、Elasticsearch安装: 1. 下载Elasticsearch，可以从官方网站或华为云镜像下载。 2. 安装Elasticsearch。 三、安装head插件: - head插件是一个可视化的管理界面，可以方便地管理和监控Elasticsearch集群。 四、安装Kibana: 1. Kibana是一个开源的数据可视化工具，用于展示和分析Elasticsearch中的数据。 2. 下载Kibana并安装。 3. 启动Kibana并进行访问测试。 4. 可选的汉化操作。 五、ES核心概念理解: - 学习ES的核心概念，包括索引、文档、映射、查询等。 以上是elasticsearch学习笔记的主要内容，希望对你有帮助。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Elasticsearch 学习笔记（上）](https://blog.csdn.net/m0_52691962/article/details/127064350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xupengboo

你的鼓励将是我创作最大的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值