es聚合统计

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

@@ -20,7 +20,7 @@ public class DateHistogramBuilder implements IEsCountBuilder{
     public Aggregation createAggregation() {
         Aggregation aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
         if (StringUtils.isNotEmpty(valueTwo)) {
-            Query query = QueryBuilders.range(j -> j.from(valueOne).to(valueTwo));
+            Query query = QueryBuilders.range(j -> j.field(field).from(valueOne).to(valueTwo));
             Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
             aggregation.aggregations().put("filter_agg",filter);
         }

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

@@ -0,0 +1,75 @@
+package cn.cslg.pas.factorys.EsCountBuilderFactory;
+
+import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
+import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
+import co.elastic.clients.elasticsearch._types.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+
+public class FilterCountBuilder implements IEsCountBuilder{
+    public String field = "";
+    public String valueOne = "";
+    public String valueTwo = "";
+    public Integer topN = 10;
+    public String path = "";
+
+
+    @Override
+    public Aggregation createAggregation() {
+        String str = "*";
+        String s = str.concat(valueOne).concat("*");
+        Query query = QueryBuilders.wildcard(i -> i.field(field).value(s));
+        AggregationBuilders.filter(n -> n.term(m -> m.field(field).value(valueOne)));
+//        AggregationBuilders.filters(n -> n.filters(m -> m.array()));
+        return AggregationBuilders.filter(i -> i.bool(j -> j.must(query)));
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getValueOne() {
+        return valueOne;
+    }
+
+    @Override
+    public void setValueOne(String valueOne) {
+        this.valueOne = valueOne;
+    }
+
+    @Override
+    public String getValueTwo() {
+        return valueTwo;
+    }
+
+    @Override
+    public void setValueTwo(String valueTwo) {
+        this.valueTwo = valueTwo;
+    }
+
+    @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;
+    }
+}

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

@@ -17,6 +17,8 @@ public class NestedCountBuilder implements IEsCountBuilder {
 
     @Override
     public Aggregation createAggregation() {
+
+
         Aggregation terms = AggregationBuilders.terms(j -> j.field(field).size(topN));
         if (StringUtils.isNotEmpty(valueOne)) {
             Query query = QueryBuilders.term(j -> j.field(field).value(valueOne));

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

@@ -17,6 +17,7 @@ public class TermsCountBuilder implements IEsCountBuilder{
 
     @Override
     public Aggregation createAggregation() {
+
         Aggregation aggregation = AggregationBuilders.terms(i -> i.field(field).size(topN));
         if (StringUtils.isNotEmpty(valueOne)) {
             Query query = QueryBuilders.term(j -> j.field(field).value(valueOne));

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

@@ -62,11 +62,14 @@ public class EsCountService {
                 String path = iEsCountBuilder.getField().substring(0, iEsCountBuilder.getField().indexOf("."));
                 iEsCountBuilder.setPath(path);
             }
-            Aggregation aggregation = iEsCountBuilder.createAggregation();
 
         }
+//        AggregationBuilders.t
+        Aggregation aggregation = iEsCountBuilder.createAggregation();
+        builder.aggregations("Agg", aggregation);
         SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
-        Aggregate aggregate = response.aggregations().get("");
+        Aggregate agg = response.aggregations().get("Agg");
+
         return esCountDTO;
     }
 }

src/test/java/cn/cslg/pas/service/EventServiceTests.java

@@ -12,7 +12,13 @@ import cn.cslg.pas.domain.es.FamilyPatent;
 import cn.cslg.pas.domain.es.PatentFamilyMessage;
 import cn.cslg.pas.service.business.ProductMarketDataService;
 import cn.cslg.pas.service.business.es.EsService;
+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.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.http.entity.ContentType;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -199,7 +205,54 @@ public class EventServiceTests {
 
     @Test
     void test5() throws IOException {
-        SelectClaimDTO dto = esService.selectClaim("CN102324864A");
-        System.out.println(dto);
+//        SelectClaimDTO dto = esService.selectClaim("CN102324864A");
+//        System.out.println(dto);
+
+        Aggregation range = AggregationBuilders.range(n -> n.field("app_date").format("yyyy"));
+        Aggregation aggregation = AggregationBuilders.dateHistogram(i -> i.field("app_date").format("yyyy").calendarInterval(CalendarInterval.Year));
+        Query query = QueryBuilders.range(j -> j.field("app_date").from("2021").to("2023"));
+        Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+        aggregation.aggregations().put("filter_agg",filter);
+
+        System.out.println(aggregation);
+
+    }
+
+    @Test
+    void test6() {
+        String valueOne = "H02";
+        Aggregation aggregation = AggregationBuilders.terms(i -> i.field("mipc.level2").size(10));
+        if (StringUtils.isNotEmpty(valueOne)) {
+            Query query = QueryBuilders.term(j -> j.field("mipc.level2").value(valueOne));
+            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+            Map<String, Aggregation> map = aggregation.aggregations();
+            System.out.println(map + "----------------");
+            map.put("filter_agg", filter);
+            System.out.println(map);
+        }
+        System.out.println(aggregation);
+    }
+
+    @Test
+    void test7() {
+        String valueOne = "";
+        Aggregation terms = AggregationBuilders.terms(j -> j.field("applicant.name.key").size(10));
+        if (StringUtils.isNotEmpty(valueOne)) {
+            Query query = QueryBuilders.term(j -> j.field("applicant.name.key").value(valueOne));
+            Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+            terms.aggregations().put("filter_agg",filter);
+        }
+        Aggregation aggregation = AggregationBuilders.nested(i -> i.path("applicant")).aggregations().put("terms_agg", terms);
+        System.out.println(aggregation);
+    }
+
+    @Test
+    void test8() {
+        String valueOne = "";
+        String str = "*";
+        String s = str.concat(valueOne).concat("*");
+        Query query = QueryBuilders.wildcard(i -> i.field("").value(s));
+        Aggregation aggregation = AggregationBuilders.filter(i -> i.bool(j -> j.must(query)));
+        System.out.println(aggregation);
     }
 }