springboot2.7集成es8 https方式绕过证书访问集群

版本说明

项目	Value
spring-boot	2.7.13
es	8.12.2

配置文件

spring:
   elasticsearch:
     uris: https://192.168.1.110:30920
     username: elastic
     password: 123456

依赖文件

子pom.xml引入elasticsearch-java依赖

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

如果出现版本问题，父pom.xml修改依赖声明

      <jakarta-json.version>2.0.1</jakarta-json.version>
      <elasticsearch.version>8.12.2</elasticsearch.version>

   
    <dependencyManagement>
       <dependencies>
       <dependency>
                <groupId>jakarta.json</groupId>
                <artifactId>jakarta.json-api</artifactId>
                <version>${jakarta-json.version}</version>
            </dependency>

            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-client</artifactId>
                <version>${elasticsearch.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

配置类

import cn.hutool.core.util.StrUtil;
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 lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.*;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.HttpRequestWrapper;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.RestClient;
import org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.net.ssl.SSLContext;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.List;


@Configuration
@Slf4j
@RequiredArgsConstructor
public class ElasticSearchConfig {

    private final ElasticsearchProperties elasticsearchProperties;

    @Bean
    public RestClient restClient() throws Exception {
        List<String> urlList = elasticsearchProperties.getUris();
        HttpHost[] httpHosts = new HttpHost[urlList.size()];
        for (int i = 0; i < urlList.size(); i++) {
            String item = urlList.get(i);
            URI uri = URI.create(item);
            httpHosts[i] = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
        }

        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(elasticsearchProperties.getUsername(), elasticsearchProperties.getPassword()));

        SSLContext sslContext = SSLContextBuilder.create()
            .loadTrustMaterial((chain, authType) -> true)
            .build();

        return RestClient.builder(httpHosts)
            .setHttpClientConfigCallback(httpClientBuilder -> {
                // 添加拦截器来打印请求
                httpClientBuilder.addInterceptorFirst((HttpRequestInterceptor) (request, context) -> {
                    RequestLine requestLine = request.getRequestLine();
                    String uri = requestLine.getUri();
                    String method = requestLine.getMethod();
                    String body = null;
                    if (request instanceof HttpRequestWrapper) {
                        HttpRequest originalRequest = ((HttpRequestWrapper) request).getOriginal();
                        if (originalRequest instanceof HttpEntityEnclosingRequest) {
                            HttpEntity entity = ((HttpEntityEnclosingRequest) originalRequest).getEntity();
                            if (entity != null) {
                                ContentType contentType = ContentType.get(entity);
                                if (contentType != null && StrUtil.contains(contentType.getMimeType(), "json")) {
                                    body = EntityUtils.toString(entity, StandardCharsets.UTF_8);
                                }
                            }
                        }
                    }
                    log.info("发送es请求，Method：{}，uri：{}，请求体：{}", method, uri, body);
                });
                httpClientBuilder.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                    .setSSLContext(sslContext)
                    .setDefaultCredentialsProvider(credentialsProvider);
                return httpClientBuilder;
            })
            .setRequestConfigCallback(requestConfigBuilder -> requestConfigBuilder
                .setConnectTimeout(5000)
                .setSocketTimeout(60000)).build();
    }


    @Bean
    public ElasticsearchClient elasticsearchClient() throws Exception {
        RestClient restClient = restClient();
        ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);
    }


}

示例

import cn.hutool.core.collection.CollUtil;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.FieldValue;
import co.elastic.clients.elasticsearch._types.SortOptions;
import co.elastic.clients.elasticsearch._types.SortOptionsBuilders;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.query_dsl.*;
import co.elastic.clients.elasticsearch.cat.IndicesResponse;
import co.elastic.clients.elasticsearch.cat.indices.IndicesRecord;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.json.JsonData;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
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.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


@SpringBootTest // 此注解只能在 springboot 主包下使用 需包含 main 方法与 yml 配置文件
@DisplayName("Es测试")
@Slf4j
public class EsTest {

    @Autowired
    private ElasticsearchClient elasticsearchClient;

    @DisplayName("查询索引")
    @Test
    public void test1() throws IOException {
        IndicesResponse indices = elasticsearchClient.cat().indices();
        for (IndicesRecord record : indices.valueBody()) {
            log.info(record.toString());
        }
    }


    @DisplayName("文档查询")
    @Test
    public void test2() throws IOException {
        String indexName = "logstash-*";
        int pageSize = 10;
        List<Query> mustQueryList = new ArrayList<>();

//        时间范围查询
        LocalDateTime startTime = LocalDateTime.of(2024, 3, 19, 0, 0, 0);
        LocalDateTime endTime = LocalDateTime.of(2024, 3, 21, 0, 0, 0);
        Query rangeQuery = RangeQuery.of(m -> m
            .field("@timestamp")
            .gte(JsonData.of(ZonedDateTime.of(startTime, ZoneId.systemDefault()).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)))
            .lte(JsonData.of(ZonedDateTime.of(endTime, ZoneId.systemDefault()).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)))
        )._toQuery();
        mustQueryList.add(rangeQuery);



//        TermsQuery terms多值精确查询
        FieldValue fieldValue1 = FieldValue.of("zhang san");
        FieldValue fieldValue2 = FieldValue.of("li si");
        List<FieldValue> fieldValueList = Arrays.asList(fieldValue1,fieldValue2);
        Query termsQuery = TermsQuery.of(m -> m
            .field("name")
            .terms(t2 -> t2.value(fieldValueList))
        )._toQuery();
        mustQueryList.add(termsQuery);

//        TermQuery 精确匹配
        Query termQuery = TermQuery.of(m -> m
            .field("pod_name")
            .value("my-pod")
        )._toQuery();
        mustQueryList.add(termQuery);

//               MatchQuery 分词匹配查询
        Query matchQuery = MatchQuery.of(m -> m
            .field("message")
            .query("keyword")
        )._toQuery();
        mustQueryList.add(matchQuery);

//        WildcardQuery 通配符搜索
        Query wildcardQuery = WildcardQuery.of(m -> m
            .field("container_ame")
            .value("f*es")
        )._toQuery();
        mustQueryList.add(wildcardQuery);
//            WildcardQuery 前缀搜索
        Query prefixQuery = PrefixQuery.of(m -> m
            .field("container_ame")
            .value("fl")
        )._toQuery();
        mustQueryList.add(prefixQuery);

//        排序
        List<SortOptions> sortOptionsList = new ArrayList<>();
        sortOptionsList.add(SortOptionsBuilders.field(s -> s.field("@timestamp").order(SortOrder.Desc)));

        List<FieldValue> searchAfter = new ArrayList<>();

        SearchResponse<LogstashResDTO> response = elasticsearchClient.search(s -> {
            s.index(indexName)
                .size(pageSize)
                .query(q -> q
                    .bool(b -> b
                        .must(mustQueryList)
                    )
                );

            if (CollUtil.isNotEmpty(sortOptionsList)) {
                s.sort(sortOptionsList);
            }

            if (CollUtil.isNotEmpty(searchAfter)) {
                s.searchAfter(searchAfter);
            }

            return s;
        }, LogstashResDTO.class);

        List<Hit<LogstashResDTO>> hits = response.hits().hits();
        for (Hit<LogstashResDTO> hit : hits) {
            LogstashResDTO source = hit.source();
            log.info(source.toString());
        }
    }

}

LogstashResDTO

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Map;


@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class LogstashResDTO implements Serializable {

    private static final long serialVersionUID = 1L;

    private Kubernetes kubernetes;

    @JsonProperty("@timestamp")
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    private LocalDateTime timestamp;

    private String stream;

    private String tag;

    private String message;

    private Docker docker;

    // 嵌套类
    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Kubernetes {
        @JsonProperty("container_name")
        private String containerName;

        @JsonProperty("namespace_name")
        private String namespaceName;

        @JsonProperty("pod_name")
        private String podName;

        @JsonProperty("container_image")
        private String containerImage;

        @JsonProperty("container_image_id")
        private String containerImageId;

        @JsonProperty("pod_id")
        private String podId;

        @JsonProperty("pod_ip")
        private String podIp;

        @JsonProperty("host")
        private String host;

        @JsonProperty("master_url")
        private String masterUrl;

        @JsonProperty("namespace_id")
        private String namespaceId;

        @JsonProperty("namespace_labels")
        private Map<String, String> namespaceLabels;

        @JsonProperty("labels")
        private Map<String, String> labels;
    }

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Docker {
        @JsonProperty("container_id")
        private String containerId;
    }

}

时间反序列化：LocalDateTimeDeserializer

import com.fasterxml.jackson.core.JacksonException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
    @Override
    public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JacksonException {
        String dateTimeString = p.getValueAsString();
        ZonedDateTime zonedDateTime = ZonedDateTime.parse(dateTimeString, DateTimeFormatter.ISO_DATE_TIME);
        ZonedDateTime beijingTime = zonedDateTime.withZoneSameInstant(ZoneId.systemDefault());
        return beijingTime.toLocalDateTime();
    }

}