es聚合分析

src/main/java/cn/cslg/pas/controller/PatentController.java

@@ -81,18 +81,11 @@ public class PatentController {
         return Response.success(patentPageMessageVOS);
     }
 
-//    @Operation(summary = "esSearch")
-//    @PostMapping("/esSearch")
-//    public Response esSearch(@RequestBody List<EsCustomFieldValueDTO> customFields) throws Exception {
-//        PatentDTO patentDTO = esService.esSearch(customFields);
+//    @Operation(summary = "esCount")
+//    @PostMapping("/esCount")
+//    public Response esCount(@RequestBody EsCountVO countVO) throws Exception {
+//        EsCountDTO patentDTO = esCountService.esCount(countVO);
 //        return Response.success(patentDTO);
 //    }
 
-    @Operation(summary = "esCount")
-    @PostMapping("/esCount")
-    public Response esCount(@RequestBody EsCountVO countVO) throws Exception {
-        EsCountDTO patentDTO = esCountService.esCount(countVO);
-        return Response.success(patentDTO);
-    }
-
 }

src/main/java/cn/cslg/pas/domain/es/Patent.java

@@ -182,7 +182,7 @@ public class Patent {
     private String simpleStatus;
 
     /**
-     * 类型
+     * 专利类型
      */
     @JsonProperty("patent_type")
     private String patentType;

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

@@ -0,0 +1,92 @@
+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.ChildrenAggregation;
+import co.elastic.clients.elasticsearch._types.aggregations.TermsAggregation;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+
+@Component
+public class ChildAnalysisBuilder implements IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    @Override
+    public Aggregation createAnalyseAgg() {
+        Aggregation terms;
+        if (ifHaveChild) {
+            Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.stats_value.raw").size(topN));
+            terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                    .field(field).size(topN).build())
+                    .aggregations(new HashMap() {{
+                        put("filter_agg", agg);
+                    }}).build();
+        } else {
+            Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.field_value.raw").size(topN));
+            terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                    .field(field).size(topN).build())
+                    .aggregations(new HashMap() {{
+                        put("filter_agg", agg);
+                    }}).build();
+        }
+
+        Aggregation aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
+                .type("project_customfield").build()).aggregations(new HashMap() {{
+            put("child_agg", terms);
+        }}).build();
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    public String getFieldValue() {
+        return fieldValue;
+    }
+
+    public void setFieldValue(String fieldValue) {
+        this.fieldValue = fieldValue;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+}

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

@@ -0,0 +1,122 @@
+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.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+
+@Component
+public class DateAnalysisBuilder implements IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    @Override
+    public Aggregation createAnalyseAgg() {
+//        Aggregation aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(fieldValue)) {
+            if (fieldValue.length() == 4) {
+                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+                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() == 6) {
+                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+                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("Q")) {
+                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+                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("H")) {
+
+            } else {
+                String start = fieldValue.substring(0, fieldValue.indexOf("-"));
+                String end = fieldValue.substring(fieldValue.indexOf("-"));
+                Query query = QueryBuilders.range(j -> j.field(field).from(start).to(end));
+                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();
+            }
+
+        }
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getFieldValue() {
+        return fieldValue;
+    }
+
+    @Override
+    public void setFieldValue(String fieldValue) {
+        this.fieldValue = fieldValue;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+}

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

@@ -0,0 +1,19 @@
+package cn.cslg.pas.factorys.EsAnalysisBuilderFactory;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+@Component
+public class EsAnalysisBuilderFactory {
+
+    @Autowired
+    private Map<String, IEsAnalysisBuilder> iEsAnalysisBuilderMap;
+
+
+    public IEsAnalysisBuilder getClass(String builderName) {
+        IEsAnalysisBuilder bean1 = iEsAnalysisBuilderMap.get(builderName);
+        return bean1;
+    }
+}

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

@@ -0,0 +1,33 @@
+package cn.cslg.pas.factorys.EsAnalysisBuilderFactory;
+
+import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
+
+public interface IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    public Aggregation createAnalyseAgg() throws Exception;
+
+    public String getField();
+
+    public void setField(String field);
+
+    public String getFieldValue();
+
+    public void setFieldValue(String fieldValue);
+
+    public Integer getTopN();
+
+    public void setTopN(Integer topN);
+
+    public String getPath();
+
+    public void setPath(String path);
+
+    public Boolean getIfHaveChild();
+
+    public void setIfHaveChild(Boolean ifHaveChild);
+}

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

@@ -0,0 +1,93 @@
+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.NestedAggregation;
+import co.elastic.clients.elasticsearch._types.aggregations.TermsAggregation;
+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 java.util.HashMap;
+
+@Component
+public class NestedAnalysisBuilder implements IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    @Override
+    public Aggregation createAnalyseAgg() {
+//        Aggregation terms = AggregationBuilders.terms(j -> j.field(field).size(topN));
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(fieldValue)) {
+            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() {{
+                        put("filter_agg", filter);
+                    }}).build();
+            aggregation = new Aggregation.Builder().nested(new NestedAggregation.Builder().
+                    path(path).build())
+                    .aggregations(new HashMap() {{
+                        put("terms_agg", finalTerms);
+                    }}).build();
+        }
+
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getFieldValue() {
+        return fieldValue;
+    }
+
+    @Override
+    public void setFieldValue(String fieldValue) {
+        this.fieldValue = fieldValue;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+}

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

@@ -0,0 +1,92 @@
+package cn.cslg.pas.factorys.EsAnalysisBuilderFactory;
+
+import co.elastic.clients.elasticsearch._types.aggregations.*;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import co.elastic.clients.json.JsonData;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+
+@Component
+public class RangeAnalysisBuilder implements IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    @Override
+    public Aggregation createAnalyseAgg() {
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(fieldValue)) {
+            if (fieldValue.contains("-")) {
+                String start = fieldValue.substring(0, fieldValue.indexOf("-"));
+                String end = fieldValue.substring(fieldValue.indexOf("-"));
+                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)));
+            }
+        }
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getFieldValue() {
+        return fieldValue;
+    }
+
+    @Override
+    public void setFieldValue(String fieldValue) {
+        this.fieldValue = fieldValue;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+}

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

@@ -0,0 +1,74 @@
+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.TermsAggregation;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+
+@Component
+public class TermsAnalysisBuilder implements IEsAnalysisBuilder {
+    public String field = "";
+    public String fieldValue = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+
+    @Override
+    public Aggregation createAnalyseAgg() {
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(fieldValue)) {
+//            Query q = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+//            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+            Aggregation filter = AggregationBuilders.filter(n -> n.term(m -> m.field(field).value(fieldValue)));
+            aggregation = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+                    .field(field).size(topN).build())
+                    .aggregations(new HashMap() {{
+                        put("filter_agg", filter);
+                    }}).build();
+        }
+        return aggregation;
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    public String getFieldValue() {
+        return fieldValue;
+    }
+
+    public void setFieldValue(String fieldValue) {
+        this.fieldValue = fieldValue;
+    }
+
+    public Integer getTopN() {
+        return topN;
+    }
+
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+}

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

@@ -35,18 +35,7 @@ public class ChildCountBuilder implements IEsCountBuilder{
                         put("filter_agg", agg);
                     }}).build();
         }
-        /*if (StringUtils.isNotEmpty(valueOne)) {
-            String str = "*";
-            String s = str.concat(valueOne).concat("*");
-            Query query = QueryBuilders.wildcard(i -> i.field(field).value(s));
-            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-            terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
-                    .field(field).size(topN).build())
-                    .aggregations(new HashMap() {{
-                        put("filter_agg", filter);
-                    }}).build();
-        }*/
-//        Aggregation finalTerms = terms;
+
         Aggregation aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
                 .type("project_customfield").build()).aggregations(new HashMap() {{
             put("child_agg", terms);

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

@@ -8,6 +8,8 @@ import cn.cslg.pas.common.utils.parseQueryToTree.treeNode;
 import cn.cslg.pas.common.vo.EsConfigVO;
 import cn.cslg.pas.common.vo.business.EsCountVO;
 import cn.cslg.pas.domain.es.Patent;
+import cn.cslg.pas.factorys.EsAnalysisBuilderFactory.EsAnalysisBuilderFactory;
+import cn.cslg.pas.factorys.EsAnalysisBuilderFactory.IEsAnalysisBuilder;
 import cn.cslg.pas.factorys.EsCountBuilderFactory.EsCountBuilderFactory;
 import cn.cslg.pas.factorys.EsCountBuilderFactory.IEsCountBuilder;
 import cn.cslg.pas.service.business.CommonService;
@@ -35,14 +37,18 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class EsCountService {
     private final List<String> childList = Arrays.asList("field");
-    private final List<String> nestedList = Arrays.asList("PA", "IN", "PE");
-    private final List<String> dateList = Arrays.asList("PD", "AD");
+    private final List<String> nestedList = Arrays.asList("PA", "IN", "PE", "SAT", "MAT", "SRH", "MRH");
+    private final List<String> dateList = Arrays.asList("PD", "AD", "GD");
+    private final List<String> numberList = Arrays.asList("QPN", "QDPN", "SFN", "IFN", "PFN");
+
 
     private final ElasticsearchClient client;
 
     @Autowired
     private EsCountBuilderFactory esCountBuilderFactory;
     @Autowired
+    private EsAnalysisBuilderFactory esAnalysisBuilderFactory;
+    @Autowired
     private FormatQueryService formatQueryService;
 
     /**
@@ -89,35 +95,35 @@ public class EsCountService {
                     List<FiltersBucket> filtersBuckets = agg.filters().buckets().array();
                     if (dateList.contains(field)) {
                         filtersBuckets.forEach(filtersBucket -> {
-                            this.getFiltersCountDTO(filtersBucket, condition,detailDTOS);
+                            this.getFiltersCountDTO(filtersBucket, condition, detailDTOS);
                             Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
-                            this.getDateCountDTOS(filtersAgg, field,topN,detailDTOS);
+                            this.getDateCountDTOS(filtersAgg, field, topN, detailDTOS);
                         });
                     } else if (nestedList.contains(field)) {
                         filtersBuckets.forEach(filtersBucket -> {
-                            this.getFiltersCountDTO(filtersBucket, condition,detailDTOS);
+                            this.getFiltersCountDTO(filtersBucket, condition, detailDTOS);
                             Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
-                            this.getNestedCountDTOS(filtersAgg, field,detailDTOS);
+                            this.getNestedCountDTOS(filtersAgg, field, detailDTOS);
                         });
                     } else if (childList.contains(field)) {
                         filtersBuckets.forEach(filtersBucket -> {
-                            this.getFiltersCountDTO(filtersBucket, condition,detailDTOS);
+                            this.getFiltersCountDTO(filtersBucket, condition, detailDTOS);
                             Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
-                            this.getChildCountDTOS(filtersAgg, field,detailDTOS);
+                            this.getChildCountDTOS(filtersAgg, field, detailDTOS);
                         });
                     } else {
                         filtersBuckets.forEach(filtersBucket -> {
-                            this.getFiltersCountDTO(filtersBucket, condition,detailDTOS);
+                            this.getFiltersCountDTO(filtersBucket, condition, detailDTOS);
                             Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
                             this.getTermCountDTOS(filtersAgg, field, detailDTOS);
                         });
                     }
                 } else {
-                    this.getFilterCountDTO(agg, condition,detailDTOS);
+                    this.getFilterCountDTO(agg, condition, detailDTOS);
                 }
             } else {
                 if (dateList.contains(field)) {
-                    this.getDateCountDTOS(agg, field,topN, detailDTOS);
+                    this.getDateCountDTOS(agg, field, topN, detailDTOS);
                 } else if (nestedList.contains(field)) {
                     this.getNestedCountDTOS(agg, field, detailDTOS);
                 } else if (childList.contains(field)) {
@@ -131,6 +137,57 @@ public class EsCountService {
         return esCountDTO;
     }
 
+    public EsCountDTO esAnalysisSearch(List<EsCountVO> countVOS) throws Exception {
+        EsCountDTO esCountDTO = new EsCountDTO();
+        List<EsCountDetailDTO> detailDTOS = new ArrayList<>();
+        for (EsCountVO vo : countVOS) {
+            String field = vo.getField();
+            Integer topN = vo.getTopN();
+            Boolean ifHaveChild = vo.getIfHaveChild();
+            List<String> values = vo.getValues();
+            //查询es返回数据
+            SearchRequest.Builder builder = new SearchRequest.Builder();
+            builder.index("patent");
+            IEsAnalysisBuilder iEsAnalysisBuilder = null;
+            String json = CommonService.readJsonFile("esAnalysis.json");
+            List<EsConfigVO> esConfigVOS = JSON.parseArray(json, EsConfigVO.class);
+            EsConfigVO esConfigVO = esConfigVOS.stream().filter(item -> item.getField().equals(field))
+                    .findFirst().orElse(null);
+            if (esConfigVO != null) {
+                iEsAnalysisBuilder = esAnalysisBuilderFactory.getClass(esConfigVO.getEsClass());
+                iEsAnalysisBuilder.setField(esConfigVO.getEsField());
+                iEsAnalysisBuilder.setTopN(topN);
+                iEsAnalysisBuilder.setIfHaveChild(ifHaveChild);
+                if (iEsAnalysisBuilder.getField().contains(".")) {
+                    String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
+                    iEsAnalysisBuilder.setPath(path);
+                }
+                for (String value : values) {
+                    iEsAnalysisBuilder.setFieldValue(value);
+                    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.getDateCountDTOS(agg, field, topN, detailDTOS);
+                    } else if (nestedList.contains(field)) {
+                        this.getNestedCountDTOS(agg, field, detailDTOS);
+                    } else if (childList.contains(field)) {
+                        this.getChildCountDTOS(agg, field, detailDTOS);
+                    } else if (childList.contains(field)) {
+                        this.getChildCountDTOS(agg, field, detailDTOS);
+                    } else {
+                        this.getTermCountDTOS(agg, field, detailDTOS);
+                    }
+
+                }
+            }
+        }
+        esCountDTO.setDetailDTOS(detailDTOS);
+        return esCountDTO;
+    }
+
     /**
      * 获取聚合后的aggregation
      *
@@ -170,11 +227,12 @@ public class EsCountService {
 
     /**
      * 获取Filter聚合返回数据
+     *
      * @param agg
      * @param condition
      * @return
      */
-    public void getFilterCountDTO(Aggregate agg,String condition,List<EsCountDetailDTO> detailDTOS) {
+    public void getFilterCountDTO(Aggregate agg, String condition, List<EsCountDetailDTO> detailDTOS) {
         EsCountDetailDTO filterDTO = new EsCountDetailDTO();
         filterDTO.setField("condition");
         filterDTO.setName(condition);
@@ -186,11 +244,12 @@ public class EsCountService {
 
     /**
      * 获取Filters聚合返回数据
+     *
      * @param filtersBucket
      * @param condition
      * @return
      */
-    public void getFiltersCountDTO(FiltersBucket filtersBucket,String condition,List<EsCountDetailDTO> detailDTOS) {
+    public void getFiltersCountDTO(FiltersBucket filtersBucket, String condition, List<EsCountDetailDTO> detailDTOS) {
         EsCountDetailDTO filtersDTO = new EsCountDetailDTO();
         filtersDTO.setField("condition");
         filtersDTO.setName(condition);
@@ -231,7 +290,7 @@ public class EsCountService {
      * @param field
      * @param detailDTOS
      */
-    public void getChildCountDTOS(Aggregate agg, String field,List<EsCountDetailDTO> detailDTOS) {
+    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 -> {
@@ -256,7 +315,7 @@ public class EsCountService {
      * @param field
      * @param detailDTOS
      */
-    public void getDateCountDTOS(Aggregate agg, String field,Integer topN,List<EsCountDetailDTO> detailDTOS) {
+    public void getDateCountDTOS(Aggregate agg, String field, Integer topN, List<EsCountDetailDTO> detailDTOS) {
         List<DateHistogramBucket> list = agg.dateHistogram().buckets().array();
         List<EsCountDetailDTO> esCountDetailDTOS = new ArrayList<>();
         list.forEach(bucket -> {
@@ -286,7 +345,7 @@ public class EsCountService {
      * @param field
      * @param detailDTOS
      */
-    public void getNestedCountDTOS(Aggregate agg, String field,List<EsCountDetailDTO> detailDTOS) {
+    public void getNestedCountDTOS(Aggregate agg, String field, List<EsCountDetailDTO> detailDTOS) {
         Aggregate termsAgg = agg.nested().aggregations().get("terms_agg");
         List<StringTermsBucket> list = termsAgg.sterms().buckets().array();
         list.forEach(bucket -> {

src/main/resources/jsons/esAnalysis.json

@@ -0,0 +1,566 @@
+[
+  {
+    "name": "IPC分类号一级",
+    "type": "String",
+    "value": "ipcLevel1",
+    "field": "IC",
+    "esField": "mipc.level1",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号二级",
+    "type": "String",
+    "value": "ipcLevel2",
+    "field": "IC2",
+    "esField": "mipc.level2",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号三级",
+    "type": "String",
+    "value": "ipcLevel3",
+    "field": "IC3",
+    "esField": "mipc.level3",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号四级",
+    "type": "String",
+    "value": "ipcLevel4",
+    "field": "IC4",
+    "esField": "mipc.level4",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号五级",
+    "type": "String",
+    "value": "ipcLevel5",
+    "field": "IC5",
+    "esField": "mipc.level5",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号一级",
+    "type": "String",
+    "value": "cpcLevel1",
+    "field": "CPC",
+    "esField": "mcpc.level1",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号二级",
+    "type": "String",
+    "value": "cpcLevel2",
+    "field": "CPC2",
+    "esField": "mcpc.level2",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号三级",
+    "type": "String",
+    "value": "cpcLevel3",
+    "field": "CPC3",
+    "esField": "mcpc.level3",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号四级",
+    "type": "String",
+    "value": "cpcLevel4",
+    "field": "CPC4",
+    "esField": "mcpc.level4",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号五级",
+    "type": "String",
+    "value": "cpcLevel5",
+    "field": "CPC5",
+    "esField": "mcpc.level5",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号一级",
+    "type": "String",
+    "value": "upcLevel1",
+    "field": "UPC",
+    "esField": "mupc.level1",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号二级",
+    "type": "String",
+    "value": "upcLevel2",
+    "field": "UPC2",
+    "esField": "mupc.level2",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号三级",
+    "type": "String",
+    "value": "upcLevel3",
+    "field": "UPC3",
+    "esField": "mupc.level3",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号一级",
+    "type": "String",
+    "value": "locLevel1",
+    "field": "LOC",
+    "esField": "mloc.level1",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号二级",
+    "type": "String",
+    "value": "locLevel2",
+    "field": "LOC2",
+    "esField": "mloc.level2",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号三级",
+    "type": "String",
+    "value": "locLevel3",
+    "field": "LOC3",
+    "esField": "mloc.level3",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人",
+    "type": "String",
+    "value": "applicant",
+    "field": "PA",
+    "esField": "applicant.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "标准申请人",
+    "type": "String",
+    "value": "standerApplicant",
+    "field": "SAT",
+    "esField": "stander_applicant.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "合并申请人",
+    "type": "String",
+    "value": "mergeApplicant",
+    "field": "MAT",
+    "esField": "merge_applicant.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人",
+    "type": "String",
+    "value": "rightHolder",
+    "field": "PE",
+    "esField": "right_holder.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "标准权利人",
+    "type": "String",
+    "value": "standerRightHolder",
+    "field": "SRH",
+    "esField": "stander_right_holder.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "合并权利人",
+    "type": "String",
+    "value": "mergeRightHolder",
+    "field": "MRH",
+    "esField": "merge_right_holder.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "发明人",
+    "type": "String",
+    "value": "inventor",
+    "field": "IN",
+    "esField": "inventor.name.key",
+    "esClass": "nestedAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "代理机构",
+    "type": "String",
+    "value": "agency",
+    "field": "AGN",
+    "esField": "agency",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "代理人名称",
+    "type": "String",
+    "value": "agent",
+    "field": "PT",
+    "esField": "agent.key",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "公开日",
+    "type": "Date",
+    "value": "publicDate",
+    "field": "PD",
+    "esField": "public_date",
+    "esClass": "dateAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请日",
+    "type": "String",
+    "value": "appDate",
+    "field": "AD",
+    "esField": "app_date",
+    "esClass": "dateAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "授权日",
+    "type": "String",
+    "value": "grantDate",
+    "field": "GD",
+    "esField": "grant_date",
+    "esClass": "dateAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请国家(受理局)",
+    "type": "String",
+    "value": "appCountry",
+    "field": "CO",
+    "esField": "app_country",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人国家",
+    "type": "String",
+    "value": "appCountry",
+    "field": "DZ",
+    "esField": "applicant_addr.country",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人省份",
+    "type": "String",
+    "value": "appProvince",
+    "field": "ADP",
+    "esField": "applicant_addr.province",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人市区",
+    "type": "String",
+    "value": "appCity",
+    "field": "ADC",
+    "esField": "applicant_addr.city",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人国家",
+    "type": "String",
+    "value": "rightCountry",
+    "field": "rightCountry",
+    "esField": "right_holder_addr.country",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人省份",
+    "type": "String",
+    "value": "rightProvince",
+    "field": "rightProvince",
+    "esField": "right_holder_addr.province",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人市区",
+    "type": "String",
+    "value": "rightCity",
+    "field": "rightCity",
+    "esField": "right_holder_addr.city",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "优先权国家",
+    "type": "String",
+    "value": "priorityCountry",
+    "field": "PC",
+    "esField": "priorities.prioritycountry",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "引用专利数量",
+    "type": "Integer",
+    "value": "quotePatentNoNum",
+    "field": "QPN",
+    "esField": "quote_patent_no_num",
+    "esClass": "rangeAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "被引用专利数量",
+    "type": "Integer",
+    "value": "quotedPatentNoNum",
+    "field": "QDPN",
+    "esField": "quoted_patent_no_num",
+    "esClass": "rangeAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "简单同族数量",
+    "type": "Integer",
+    "value": "simpleFamilyNum",
+    "field": "SFN",
+    "esField": "simple_family_num",
+    "esClass": "rangeAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "inpadoc同族数量",
+    "type": "Integer",
+    "value": "inpadocFamilyNum",
+    "field": "IFN",
+    "esField": "inpadoc_family_num",
+    "esClass": "rangeAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "扩展同族数量",
+    "type": "Integer",
+    "value": "patsnapFamilyNum",
+    "field": "PFN",
+    "esField": "patsnap_family_num",
+    "esClass": "rangeAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "专利状态",
+    "type": "String",
+    "value": "simpleStatus",
+    "field": "SS",
+    "esField": "simple_status",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "专利类型",
+    "type": "String",
+    "value": "patentType",
+    "field": "PT",
+    "esField": "patent_type",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "法律状态",
+    "type": "String",
+    "value": "legalStatus",
+    "field": "LG",
+    "esField": "legal_status",
+    "esClass": "termsAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位id",
+    "type": "String",
+    "value": "field",
+    "field": "field",
+    "esField": "custom_field.field",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位值",
+    "type": "String",
+    "value": "fieldValue",
+    "field": "fieldValue",
+    "esField": "custom_field.field_value.raw",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位统计值",
+    "type": "String",
+    "value": "statsValue",
+    "field": "statsValue",
+    "esField": "custom_field.stats_value.raw",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  }
+]