es统计分析

src/main/java/cn/cslg/pas/common/vo/business/EsCountVO.java

@@ -10,6 +10,8 @@ public class EsCountVO {
     private String condition;
     //栏位
     private String field;
+    //栏位
+    private String fieldId;
     //自定义栏位类型
     private Integer fieldType;
     //统计搜索的栏位值1

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

@@ -32,15 +32,24 @@ public class ChildAnalysisBuilder implements IEsAnalysisBuilder {
                 Query q = QueryBuilders.term(i -> i.field("custom_field.field_value.raw").value(value));
                 queryList.add(q);
             }
-            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.should(queryList)));
+            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 filterAgg = new Aggregation.Builder().terms(new TermsAggregation.Builder()
-                    .field(field).size(topN).build())
+                    .field("custom_field.field_value.raw").build())
                     .aggregations(new HashMap() {{
-                        put("filter_agg", filter);
+                        put("filterAgg", filters);
                     }}).build();
+
+            Aggregation Agg = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                    .field(field).build())
+                    .aggregations(new HashMap() {{
+                        put("term_agg", filterAgg);
+                    }}).build();
+
             aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
                     .type("project_customfield").build()).aggregations(new HashMap() {{
-                put("child_agg", filterAgg);
+                put("child_agg", Agg);
             }}).build();
         }
 

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

@@ -1,13 +1,11 @@
 package cn.cslg.pas.factorys.EsAnalysisBuilderFactory;
 
-import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
-import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
-import co.elastic.clients.elasticsearch._types.aggregations.CalendarInterval;
-import co.elastic.clients.elasticsearch._types.aggregations.DateHistogramAggregation;
+import co.elastic.clients.elasticsearch._types.aggregations.*;
 import co.elastic.clients.elasticsearch._types.query_dsl.Query;
 import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
@@ -30,160 +28,132 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
     @Override
     public Aggregation createAnalyseAgg() throws ParseException {
         Aggregation aggregation = null;
-        if (StringUtils.isNotEmpty(fieldValue)) {
+        List<DateRangeExpression> rangeExpressions = new ArrayList<>();
+
+        if (!CollectionUtils.isEmpty(values)) {
             Calendar calendar = Calendar.getInstance();
-            if (fieldValue.length() == YEAR) {
-                SimpleDateFormat format = new SimpleDateFormat("yyyy");
-                Date year = format.parse(fieldValue);
-                calendar.setTime(year);
-                calendar.add(Calendar.YEAR, 1);
-                Date yearDate = calendar.getTime();
-                String nextYear = format.format(yearDate);
-                Query query = QueryBuilders.range(j -> j.field(field).from(fieldValue).to(nextYear).format("yyyy"));
-                Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                        .field(field).format("yyyy")
-                        .calendarInterval(CalendarInterval.Year).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filter);
-                        }}).build();
-            } else if (fieldValue.length() == MONTH && !fieldValue.contains("Q")
-                    && !fieldValue.contains("H")) {
-                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                Date month = format.parse(fieldValue);
-                calendar.setTime(month);
-                calendar.add(Calendar.MONTH, 1);
-                Date monthDate = calendar.getTime();
-                String nextMonth = format.format(monthDate);
-                Query query = QueryBuilders.range(j -> j.field(field).from(fieldValue).to(nextMonth).format("yyyy-MM"));
-                Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                        .field(field).format("yyyy-MM")
-                        .calendarInterval(CalendarInterval.Month).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filter);
-                        }}).build();
-
-            } else if (fieldValue.length() == MONTH && fieldValue.contains("Q")) {
-                if (fieldValue.contains("Q1")) {
-                    String firstQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String firstQuarterDate = firstQuarter + "-01";
-                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date quarter = format.parse(firstQuarterDate);
-                    calendar.setTime(quarter);
-                    calendar.add(Calendar.MONTH, 3);
-                    Date quarterDate = calendar.getTime();
-                    String nextQuarterDate = format.format(quarterDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(firstQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Quarter).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
-                } else if (fieldValue.contains("Q2")) {
-                    String secondQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String secondQuarterDate = secondQuarter + "-04";
+            for (String value : values) {
+                if (value.length() == YEAR) {
                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date quarter = format.parse(secondQuarterDate);
-                    calendar.setTime(quarter);
-                    calendar.add(Calendar.MONTH, 3);
-                    Date quarterDate = calendar.getTime();
-                    String nextQuarterDate = format.format(quarterDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(secondQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Quarter).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
-                } else if (fieldValue.contains("Q3")) {
-                    String thirdQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String thirdQuarterDate = thirdQuarter + "-07";
+                    String startYear = value + "-01";
+                    Date year = format.parse(startYear);
+                    calendar.setTime(year);
+                    calendar.add(Calendar.YEAR, 1);
+                    Date yearDate = calendar.getTime();
+                    String nextYear = format.format(yearDate);
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(startYear));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextYear));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+                } else if (value.length() == MONTH && !value.contains("Q")
+                        && !value.contains("H")) {
                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date quarter = format.parse(thirdQuarterDate);
-                    calendar.setTime(quarter);
-                    calendar.add(Calendar.MONTH, 3);
-                    Date quarterDate = calendar.getTime();
-                    String nextQuarterDate = format.format(quarterDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(thirdQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Quarter).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
-                } else if (fieldValue.contains("Q4")) {
-                    String fourthQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String fourthQuarterDate = fourthQuarter + "-10";
-                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date quarter = format.parse(fourthQuarterDate);
-                    calendar.setTime(quarter);
-                    calendar.add(Calendar.MONTH, 3);
-                    Date quarterDate = calendar.getTime();
-                    String nextQuarterDate = format.format(quarterDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(fourthQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Quarter).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
-                }
-            } else if (fieldValue.length() == MONTH && fieldValue.contains("H")) {
-                if (fieldValue.contains("H1")) {
-                    String firstHalfYear = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String firstHalfYearDate = firstHalfYear + "-01";
+                    Date month = format.parse(value);
+                    calendar.setTime(month);
+                    calendar.add(Calendar.MONTH, 1);
+                    Date monthDate = calendar.getTime();
+                    String nextMonth = format.format(monthDate);
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(value));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextMonth));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+                } else if (value.length() == MONTH && value.contains("Q")) {
+                    if (value.contains("Q1")) {
+                        String firstQuarter = value.substring(0, value.indexOf("-"));
+                        String firstQuarterDate = firstQuarter + "-01";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date quarter = format.parse(firstQuarterDate);
+                        calendar.setTime(quarter);
+                        calendar.add(Calendar.MONTH, 3);
+                        Date quarterDate = calendar.getTime();
+                        String nextQuarterDate = format.format(quarterDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(firstQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q2")) {
+                        String secondQuarter = value.substring(0, value.indexOf("-"));
+                        String secondQuarterDate = secondQuarter + "-04";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date quarter = format.parse(secondQuarterDate);
+                        calendar.setTime(quarter);
+                        calendar.add(Calendar.MONTH, 3);
+                        Date quarterDate = calendar.getTime();
+                        String nextQuarterDate = format.format(quarterDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(secondQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q3")) {
+                        String thirdQuarter = value.substring(0, value.indexOf("-"));
+                        String thirdQuarterDate = thirdQuarter + "-07";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date quarter = format.parse(thirdQuarterDate);
+                        calendar.setTime(quarter);
+                        calendar.add(Calendar.MONTH, 3);
+                        Date quarterDate = calendar.getTime();
+                        String nextQuarterDate = format.format(quarterDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(thirdQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q4")) {
+                        String fourthQuarter = value.substring(0, value.indexOf("-"));
+                        String fourthQuarterDate = fourthQuarter + "-10";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date quarter = format.parse(fourthQuarterDate);
+                        calendar.setTime(quarter);
+                        calendar.add(Calendar.MONTH, 3);
+                        Date quarterDate = calendar.getTime();
+                        String nextQuarterDate = format.format(quarterDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(fourthQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    }
+                } else if (value.length() == MONTH && value.contains("H")) {
+                    if (value.contains("H1")) {
+                        String firstHalfYear = value.substring(0, value.indexOf("-"));
+                        String firstHalfYearDate = firstHalfYear + "-01";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date halfYear = format.parse(firstHalfYearDate);
+                        calendar.setTime(halfYear);
+                        calendar.add(Calendar.MONTH, 6);
+                        Date halfYearDate = calendar.getTime();
+                        String nextHalfYearDate = format.format(halfYearDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(firstHalfYearDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextHalfYearDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("H2")) {
+                        String secondHalfYear = value.substring(0, value.indexOf("-"));
+                        String secondHalfYearDate = secondHalfYear + "-07";
+                        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                        Date halfYear = format.parse(secondHalfYearDate);
+                        calendar.setTime(halfYear);
+                        calendar.add(Calendar.MONTH, 6);
+                        Date halfYearDate = calendar.getTime();
+                        String nextHalfYearDate = format.format(halfYearDate);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(secondHalfYearDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextHalfYearDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    }
+                } else {
                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date halfYear = format.parse(firstHalfYearDate);
-                    calendar.setTime(halfYear);
-                    calendar.add(Calendar.MONTH, 6);
-                    Date halfYearDate = calendar.getTime();
-                    String nextHalfYearDate = format.format(halfYearDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(firstHalfYearDate).to(nextHalfYearDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Month).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
-                } else if (fieldValue.contains("H2")) {
-                    String secondHalfYear = fieldValue.substring(0, fieldValue.indexOf("-"));
-                    String secondHalfYearDate = secondHalfYear + "-07";
-                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
-                    Date halfYear = format.parse(secondHalfYearDate);
-                    calendar.setTime(halfYear);
-                    calendar.add(Calendar.MONTH, 6);
-                    Date halfYearDate = calendar.getTime();
-                    String nextHalfYearDate = format.format(halfYearDate);
-                    Query query = QueryBuilders.range(j -> j.field(field).from(secondHalfYearDate).to(nextHalfYearDate).format("yyyy-MM"));
-                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                            .field(field).format("yyyy-MM")
-                            .calendarInterval(CalendarInterval.Month).build())
-                            .aggregations(new HashMap() {{
-                                put("filter_agg", filter);
-                            }}).build();
+                    String start = value.substring(0, value.indexOf("-")) + "-01";
+                    String end = value.substring(value.indexOf("-") + 1);
+                    String nextYear = String.valueOf(Integer.parseInt(end) + 1) + "-01";
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(start));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextYear));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+
                 }
-            } else {
-                String start = fieldValue.substring(0, fieldValue.indexOf("-"));
-                String end = fieldValue.substring(fieldValue.indexOf("-") + 1);
-                String nextYear = String.valueOf(Integer.parseInt(end) + 1);
-                Query query = QueryBuilders.range(j -> j.field(field).from(start).to(nextYear).format("yyyy"));
-                Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                        .field(field).format("yyyy")
-                        .calendarInterval(CalendarInterval.Year).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filter);
-                        }}).build();
             }
         }
+        aggregation = AggregationBuilders.dateRange(i -> i.field(field).format("yyyy-MM").ranges(rangeExpressions));
+
         return aggregation;
     }
 

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

@@ -33,8 +33,6 @@ public class NestedAnalysisBuilder implements IEsAnalysisBuilder {
                 queryList.add(q);
             }
             Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.should(queryList)));
-//            Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
-//            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
             Aggregation finalTerms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
                     .field(field).size(topN).build())
                     .aggregations(new HashMap() {{

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

@@ -23,46 +23,27 @@ public class RangeAnalysisBuilder implements IEsAnalysisBuilder {
 
     @Override
     public Aggregation createAnalyseAgg() {
+        List<AggregationRange> ranges = new ArrayList<>();
         Aggregation aggregation = null;
-        if (!CollectionUtils.isEmpty(values)) {
-            List<Query> queryList = new ArrayList<>();
             for (String value : values) {
                 if (value.contains("-")) {
                     String start = value.substring(0, value.indexOf("-"));
                     String end = value.substring(value.indexOf("-") + 1);
-//                    end = String.valueOf(Integer.parseInt(end) + 1);
-//                    String finalEnd = end;
-                    Query query = QueryBuilders.range(i -> i.field(field).from(start).to(end));
-                    queryList.add(query);
+                    end = String.valueOf(Integer.parseInt(end) + 1);
+                    String finalEnd = end;
+                    AggregationRange range = AggregationRange.of(i -> i.from(start).to(finalEnd).key(value));
+                    ranges.add(range);
                 } else if (value.contains("以上")) {
                     String start = value.substring(0, value.indexOf("以上"));
-                    Query query = QueryBuilders.range(i -> i.field(field).from(start));
-                    queryList.add(query);
+                    AggregationRange range = AggregationRange.of(i -> i.from(start).key(value));
+                    ranges.add(range);
                 } else {
-//                    String end = String.valueOf(Integer.parseInt(value) + 1);
-                    Query query = QueryBuilders.range(i -> i.field(field).from(value).to(value));
-                    queryList.add(query);
+                    String end = String.valueOf(Integer.parseInt(value) + 1);
+                    AggregationRange range = AggregationRange.of(i -> i.from(value).to(end).key(value));
+                    ranges.add(range);
                 }
             }
-            aggregation = AggregationBuilders.filter(n -> n.bool(k -> k.should(queryList)));
-
-//            if (fieldValue.contains("-")) {
-//                String start = fieldValue.substring(0, fieldValue.indexOf("-"));
-//                String end = fieldValue.substring(fieldValue.indexOf("-") + 1);
-//                end = String.valueOf(Integer.parseInt(end) + 1);
-//                String finalEnd = end;
-//                aggregation = AggregationBuilders.range(i -> i.field(field)
-//                        .ranges(j -> j.from(start).to(finalEnd)));
-//            } else if (fieldValue.contains("以上")) {
-//                String start = fieldValue.substring(0, fieldValue.indexOf("以上"));
-//                aggregation = AggregationBuilders.range(i -> i.field(field)
-//                        .ranges(j -> j.from(start)));
-//            } else {
-//                String end = String.valueOf(Integer.parseInt(fieldValue) + 1);
-//                aggregation = AggregationBuilders.range(i -> i.field(field)
-//                        .ranges(j -> j.from(fieldValue).to(end)));
-//            }
-        }
+        aggregation = AggregationBuilders.range(i -> i.field(field).ranges(ranges));
         return aggregation;
     }
 

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

@@ -18,6 +18,7 @@ public class ChildCountBuilder implements IEsCountBuilder{
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
     @Override
     public Aggregation createAggregation() {
@@ -27,7 +28,8 @@ public class ChildCountBuilder implements IEsCountBuilder{
 
             } 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_type").value(fieldType));
+
+                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() {{
@@ -41,16 +43,22 @@ public class ChildCountBuilder implements IEsCountBuilder{
             }
 
         } else {
-            if (StringUtils.isNotEmpty(valueOne)) {
+            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)));
+            } else if (StringUtils.isNotEmpty(valueOne) && StringUtils.isNotEmpty(valueTwo)) {
 
             } 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_type").value(fieldType));
+                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() {{
@@ -131,4 +139,12 @@ public class ChildCountBuilder implements IEsCountBuilder{
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -20,6 +20,7 @@ public class DateHistogramBuilder implements IEsCountBuilder{
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
     @Override
     public Aggregation createAggregation() {
@@ -94,4 +95,14 @@ public class DateHistogramBuilder implements IEsCountBuilder{
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -13,6 +13,7 @@ public class FilterCountBuilder implements IEsCountBuilder{
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
 
     @Override
@@ -94,4 +95,14 @@ public class FilterCountBuilder implements IEsCountBuilder{
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -12,6 +12,7 @@ public interface IEsCountBuilder {
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
     public Aggregation createAggregation() throws Exception;
 
@@ -42,4 +43,8 @@ public interface IEsCountBuilder {
     public String getFieldType();
 
     public void setFieldType(String fieldType);
+
+    public String getFieldId();
+
+    public void setFieldId(String fieldId);
 }

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

@@ -18,6 +18,7 @@ public class NestedCountBuilder implements IEsCountBuilder {
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
     @Override
     public Aggregation createAggregation() {
@@ -112,4 +113,14 @@ public class NestedCountBuilder implements IEsCountBuilder {
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -12,6 +12,7 @@ public class RangeCountBuilder implements IEsCountBuilder{
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
 
     @Override
     public Aggregation createAggregation() {
@@ -77,4 +78,14 @@ public class RangeCountBuilder implements IEsCountBuilder{
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -20,6 +20,8 @@ public class TermsCountBuilder implements IEsCountBuilder{
     public String path = "";
     public Boolean ifHaveChild = false;
     public String fieldType = null;
+    public String fieldId = null;
+
     @Override
     public Aggregation createAggregation() {
         Aggregation aggregation = AggregationBuilders.terms(i -> i.field(field).size(topN));
@@ -107,4 +109,14 @@ public class TermsCountBuilder implements IEsCountBuilder{
     public void setFieldType(String fieldType) {
         this.fieldType = fieldType;
     }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
 }

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

@@ -150,7 +150,9 @@ public class EsCountService {
             String field = vo.getField();
             Integer topN = vo.getTopN();
             Boolean ifHaveChild = vo.getIfHaveChild();
+            String fieldId = vo.getFieldId();
             List<String> values = vo.getValues();
+
             //查询es返回数据
             SearchRequest.Builder builder = new SearchRequest.Builder();
             builder.index("patent");
@@ -164,28 +166,28 @@ public class EsCountService {
                 iEsAnalysisBuilder.setField(esConfigVO.getEsField());
                 iEsAnalysisBuilder.setTopN(topN);
                 iEsAnalysisBuilder.setIfHaveChild(ifHaveChild);
-                for (String value : values) {
-                    if (iEsAnalysisBuilder.getField().contains(".")) {
-                        String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
-                        iEsAnalysisBuilder.setPath(path);
-                    }
-                    iEsAnalysisBuilder.setFieldValue(value);
-                    Aggregation aggregation = iEsAnalysisBuilder.createAnalyseAgg();
-                    builder.aggregations("Agg", aggregation);
-                    SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+                iEsAnalysisBuilder.setFieldValue(fieldId);
+                if (iEsAnalysisBuilder.getField().contains(".")) {
+                    String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
+                    iEsAnalysisBuilder.setPath(path);
+                }
+                iEsAnalysisBuilder.setValues(values);
 
-                    Aggregate agg = response.aggregations().get("Agg");
-                    if (dateList.contains(field)) {
-                        this.getDateAnalysisDTOS(agg, field, value, topN, detailDTOS);
-                    } else if (nestedList.contains(field)) {
-                        this.getNestedCountDTOS(agg, field, detailDTOS);
-                    } else if (childList.contains(field)) {
-                        this.getChildAnalysisDTOS(agg, field, value, detailDTOS);
-                    } else if (numberList.contains(field)) {
-                        this.getNumberAnalysisDTOS(agg, field, value, detailDTOS);
-                    } else {
-                        this.getTermCountDTOS(agg, field, detailDTOS);
-                    }
+                Aggregation aggregation = iEsAnalysisBuilder.createAnalyseAgg();
+                builder.aggregations("Agg", aggregation);
+                SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+
+                Aggregate agg = response.aggregations().get("Agg");
+                if (dateList.contains(field)) {
+                    this.getDateAnalysisDTOS(agg, field, topN, detailDTOS);
+                } else if (nestedList.contains(field)) {
+                    this.getNestedCountDTOS(agg, field, detailDTOS);
+                } else if (childList.contains(field)) {
+                    this.getChildAnalysisDTOS(agg, field, detailDTOS);
+                } else if (numberList.contains(field)) {
+                    this.getNumberAnalysisDTOS(agg, field,detailDTOS);
+                } else {
+                    this.getTermCountDTOS(agg, field, detailDTOS);
                 }
             }
         }
@@ -193,12 +195,14 @@ public class EsCountService {
         return esCountDTO;
     }
 
+    //测试用的
     public EsCountDTO esAnalysis(EsCountVO vo) throws Exception {
         EsCountDTO esCountDTO = new EsCountDTO();
         List<EsCountDetailDTO> detailDTOS = new ArrayList<>();
         String field = vo.getField();
         Integer topN = vo.getTopN();
         Boolean ifHaveChild = vo.getIfHaveChild();
+        String fieldId = vo.getFieldId();
         List<String> values = vo.getValues();
 
         //查询es返回数据
@@ -214,6 +218,7 @@ public class EsCountService {
             iEsAnalysisBuilder.setField(esConfigVO.getEsField());
             iEsAnalysisBuilder.setTopN(topN);
             iEsAnalysisBuilder.setIfHaveChild(ifHaveChild);
+            iEsAnalysisBuilder.setFieldValue(fieldId);
             if (iEsAnalysisBuilder.getField().contains(".")) {
                 String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
                 iEsAnalysisBuilder.setPath(path);
@@ -226,17 +231,13 @@ public class EsCountService {
 
             Aggregate agg = response.aggregations().get("Agg");
             if (dateList.contains(field)) {
-//                this.getDateAnalysisDTOS(agg, field, value, topN, detailDTOS);
+                this.getDateAnalysisDTOS(agg, field, topN, detailDTOS);
             } else if (nestedList.contains(field)) {
                 this.getNestedCountDTOS(agg, field, detailDTOS);
             } else if (childList.contains(field)) {
-                for (String value : values) {
-                    this.getChildAnalysisDTOS(agg, field, value, detailDTOS);
-                }
+                this.getChildAnalysisDTOS(agg, field, detailDTOS);
             } else if (numberList.contains(field)) {
-//                for (String value : values) {
-//                    this.getNumberAnalysisDTOS(agg, field, value, detailDTOS);
-//                }
+                this.getNumberAnalysisDTOS(agg, field,detailDTOS);
             } else {
                 this.getTermCountDTOS(agg, field, detailDTOS);
             }
@@ -260,6 +261,7 @@ public class EsCountService {
         Boolean ifHaveChild = vo.getIfHaveChild();
         String field = vo.getField();
         Integer fieldType = vo.getFieldType();
+        String fieldId = vo.getFieldId();
         Aggregation aggregation = null;
 
         builder.index("patent");
@@ -270,6 +272,7 @@ public class EsCountService {
         if (esConfigVO != null) {
             iEsCountBuilder = esCountBuilderFactory.getClass(esConfigVO.getEsClass());
             iEsCountBuilder.setField(esConfigVO.getEsField());
+            iEsCountBuilder.setFieldId(fieldId);
             iEsCountBuilder.setValueOne(valueOne);
             iEsCountBuilder.setValueTwo(valueTwo);
             iEsCountBuilder.setTopN(topN);
@@ -352,19 +355,38 @@ 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();
-        list.forEach(bucket -> {
-            EsCountDetailDTO dto = new EsCountDetailDTO();
-            dto.setField(field);
+        for (StringTermsBucket bucket : list) {
             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);
+            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.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);
+//                }
+//            }
+//        });
     }
 
     /**
@@ -372,22 +394,35 @@ public class EsCountService {
      *
      * @param agg
      * @param field
-     * @param value
      * @param detailDTOS
      */
-    public void getChildAnalysisDTOS(Aggregate agg, String field, String value, List<EsCountDetailDTO> detailDTOS) {
+    public void getChildAnalysisDTOS(Aggregate agg, String field, List<EsCountDetailDTO> detailDTOS) {
         Aggregate childAgg = agg.children().aggregations().get("child_agg");
         List<StringTermsBucket> list = childAgg.sterms().buckets().array();
-        list.forEach(bucket -> {
-            EsCountDetailDTO dto = new EsCountDetailDTO();
-            dto.setField(field);
-            Aggregate aggregate = bucket.aggregations().get("filter_agg");
-            dto.setName(value);
-            dto.setNumber(aggregate.filter().docCount());
-            if (dto.getNumber() > 0) {
-                detailDTOS.add(dto);
+        for (StringTermsBucket bucket : list) {
+            Aggregate termAgg = bucket.aggregations().get("term_agg");
+            List<StringTermsBucket> bucketList = termAgg.sterms().buckets().array();
+            if (!CollectionUtils.isEmpty(bucketList)) {
+                for (StringTermsBucket termsBucket : bucketList) {
+                    EsCountDetailDTO dto = new EsCountDetailDTO();
+                    dto.setField(field);
+                    dto.setName(termsBucket.key().stringValue());
+                    Aggregate aggregate = termsBucket.aggregations().get("filterAgg");
+                    List<FiltersBucket> filtersBuckets = aggregate.filters().buckets().array();
+                    for (int i = 0; i < filtersBuckets.size() - 1; i++) {
+                        FiltersBucket filtersBucket = filtersBuckets.get(i);
+                        if (filtersBucket.docCount() > 0) {
+                            dto.setNumber(filtersBucket.docCount());
+                            if (dto.getNumber() > 0) {
+                                detailDTOS.add(dto);
+                            }
+                            break;
+                        }
+                    }
+                }
             }
-        });
+
+        }
     }
 
     /**
@@ -395,16 +430,18 @@ public class EsCountService {
      *
      * @param agg
      * @param field
-     * @param value
      * @param detailDTOS
      */
-    public void getNumberAnalysisDTOS(Aggregate agg, String field, String value, List<EsCountDetailDTO> detailDTOS) {
-        EsCountDetailDTO dto = new EsCountDetailDTO();
-        dto.setField(field);
-        dto.setName(value);
-        dto.setNumber(agg.filter().docCount());
-        if (dto.getNumber() > 0) {
-            detailDTOS.add(dto);
+    public void getNumberAnalysisDTOS(Aggregate agg, String field,List<EsCountDetailDTO> detailDTOS) {
+        List<RangeBucket> list = agg.range().buckets().array();
+        for (RangeBucket bucket : list) {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            dto.setName(bucket.key());
+            dto.setNumber(bucket.docCount());
+            if (dto.getNumber() > 0) {
+                detailDTOS.add(dto);
+            }
         }
     }
 
@@ -443,43 +480,21 @@ public class EsCountService {
      *
      * @param agg
      * @param field
-     * @param value
      * @param topN
      * @param detailDTOS
      */
-    public void getDateAnalysisDTOS(Aggregate agg, String field, String value, Integer topN, List<EsCountDetailDTO> detailDTOS) {
-        List<DateHistogramBucket> list = agg.dateHistogram().buckets().array();
+    public void getDateAnalysisDTOS(Aggregate agg, String field, Integer topN, List<EsCountDetailDTO> detailDTOS) {
+        List<RangeBucket> list1 = agg.dateRange().buckets().array();
         List<EsCountDetailDTO> esCountDetailDTOS = new ArrayList<>();
-        if (value.contains("H")) {
-            long sum = 0L;
-            for (DateHistogramBucket bucket : list) {
-                Aggregate aggregate = bucket.aggregations().get("filter_agg");
-                long docCount = aggregate.filter().docCount();
-                sum += docCount;
-            }
+        for (RangeBucket bucket : list1) {
             EsCountDetailDTO dto = new EsCountDetailDTO();
             dto.setField(field);
-            dto.setName(value);
-            dto.setNumber(sum);
+            dto.setName(bucket.key());
+            dto.setNumber(bucket.docCount());
             if (dto.getNumber() > 0) {
                 esCountDetailDTOS.add(dto);
             }
-        } else {
-            list.forEach(bucket -> {
-                EsCountDetailDTO dto = new EsCountDetailDTO();
-                dto.setField(field);
-                Aggregate aggregate = bucket.aggregations().get("filter_agg");
-                dto.setName(value);
-                dto.setNumber(bucket.docCount());
-                if (aggregate != null) {
-                    dto.setNumber(aggregate.filter().docCount());
-                }
-                if (dto.getNumber() > 0) {
-                    esCountDetailDTOS.add(dto);
-                }
-            });
         }
-
         if (!CollectionUtils.isEmpty(esCountDetailDTOS)) {
             List<EsCountDetailDTO> collect = esCountDetailDTOS.stream()
                     .sorted(Comparator.comparing(EsCountDetailDTO::getName).reversed()).limit(topN).collect(Collectors.toList());