es统计

src/main/java/cn/cslg/pas/factorys/EsAnalysisBuilderFactory/ChildAnalysisBuilder.java

@@ -35,6 +35,7 @@ public class ChildAnalysisBuilder implements IEsAnalysisBuilder {
             Query query = QueryBuilders.term(n -> n.field(field).value(fieldValue));
             queryList.add(query);
             Aggregation filters = AggregationBuilders.filters(n -> n.filters(m -> m.array(queryList)));
+//            Aggregation filters = AggregationBuilders.filter(n -> n.bool(k -> k.must(queryList)));
             Aggregation filterAgg = new Aggregation.Builder().terms(new TermsAggregation.Builder()
                     .field("custom_field.field_value.raw").build())
                     .aggregations(new HashMap() {{

src/main/java/cn/cslg/pas/factorys/EsAnalysisBuilderFactory/DateAnalysisBuilder.java

@@ -140,7 +140,6 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
                         rangeExpressions.add(expression);
                     }
                 } else {
-                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
                     String start = value.substring(0, value.indexOf("-")) + "-01";
                     String end = value.substring(value.indexOf("-") + 1);
                     String nextYear = String.valueOf(Integer.parseInt(end) + 1) + "-01";

src/main/java/cn/cslg/pas/factorys/EsCountBuilderFactory/ChildCountBuilder.java

@@ -6,8 +6,10 @@ import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 
 @Component
 public class ChildCountBuilder implements IEsCountBuilder{
@@ -24,48 +26,32 @@ public class ChildCountBuilder implements IEsCountBuilder{
     public Aggregation createAggregation() {
         Aggregation terms = null;
         if (ifHaveChild) {
-            if (StringUtils.isNotEmpty(valueOne)) {
-
-            } else {
-                Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.stats_value.raw").size(topN));
-
-                Query query = QueryBuilders.term(i -> i.field("custom_field.field").value(fieldId));
-                Aggregation filtersAgg = new Aggregation.Builder().filters(new FiltersAggregation.Builder()
-                        .filters(i -> i.array(Arrays.asList(query))).build())
-                        .aggregations(new HashMap() {{
-                            put("filters_agg", agg);
-                        }}).build();
-                terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
-                        .field(field).size(topN).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filtersAgg);
-                        }}).build();
+            Aggregation agg = null;
+            List<Query> queryList = new ArrayList<>();
+            if (StringUtils.isNotEmpty(valueOne) && StringUtils.isEmpty(valueTwo)) {
+                String str = "*";
+                String s = str.concat(valueOne).concat("*");
+                Query query = QueryBuilders.wildcard(i -> i.field("custom_field.field_value.raw").value(s));
+                queryList.add(query);
+            } else if (StringUtils.isNotEmpty(valueOne) && StringUtils.isNotEmpty(valueTwo)) {
+
             }
+            terms = this.getAggregation(queryList);
 
         } else {
+            Aggregation agg = null;
+            List<Query> queryList = new ArrayList<>();
             if (StringUtils.isNotEmpty(valueOne) && StringUtils.isEmpty(valueTwo)) {
                 String str = "*";
                 String s = str.concat(valueOne).concat("*");
                 Query query = QueryBuilders.wildcard(i -> i.field("custom_field.field_value.raw").value(s));
-                Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                queryList.add(query);
             } else if (StringUtils.isNotEmpty(valueOne) && StringUtils.isNotEmpty(valueTwo)) {
 
-            } else {
-                Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.field_value.raw").size(topN));
-                Query query = QueryBuilders.term(i -> i.field("custom_field.field").value(fieldId));
-                Aggregation filtersAgg = new Aggregation.Builder().filters(new FiltersAggregation.Builder()
-                        .filters(i -> i.array(Arrays.asList(query))).build())
-                        .aggregations(new HashMap() {{
-                            put("filters_agg", agg);
-                        }}).build();
-
-                terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
-                        .field(field).size(topN).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filtersAgg);
-                        }}).build();
             }
+            terms = this.getAggregation(queryList);
         }
+
         Aggregation finalTerms = terms;
         Aggregation aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
                 .type("project_customfield").build()).aggregations(new HashMap() {{
@@ -74,6 +60,31 @@ public class ChildCountBuilder implements IEsCountBuilder{
         return aggregation;
     }
 
+    /**
+     * 通用获取Aggregation
+     * @param queryList
+     * @return
+     */
+    private Aggregation getAggregation(List<Query> queryList) {
+        Query query = QueryBuilders.term(i -> i.field("custom_field.field").value(fieldId));
+        queryList.add(query);
+
+        Aggregation filtersAgg = AggregationBuilders.filter(n -> n.bool(k -> k.must(queryList)));
+
+        Aggregation termAgg = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                .field("custom_field.field_value.raw").build())
+                .aggregations(new HashMap() {{
+                    put("filterAgg", filtersAgg);
+                }}).build();
+
+        Aggregation terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                .field(field).size(topN).build())
+                .aggregations(new HashMap() {{
+                    put("filter_agg", termAgg);
+                }}).build();
+        return terms;
+    }
+
     @Override
     public String getField() {
         return field;

src/main/java/cn/cslg/pas/service/business/es/EsCountService.java

@@ -355,38 +355,23 @@ public class EsCountService {
     public void getChildCountDTOS(Aggregate agg, String field, List<EsCountDetailDTO> detailDTOS) {
         Aggregate childAgg = agg.children().aggregations().get("child_agg");
         List<StringTermsBucket> list = childAgg.sterms().buckets().array();
-        for (StringTermsBucket bucket : list) {
+        list.forEach(bucket -> {
             Aggregate aggregate = bucket.aggregations().get("filter_agg");
-            List<FiltersBucket> list1 = aggregate.filters().buckets().array();
-            for (FiltersBucket filtersBucket : list1) {
-                Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
-                List<StringTermsBucket> list2 = filtersAgg.sterms().buckets().array();
-                if (!CollectionUtils.isEmpty(list2)) {
-                    for (StringTermsBucket termsBucket : list2) {
-                        EsCountDetailDTO dto = new EsCountDetailDTO();
-                        dto.setField(field);
-                        dto.setName(termsBucket.key().stringValue());
-                        dto.setNumber(termsBucket.docCount());
-                        if (dto.getNumber() > 0) {
-                            detailDTOS.add(dto);
-                        }
+            List<StringTermsBucket> termsBuckets = aggregate.sterms().buckets().array();
+            termsBuckets.forEach(termsBucket -> {
+                Aggregate termAgg = termsBucket.aggregations().get("filterAgg");
+                long count = termAgg.filter().docCount();
+                if (count > 0) {
+                    EsCountDetailDTO dto = new EsCountDetailDTO();
+                    dto.setField(field);
+                    dto.setName(termsBucket.key().stringValue());
+                    dto.setNumber(count);
+                    if (dto.getNumber() > 0) {
+                        detailDTOS.add(dto);
                     }
                 }
-            }
-        }
-//        list.forEach(bucket -> {
-//            EsCountDetailDTO dto = new EsCountDetailDTO();
-//            dto.setField(field);
-//            Aggregate aggregate = bucket.aggregations().get("filter_agg");
-//            List<StringTermsBucket> buckets = aggregate.sterms().buckets().array();
-//            for (StringTermsBucket termsBucket : buckets) {
-//                dto.setName(termsBucket.key().stringValue());
-//                dto.setNumber(termsBucket.docCount());
-//                if (dto.getNumber() > 0) {
-//                    detailDTOS.add(dto);
-//                }
-//            }
-//        });
+            });
+        });
     }
 
     /**