1、官网API地址https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/7.17/indexing.html
3、去重查询 [https://blog.csdn.net/qq_31286957/article/details/127598644]
4、多层bool嵌套查询

查询多层嵌套
BoolQuery.Builder boolQuery = new BoolQuery.Builder();
BoolQuery subBuild = subBoolQuery.build();
subBoolQuery.must(q -> q.term(t -> t.field(fieldName).value(groupKey)));
boolQuery.must(t -> t.bool(subBuild));
SearchResponse<JSONObject> search = elasticsearchClient.search(
            builder ->builder.index(EsIndexName)
                    .query(q ->q.bool(boolQuery.build()))
                            .size(1000), JSONObject.class);
List<Hit<JSONObject>> hits = search.hits().hits();
桶聚合多层嵌套
 SearchResponse<JSONObject> response = elasticsearchClient.search(s -> s
                        .index(EsIndexName)
                        .aggregations("aAggs", t -> t.terms(f -> f.field("a").size(10000))
                                .aggregations("bAggs", tt -> tt.terms(f -> f.field("b").size(20))))
                        .size(0)
                , JSONObject.class);
结果处理：
        Buckets<StringTermsBucket> buckets = response.aggregations().get("aAggs").sterms().buckets();
        for (StringTermsBucket b : buckets.array()) {
            System.out.println(b.key()._get() + " : " + b.docCount());
            Buckets<StringTermsBucket> bAggs= b.aggregations().get("bAggs").sterms().buckets();
            for (StringTermsBucket bb : bAggs.array()) {
                System.out.println("    " + bb.key()._get() + " : " + bb.docCount());
            }
        }

5、客户端连接配置工具类

       <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>7.17.9</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>

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.extern.slf4j.Slf4j;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.entity.ContentType;

import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.RestClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Component
@Slf4j
public class ElasticSearchConfiguration {
    @Autowired
    ElasticSearchProperties elasticsearchProperties;


    @Bean()
    public ElasticsearchClient elasticsearchClient() {
        String host = elasticsearchProperties.getHost();
        String[] hosts = host.split(",");
        HttpHost[] httpHosts = new HttpHost[hosts.length];
        for (int i = 0; i < httpHosts.length; i++) {
            String h = hosts[i];
            httpHosts[i] = new HttpHost(h.split(":")[0], Integer.parseInt(h.split(":")[1]), "http");
        }
        RestClient restClient = RestClient.builder(httpHosts)
                .setHttpClientConfigCallback(httpClientBuilder
                        ->httpClientBuilder.setDefaultHeaders(
                                listOf(new BasicHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString())))
                        .addInterceptorLast((HttpResponseInterceptor) (response, context)
                                -> response.addHeader("X-Elastic-Product", "Elasticsearch"))).build();
        ElasticsearchTransport transport = new RestClientTransport(
                restClient, new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);

    }
    public static <T> List<T> listOf(T... elements) {
        List<T> list = new ArrayList<>();
        for (T e : elements)
            list.add(e);
        return Collections.unmodifiableList(list);
    }
}

6、批量更新

 BulkRequest.Builder br = new BulkRequest.Builder();
 //循环处理
 for(){
	 JSONObject jsonObject = new JSONObject();
	 jsonObject.put("xxx",xxx);
	 br.operations(op -> op.update(idx -> idx.index(EsIndexName).id(id).action(a -> a
	                                .doc(jsonObject).docAsUpsert(true)
	                        ))).refresh(Refresh.True);
 }
 BulkResponse bulk = elasticsearchClient.bulk(br.build());

7. 范围查询

      BoolQuery.Builder boolQuery = new BoolQuery.Builder();
     if (StringUtils.isNoneBlank(updateTimeStart) || StringUtils.isNoneBlank(updateTimeEnd)) {
            RangeQuery.Builder rangeQuery = new RangeQuery.Builder();
            if (StringUtils.isNoneBlank(updateTimeStart)) {
                rangeQuery.field("update_time").gte(JsonData.of(updateTimeStart));
            }
            if (StringUtils.isNoneBlank(updateTimeEnd)) {
                rangeQuery.field("update_time").lte(JsonData.of(updateTimeEnd));
            }
            boolQuery.must(t -> t.range(rangeQuery.build()));
        }

8、字段排序

        String sortField =xxx.getSort_field();//传递的排序参数
        String sortType = xxx.getSort_type();//传递的排序参数
       FieldSort.Builder sortBuilder = new FieldSort.Builder();
        if (StringUtils.isNoneBlank(sortField)) {
            sortBuilder.field(sortField);
        } else {
            sortBuilder.field("id");
        }
        if (StringUtils.isNoneBlank(sortType)) {
            if (sortType.equals("asc")) {
                sortBuilder.order(SortOrder.Asc);
            } else if (sortType.equals("desc")) {
                sortBuilder.order(SortOrder.Desc);
            }
        } else {
            sortBuilder.order(SortOrder.Asc);
        }
        SortOptions.Builder sortOptionsBuilder = new SortOptions.Builder();
        sortOptionsBuilder.field(sortBuilder.build());
        BoolQuery build = boolQuery.build();
        SortOptions buildSort = sortOptionsBuilder.build();
        log.info("查询条件: {}", build.toString());
        log.info("排序条件: {}", buildSort.toString());
        SearchResponse<JSONObject> search = elasticsearchClient.search(builder ->
                        builder.index(ES_INDEX_NAME)
                                .query(q ->
                                        q.bool(build))
                                .from(start)
                                .size(size).sort(buildSort)
                , JSONObject.class);
        List<Hit<JSONObject>> hits = search.hits().hits();

9、聚合查询

 //聚合嵌套
   SearchResponse<JSONObject> response = elasticsearchClient.search(s -> s
                            .index("索引名称")
                            .query(q ->
                                    q.bool(boolQuery.build()))
                            .aggregations("聚合名称1", t -> t.terms(f -> f.field("字段名称1").size(10))
                                    .aggregations("聚合名称2", m -> m.sum(f2 -> f2.field("字段名称2"))))
                            .size(0)
                    , JSONObject.class);
            Aggregate accAggsGroup = response.aggregations().get("聚合名称1");
            Buckets<StringTermsBucket> buckets = accAggsGroup.sterms().buckets();
            for (StringTermsBucket termsBucket : buckets.array()) {
                String uuid = termsBucket.key()._get().toString();
                double sumCount = termsBucket.aggregations().get("聚合名称2").sum().value();
            }

kibana DSL

聚合 多字段
GET 索引名称/_search
{
  "size": 0,
  "query": {
   "match_all": {}
  },
  "aggs": {
    "SUM聚合名称1": {
      "sum": {
        "field": "字段名称1"
      }
    },
    "SUM聚合名称2": {
      "sum": {
        "field": "字段名称2"
      }
    }
  },
    "SUM聚合名称3": {
      "sum": {
        "field": "字段名称3"
      }
    }
  }
}

                SearchResponse<Void> response = elasticsearchClient.search(b -> b
                                .index("索引名称")
                                .size(0)
                                .query(q -> q.bool(build))
                                .aggregations("SUM聚合名称1", a -> a
                                        .sum(h -> h.field("字段名称1"))
                                ).aggregations("SUM名称2", a -> a
                                        .sum(h -> h.field("字段名称2"))
                                ).aggregations("SUM名称3", a -> a
                                        .sum(h -> h.field("字段名称3"))
                                ),
                        Void.class
                );
                double sumOne = response.aggregations().get("SUM聚合名称1").sum().value();
                double sumTwo = response.aggregations().get("SUM聚合名称2").sum().value();
                double sumThere = response.aggregations().get("SUM聚合名称3").sum().value();