{ "size": 0, "aggs": { "group_by_city": { "terms": { "field": "source.geo.city_name", "size": 100 }, "aggs": { "unique_ips": { "cardinality": { "field": "source.ip" } }, "sort_by_unique_ips": { "bucket_sort": { "sort": [ { "unique_ips": { "order": "desc" } } ], "size": 10 } } } } } } 怎么用java api完成这个查询

可以使用Elasticsearch官方提供的Java客户端API来完成这个查询。以下是一个示例代码：

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
import org.elasticsearch.search.aggregations.pipeline.bucketmetrics.BucketSortPipelineAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class ElasticsearchAggregationExample {
    public static void main(String[] args) throws IOException {
        RestHighLevelClient client = new RestHighLevelClient();

        SearchRequest searchRequest = new SearchRequest("my-index");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        // 设置查询条件
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        // 构建聚合查询
        TermsAggregationBuilder groupByCity =
            AggregationBuilders.terms("group_by_city")
                .field("source.geo.city_name")
                .size(100)
                .subAggregation(
                    AggregationBuilders.cardinality("unique_ips")
                        .field("source.ip")
                )
                .subAggregation(
                    new BucketSortPipelineAggregationBuilder("sort_by_unique_ips")
                        .sort(
                            AggregationBuilders
                                .subAggregation("unique_ips")
                                .order("desc")
                        )
                        .size(10)
                        .from(0)
                        .gapPolicy(BucketSortPipelineAggregationBuilder.GapPolicy.SKIP)
                );

        searchSourceBuilder.aggregation(groupByCity);

        // 设置查询参数
        searchSourceBuilder.size(0);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        searchSourceBuilder.trackTotalHits(true);

        searchRequest.source(searchSourceBuilder);

        // 执行查询
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        // 处理查询结果
        // ...

        client.close();
    }
}

以上代码中，首先创建了一个`RestHighLevelClient`对象，然后创建了一个`SearchRequest`对象，并设置了查询的索引名为`my-index`。接着使用`SearchSourceBuilder`构建了查询条件，这里使用了一个`matchAllQuery`来查询所有文档。

接下来，使用`AggregationBuilders`构建了一个聚合查询，这个聚合查询包含了一个`terms`聚合和两个子聚合。`terms`聚合按照`source.geo.city_name`字段进行分组，并设置了分组大小为`100`。其中，第一个子聚合是一个`cardinality`聚合，用于计算每个分组中不同的`source.ip`的数量。第二个子聚合是一个`bucket_sort`聚合，用于根据第一个子聚合的结果进行排序，并只返回前`10`个分组。

最后，将构建好的查询对象执行查询，并对查询结果进行处理。注意，在实际使用中需要根据具体情况来设置查询参数和处理查询结果。