ES的简单筛选功能以及java API调用方式

最新推荐文章于 2024-02-04 10:47:19 发布

哦到凯呀

最新推荐文章于 2024-02-04 10:47:19 发布

阅读量753

点赞数

分类专栏： elasticsearch 文章标签： es elasticsearch java

本文链接：https://blog.csdn.net/lisen01070107/article/details/115750954

版权

elasticsearch 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

ES的简单筛选功能以及java API调用方式

<!--es客户端-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.6.2</version>
        </dependency>

// client的注入
@Provides
    @Singleton
    RestHighLevelClient restHighLevelClient(Properties properties) {
        String host = properties.getProperty(PropertiesKeyConstants.ES_CONFIG_HOST);
        String port = properties.getProperty(PropertiesKeyConstants.ES_CONFIG_PORT);
        String username = properties.getProperty(PropertiesKeyConstants.ES_CONFIG_USERNAME);
        String password = properties.getProperty(PropertiesKeyConstants.ES_CONFIG_PASSWORD);
        int portInt = 9200;
        if (StringUtil.isNotBlank(port)) {
            portInt = Integer.parseInt(port);
        }
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
        RestClientBuilder builder = RestClient.builder(new HttpHost(host, portInt, "http"))
                .setHttpClientConfigCallback(requestConfig -> requestConfig.setKeepAliveStrategy((response, context) ->
                        TimeUnit.MINUTES.toMillis(1)));
        builder.setHttpClientConfigCallback(f -> f.setDefaultCredentialsProvider(credentialsProvider));
        RestHighLevelClient client = new RestHighLevelClient(builder);
        return client;
    }

# 流量总览 浏览量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }} 
      ]
    }},
  "from": 0,
  "size": 0
}


# 流量总览 点击量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACCLIK"
        }} 
      ]
    }},
  "from": 0,
  "size": 0
}

# 流量总览 访客数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }} 
      ]
    }},
    "aggs":{
     "_A_": {
       "cardinality": {
          "field": "t.keyword"
        }
     }
  },
  "from": 0,
  "size": 0
}


# 流量总览 平均停留时长/用户数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }} 
      ]
    }},
    "aggs":{
     "_A_": {
       "sum": {
          "field": "acData.leave"
        }
     }
  },
  "from": 0,
  "size": 0
}


# 流量总览 跳失率只访问一次的用户数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "SELF"
        }},
        {
          "match": {
            "acData.status": "true"
          }
        }
      ]
    }}
  ,
  "from": 0,
  "size": 10
}



# 实时分析 浏览量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 1614581014000,
                      "lt": 1616481741500
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "from": 0,
  "size": 0
}



# 实时分析 点击量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACCLIK"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 1614581014000,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "from": 0,
  "size": 1
}


# 实时分析 访客数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 1614581014000,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "cardinality": {
        "field": "t.keyword"
      }
    }
  }, 
  "from": 0,
  "size": 1
}


# 实时分析 平均停留时长
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 1614581014000,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
   "aggs":{
     "_A_": {
       "sum": {
          "field": "acData.leave"
        }
     }
  },
  "from": 0,
  "size": 1
}



# 实时分析 跳失率
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "SELF"
        }},
        {
          "match": {
            "acData.status": "true"
          }
        },
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.sTme": {
                      "gte": 1591760011268,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "from": 0,
  "size": 10
}



# 页面流量排行 浏览量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }}
      
      ]
    }}
  ,
  "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        }
     }
  },
  "from": 0,
  "size": 0
}


# 页面流量排行 点击量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACCLIK"
        }}
      
      ]
    }}
  ,
  "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        }
     }
  },
  "from": 0,
  "size": 0
}


# 页面流量排行 访客量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }}
      
      ]
    }}
  ,
   "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        },
        "aggs": {
          "_B_": {
            "cardinality": {
              "field": "t.keyword"
            }
          }
        }
     }
  },
  "from": 0,
  "size": 0
}


# 页面流量排行 停留时长（平均需要除用户数）
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }}
      
      ]
    }}
  ,
   "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        },
        "aggs": {
          "_B_": {
            "sum": {
              "field": "acData.leave"
            }
          }
        }
     }
  },
  "from": 0,
  "size": 1
}

# 页面流量排行 跳失率
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "SELF"
        }},
        {
          "match": {
            "acData.status": "true"
          }
        }
      
      ]
    }}
  ,
   "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        }
     }
  },
  "from": 0,
  "size": 1
}

# 流量趋势 浏览量
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 0,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "terms": {
        "field": "acData.date",
        "order": {
          "_term": "asc"
        }
      }
    }
  }, 
  "from": 0,
  "size": 0
}

# 流量趋势 点击数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACCLIK"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.sTme": {
                      "gte": 0,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "terms": {
        "field": "acData.date",
        "order": {
          "_term": "asc"
        }
      }
    }
  }, 
  "from": 0,
  "size": 10
}

# 流量趋势 访客数
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 0,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "terms": {
        "field": "acData.date",
        "order": {
          "_term": "asc"
        }
      },
       "aggs": {
          "_B_": {
            "cardinality": {
              "field": "t.keyword"
            }
          }
        }
    }
  }, 
 
  "from": 0,
  "size": 10
}

# 流量趋势 停留时间
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }},
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.inTime": {
                      "gte": 1614581014000,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "terms": {
        "field": "acData.date"
      },
       "aggs": {
          "_B_": {
            "sum": {
              "field": "acData.leave"
            }
          }
        }
    }
  }, 
  "from": 0,
  "size": 0
}

# 流量趋势 跳失率
GET wx_bury_point_test_2021_3_19_02/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "SELF"
        }
        },
        {
          "match": {
            "acData.status": "true"
          }
        },
        {
          "bool": {
            "filter": {
               "range": {
                    "acData.sTme": {
                      "gte": 0,
                      "lt": 1616481814000
                    }
                }
            }
          }
        }
      ]
    }}
  ,
  "aggs": {
    "_A_": {
      "terms": {
        "field": "acData.date"
      }
    }
  }, 
  "from": 0,
  "size": 0
}

import io.vertx.core.json.JsonArray;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.ParsedCardinality;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.elasticsearch.search.aggregations.metrics.ParsedValueCount;
import org.elasticsearch.search.aggregations.metrics.ValueCountAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

import javax.inject.Inject;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author lisen
 * @Date 2021/3/13 11:14
 */
@Slf4j
@RequiredArgsConstructor(onConstructor = @__(@Inject))
public class ElasticSearchServiceImpl implements ElasticSearchService {

    private final RedissonClient redissonClient;
    private final RestHighLevelClient client;
    private final Sequence sequence;
    private final JwtTokenProvider jwtTokenProvider;
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    private SimpleDateFormat simpleDate = new SimpleDateFormat("MM/dd");

    private TimeValue timeoutTime = TimeValue.timeValueSeconds(60);

    @Override
    @SneakyThrows
    public Boolean createIndex(String indexName) {
        //1.创建索引的请求
        CreateIndexRequest request = new CreateIndexRequest(indexName);
        //2客户端执行请求，请求后获得响应
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        return response != null;
    }

    @Override
    @SneakyThrows
    public Boolean deleteIndex(String indexName) {
        DeleteIndexRequest request = new DeleteIndexRequest(indexName);
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        return delete.isAcknowledged();
    }

    @Override
    @SneakyThrows
    public String addDocument(String indexName, Object ro) {
        List<String> addDocumentList = new ArrayList<>();
        IndexRequest request = new IndexRequest(indexName);
        //将数据放到json字符串
        request.id(sequence.getStringId());
        //设置超时时间
        request.timeout(timeoutTime);
        request.source(JSON.toJSONString(ro), XContentType.JSON);
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        log.info("添加埋点文档数据:{},添加状态:{}", response.toString(), response.status());
        addDocumentList.add(response.toString());
        return JSON.toJSONString(addDocumentList);
    }

    @Override
    @SneakyThrows
    public Boolean batchAddDocument(String indexName, JsonArray ro) {
        String userId = jwtTokenProvider.parseToken(((HashMap) ro.getList().get(0)).get("t") + "").get("userId") + "";
        RLock lockReward = redissonClient.getLock(RedisConstant.ES_BURY_POINT_LOCK + userId);
        try {
            lockReward.tryLock(3, TimeUnit.SECONDS);
            BulkRequest request = new BulkRequest(); //批量操作的Request
            request = this.dealSavePointInfos(ro, userId, indexName, request);
            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
            TimeUnit.MILLISECONDS.sleep(50);
            return !response.hasFailures();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new GrpcCommonException(e.getMessage(), ErrorCode.NORMAL_SERVER_ERROR);
        } finally {
            if (lockReward.isLocked() && lockReward.isHeldByCurrentThread()) {
                lockReward.unlock();
            }
        }
    }

    private BulkRequest dealSaveType(Map<String, String> map, String indexName, HashMap obj, String userId,
                                     BulkRequest request, String type) {
        HashMap acData = (HashMap) (obj).get("acData");
        EsDocumentInfoDTO dto = this.searchDocumentInfo(map, indexName);
        if (dto == null) {
            HashMap<String, Object> mapInfo = this.dealSelfMapJson(acData, userId, obj.get("uuid") + "", "true", type);
            request.add(new IndexRequest(indexName).id(sequence.getStringId())
                    .source(JSON.toJSONString(mapInfo), XContentType.JSON));
        } else {
            this.dealUpdateDocument(dto, indexName); // 更新文档的值 status置为false
        }
        return request;
    }

    private void dealUpdateDocument(EsDocumentInfoDTO dto, String indexName) {
        Map<String, Object> mapInfo = dto.getMap();
        HashMap acDataMapInfo = (HashMap) mapInfo.get("acData");
        if ("true".equals(acDataMapInfo.get("status"))) {
            acDataMapInfo.put("status", "false");
            this.updateDocument(mapInfo, indexName, dto.getId());
        }
    }


    private HashMap<String, Object> dealSelfMapJson(HashMap acData, String userId, String uuid, String status, String type) {
        HashMap<String, Object> mapInfo = new LinkedHashMap<>();
        HashMap<String, Object> mapInfoAct = new HashMap<>();
        mapInfo.put("uuid", uuid);
        mapInfo.put("t", userId);
        mapInfoAct.put("type", type);
        mapInfoAct.put("sTme", acData.get("sTme"));
        mapInfoAct.put("fromPath", acData.get("fromPath"));
        mapInfoAct.put("date", simpleDateFormat.format(new Date(Long.valueOf(acData.get("sTme") + ""))));
        mapInfoAct.put("status", status);
        mapInfo.put("acData", mapInfoAct);
        return mapInfo;
    }

    private BulkRequest dealSavePointInfos(JsonArray ro, String userId, String indexName, BulkRequest request) {
        for (int i = 0; i < ro.getList().size(); i++) { //批量处理请求
            HashMap obj = (HashMap) ro.getList().get(i);
            HashMap acData = (HashMap) (obj).get("acData");
            String type = acData.get("type") + "";
            if ("ACPAGE".equals(type) || "ACCLIK".equals(type)) {
                Long inTime = 0L, outTime = 0L;
                if ("ACPAGE".equals(type)) {
                    inTime = Long.valueOf(acData.get("inTime") + "");
                    outTime = Long.valueOf(acData.get("outTime") + "");
                    Long endTime = outTime - inTime;
                    int leaveTime = 0;
                    if (!(inTime == 0 || outTime == 0)) {
                        leaveTime = endTime.intValue();
                    }
                    acData.put("leave", leaveTime);
                    acData.put("fromPath", (acData.get("fromPath") + "").split("-")[0]);
                    Map<String, String> map = new HashMap<>(); // 类型为自定义的 存在 就将一个值置位false 否则为true
                    map.put("acData.type", EsConstants.INDEX_TYPE_PATH);
                    map.put("t", userId);
                    map.put("acData.fromPath.keyword", (acData.get("fromPath") + "").split("-")[0] + "");
                    request = this.dealSaveType(map, indexName, obj, userId, request, EsConstants.INDEX_TYPE_PATH); // 增加路径的跳失数据
                    Map<String, String> mapDay = new HashMap<>(); // 类型为自定义的 存在 就将一个值置位false 否则为true
                    mapDay.put("acData.type", EsConstants.INDEX_TYPE_DAY);
                    mapDay.put("t", userId);
                    mapDay.put("acData.date", simpleDateFormat.format(new Date(Long.valueOf(acData.get("sTme") + ""))));
                    request = this.dealSaveType(mapDay, indexName, obj, userId, request, EsConstants.INDEX_TYPE_DAY); // 增加日期的跳失数据
                    Map<String, String> mapView = new HashMap<>(); // 类型为自定义的 存在 就将一个值置位false 否则为true
                    mapView.put("acData.type", EsConstants.INDEX_TYPE_VIEW);
                    mapView.put("t", userId);
                    request = this.dealSaveType(mapView, indexName, obj, userId, request, EsConstants.INDEX_TYPE_VIEW); // 增加日期的跳失数据
                }
                if ("ACCLIK".equals(type)) {
                    inTime = Long.valueOf(acData.get("sTme") + "");
                    String[] arr = (acData.get("path") + "").split("#");
                    acData.put("fromPath", arr.length > 0 ? arr[arr.length - 1] : "");
                }
                acData.put("date", inTime == 0L ? simpleDateFormat.format(new Date(outTime)) : simpleDateFormat.format(new Date(inTime)));
            }
            obj.put("t", userId);
            request.add(new IndexRequest(indexName).id(sequence.getStringId())
                    .source(JSON.toJSONString(ro.getList().get(i)), XContentType.JSON));
        }
        return request;
    }

    @Override
    @SneakyThrows
    public String getDocument(String indexName, String id) {
        GetRequest request = new GetRequest(indexName, id);
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        log.info("获取埋点数据:{},response:{}", response.getSourceAsString(), response);
        return response.getSourceAsString();
    }

    @Override
    @SneakyThrows
    public Boolean updateDocument(Object obj, String indexName, String id) {
        //修改是id为1的
        UpdateRequest request = new UpdateRequest(indexName, id);
        request.timeout(timeoutTime);
        request.doc(JSON.toJSONString(obj), XContentType.JSON);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        if (response.status().name().equals("OK")) {
            return true;
        }
        return false;
    }

    @Override
    public Boolean deleteDocument(String indexName, String id) {
        return null;
    }

    @Override
    @SneakyThrows
    public Long searchDocument(Map<String, String> queryMap, String indexName) {
        SearchRequest request = new SearchRequest(indexName);
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        for (Map.Entry<String, String> entry : queryMap.entrySet()) {
            String mapKey = entry.getKey();
            String mapValue = entry.getValue();
            boolQueryBuilder.must(QueryBuilders.matchQuery(mapKey, mapValue));
        }
        //matchPhraseQuery和matchQuery等的区别，在使用matchQuery等时，在执行查询时，搜索的词会被分词器分词
        sourceBuilder.timeout(timeoutTime);
        sourceBuilder.query(boolQueryBuilder);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        return response.getHits().getTotalHits().value;
    }


    /**
     * 查询一个记录的信息（数组 只返回第一个）
     *
     * @param queryMap
     * @param indexName
     * @return
     */
    @SneakyThrows
    public EsDocumentInfoDTO searchDocumentInfo(Map<String, String> queryMap, String indexName) {
        SearchRequest request = new SearchRequest(indexName);
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        for (Map.Entry<String, String> entry : queryMap.entrySet()) {
            String mapKey = entry.getKey();
            String mapValue = entry.getValue();
            boolQueryBuilder.must(QueryBuilders.matchQuery(mapKey, mapValue));
        }
        //matchPhraseQuery和matchQuery等的区别，在使用matchQuery等时，在执行查询时，搜索的词会被分词器分词
        sourceBuilder.timeout(timeoutTime);
        sourceBuilder.query(boolQueryBuilder);
        request.source(sourceBuilder);
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        EsDocumentInfoDTO dto = null;
        if (response.getHits().getHits().length > 0) {
            dto = new EsDocumentInfoDTO();
            dto.setId(response.getHits().getHits()[0].getId());
            dto.setMap(response.getHits().getHits()[0].getSourceAsMap());
        }
        return dto;
    }

    @Override
    @SneakyThrows
    public Long searchDocumentCount(String column, String value, String indexName) {
        SearchRequest request = new SearchRequest(indexName);
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //matchPhraseQuery和matchQuery等的区别，在使用matchQuery等时，在执行查询时，搜索的词会被分词器分词
        QueryBuilder queryBuilder = QueryBuilders.matchQuery(column, value);
        sourceBuilder.query(queryBuilder);
        sourceBuilder.timeout(timeoutTime);
        sourceBuilder.query(queryBuilder);
        request.source(sourceBuilder);
        return client.search(request, RequestOptions.DEFAULT).getHits().getTotalHits().value;
    }


    /**
     * 根据页面来分组浏览量
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchDocumentCountGroup(String selectColumn, String selectValue, String groupColumn,
                                                            String indexName) {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.timeout(timeoutTime);
            List<QueryBuilder> listQ = new ArrayList<>();
            listQ.add(QueryBuilders.matchQuery(selectColumn, selectValue));
            BoolQueryBuilder builders = QueryBuilders.boolQuery();
            builders.must().addAll(listQ);
            searchSourceBuilder.query(builders);
            searchSourceBuilder.size(0);
            //根据姓名进行分组统计个数
            TermsAggregationBuilder field = AggregationBuilders.terms("terms_user").field(groupColumn + ".keyword");
            ValueCountAggregationBuilder countField = AggregationBuilders.count("count_name").field(groupColumn + ".keyword");
            field.subAggregation(countField);
            searchSourceBuilder.aggregation(field);
            SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            //分组在es中是分桶
            ParsedStringTerms termsName = response.getAggregations().get("terms_user");
            List<? extends Terms.Bucket> buckets = termsName.getBuckets();
            HashMap<String, String> map = new HashMap<>();
            buckets.forEach(name -> {
                String key = (String) name.getKey();
                ParsedValueCount countName = name.getAggregations().get("count_name");
                Double value = countName.value();
                map.put(key, value.longValue() + "");
                log.info("name , count {} {}", key, value);
            });
            return map;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    @SneakyThrows
    public Long searchDocumentCountByTime(String column, String value, String indexName, Long startTime, Long endTime) {
        SearchRequest request = new SearchRequest(indexName);
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        //matchPhraseQuery和matchQuery等的区别，在使用matchQuery等时，在执行查询时，搜索的词会被分词器分词
        List<QueryBuilder> list = new ArrayList<>();
        list.add(QueryBuilders.matchQuery(column, value));
        list.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(list);
        sourceBuilder.timeout(timeoutTime);
        sourceBuilder.query(builders);
        request.source(sourceBuilder);
        return client.search(request, RequestOptions.DEFAULT).getHits().getTotalHits().value;
    }


    /**
     * 获取每个天的分组信息浏览量
     *
     * @param column
     * @param value
     * @param indexName
     * @param startTime
     * @param endTime
     * @return
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchDocumentByDays(String column, String value, String indexName, Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listOption = new ArrayList<>();
        listOption.add(QueryBuilders.matchQuery(column, value));
        String inTime = "acData.sTme";
        listOption.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery(inTime).gte(startTime).lt(endTime)));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listOption);
        //根据姓名进行分组统计个数
        TermsAggregationBuilder field = AggregationBuilders.terms("terms_user").field("acData.date")
                .order(BucketOrder.key(true));
        ValueCountAggregationBuilder countField = AggregationBuilders.count("count_name").field("acData.date");
        field.subAggregation(countField);
        searchSourceBuilder.aggregation(field);
        searchSourceBuilder.query(builders);
        searchSourceBuilder.timeout(timeoutTime);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        //分组在es中是分桶
        ParsedTerms termsName = response.getAggregations().get("terms_user");
        List<? extends Terms.Bucket> buckets = termsName.getBuckets();
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        buckets.forEach(name -> {
            String key = name.getKey() + "";
            ParsedValueCount countName = name.getAggregations().get("count_name");
            Double valueD = countName.value();
            map.put(simpleDate.format(new Date(Long.parseLong(key))), valueD.longValue() + "");
            log.info("name , count {} {}", key, valueD);
        });
        return map;
    }


    /**
     * @param column       分组字段
     * @param optionColumn 筛选字段
     * @param optionValue  筛选字段的值
     * @param indexName    索引
     * @return
     */
    @Override
    @SneakyThrows
    public Long searchUserCount(String column, String optionColumn, String optionValue, String indexName) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        QueryBuilder names = QueryBuilders.matchQuery(optionColumn, optionValue);
//        TermsAggregationBuilder tb = AggregationBuilders.terms("group").field(column + ".keyword").size(Integer.MAX_VALUE);
        AggregationBuilder tb = AggregationBuilders.cardinality("user_count").field(column + ".keyword");
//        AggregationBuilder avgAge = AggregationBuilders.avg("avg_age").field("age");
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.query(names);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        return ((ParsedCardinality) response.getAggregations().asList().get(0)).getValue();
    }

    /**
     * 实时分析 按天来统计人均访问量
     *
     * @param column
     * @param optionColumn
     * @param optionValue
     * @param indexName
     * @param startTime
     * @param endTime
     * @return
     */
    @Override
    @SneakyThrows
    public Long searchUserCountByTime(String column, String optionColumn, String optionValue,
                                      String indexName, Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> list = new ArrayList<>();
        list.add(QueryBuilders.matchQuery(optionColumn, optionValue));
        list.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(list);
        AggregationBuilder tb = AggregationBuilders.cardinality("_A_").field(column + ".keyword");
        searchSourceBuilder.query(builders);
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        return ((ParsedCardinality) response.getAggregations().asList().get(0)).getValue();
    }


    /**
     * 获取流量趋势的 访客数
     *
     * @param column
     * @param optionColumn
     * @param optionValue
     * @param indexName
     * @param startTime
     * @param endTime
     * @return
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchUserByDays(String column, String optionColumn, String optionValue, String indexName,
                                                    Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listQ = new ArrayList<>();
        listQ.add(QueryBuilders.matchQuery(optionColumn, optionValue));
        listQ.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listQ);
        AggregationBuilder tb = AggregationBuilders.terms("_A_").field("acData.date").subAggregation(
                AggregationBuilders.cardinality("_B_").field("t.keyword")
        );
        searchSourceBuilder.query(builders);
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        //分组在es中是分桶
        ParsedTerms termsName = response.getAggregations().get("_A_");
        List<? extends Terms.Bucket> buckets = termsName.getBuckets();
        HashMap<String, String> map = new HashMap<>();
        buckets.forEach(name -> {
            String key = name.getKey() + "";
            ParsedCardinality countName = name.getAggregations().get("_B_");
            Double valueD = countName.value();
            map.put(simpleDate.format(new Date(Long.parseLong(key))), valueD.longValue() + "");
            log.info("name , count {} {}", key, valueD);
        });
        return map;
    }


    /**
     * 获取流量趋势的 平均停留时长
     *
     * @param column
     * @param optionColumn
     * @param optionValue
     * @param indexName
     * @param startTime
     * @param endTime
     * @return
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchLeaveByDays(String column, String optionColumn, String optionValue,
                                                     String indexName, Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listQ = new ArrayList<>();
        listQ.add(QueryBuilders.matchQuery(optionColumn, optionValue));
        listQ.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listQ);
        AggregationBuilder tb = AggregationBuilders.terms("_A_").field("acData.date").subAggregation(
                AggregationBuilders.sum("_B_").field("acData.leave")
        );
        searchSourceBuilder.query(builders);
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        //分组在es中是分桶
        ParsedTerms termsName = response.getAggregations().get("_A_");
        List<? extends Terms.Bucket> buckets = termsName.getBuckets();
        HashMap<String, String> map = new HashMap<>();
        buckets.forEach(name -> {
            String key = name.getKey() + "";
            ParsedSum countName = name.getAggregations().get("_B_");
            Double valueD = countName.value() / 1000;
            map.put(simpleDate.format(new Date(Long.parseLong(key))), valueD.longValue() + "");
            log.info("name , count {} {}", key, valueD);
        });
        return map;
    }


    /**
     * 查询所有用户逗留时间的sum
     *
     * @param selectColumn
     * @param selectValue
     * @param aggsColumn
     * @param aggsType
     * @param indexName
     * @return
     */
    @Override
    @SneakyThrows
    public Long searchAggs(String selectColumn, Object selectValue, String aggsColumn, String aggsType, String indexName) {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//            QueryBuilder names = QueryBuilders.termQuery("name", name);
            QueryBuilder names = QueryBuilders.matchQuery("acData.type", "ACPAGE");
            AggregationBuilder sumAge = AggregationBuilders.sum("leave_time").field("acData.leave");
            searchSourceBuilder.aggregation(sumAge);
            searchSourceBuilder.query(names);
            searchSourceBuilder.size(0);
            SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            ParsedSum.SingleValue avgAggregationBuilder = response.getAggregations().get("leave_time");
            return (long) avgAggregationBuilder.value();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    @SneakyThrows
    public Long searchAggsByTime(String indexName, Long startTime, Long endTime) {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//            QueryBuilder names = QueryBuilders.termQuery("name", name);
            List<QueryBuilder> list = new ArrayList<>();
            list.add(QueryBuilders.matchQuery("acData.type", "ACPAGE"));
            list.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
//            list.add(QueryBuilders.termQuery("name", "acData.leave"));
            BoolQueryBuilder builders = QueryBuilders.boolQuery();
            builders.must().addAll(list);
            AggregationBuilder sumAge = AggregationBuilders.sum("leave_time").field("acData.leave");
            searchSourceBuilder.aggregation(sumAge);
            searchSourceBuilder.query(builders);
            searchSourceBuilder.size(0);
            SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            ParsedSum.SingleValue avgAggregationBuilder = response.getAggregations().get("leave_time");
            return (long) avgAggregationBuilder.value();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    /**
     * 页面流量排行 访客数
     *
     * @param column
     * @param optionColumn
     * @param optionValue
     * @param indexName
     * @return
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchViewUserCount(String column, String optionColumn, String optionValue, String indexName) {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            List<QueryBuilder> listQ = new ArrayList<>();
            listQ.add(QueryBuilders.matchQuery(optionColumn, optionValue));
            BoolQueryBuilder builders = QueryBuilders.boolQuery();
            builders.must().addAll(listQ);
            AggregationBuilder tb = AggregationBuilders.terms("_A_").field("acData.fromPath.keyword").subAggregation(
                    AggregationBuilders.cardinality("_B_").field("t.keyword")
            );
            searchSourceBuilder.query(builders);
            searchSourceBuilder.aggregation(tb);
            searchSourceBuilder.size(0);
            SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            //分组在es中是分桶
            ParsedStringTerms termsName = response.getAggregations().get("_A_");
            List<? extends Terms.Bucket> buckets = termsName.getBuckets();
            HashMap<String, String> map = new HashMap<>();
            buckets.forEach(name -> {
                String key = name.getKey() + "";
                ParsedCardinality countName = name.getAggregations().get("_B_");
                Double valueD = countName.value();
                map.put(key, valueD.longValue() + "");
                log.info("name , count {} {}", key, valueD);
            });
            return map;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 页面流量排行 平均停留时长
     *
     * @param column
     * @param optionColumn
     * @param optionValue
     * @param indexName
     * @return
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchViewLeaveTime(String column, String optionColumn, String optionValue, String indexName) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listQ = new ArrayList<>();
        listQ.add(QueryBuilders.matchQuery(optionColumn, optionValue));
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listQ);
        AggregationBuilder tb = AggregationBuilders.terms("_A_").field("acData.fromPath.keyword").subAggregation(
                AggregationBuilders.sum("_B_").field("acData.leave")
        );
        searchSourceBuilder.query(builders);
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        //分组在es中是分桶
        ParsedStringTerms termsName = response.getAggregations().get("_A_");
        List<? extends Terms.Bucket> buckets = termsName.getBuckets();
        HashMap<String, String> map = new HashMap<>();
        buckets.forEach(name -> {
            String key = name.getKey() + "";
            ParsedSum countName = name.getAggregations().get("_B_");
            Double valueD = countName.value();
            map.put(key, (valueD.longValue() / 1000) + "");
            log.info("name , count {} {}", key, valueD);
        });
        return map;
    }


    /**
     * 分组 用户访问一次的总数
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchOneViewUserCountGroup(String indexName, String type, Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listQ = new ArrayList<>();
        listQ.add(QueryBuilders.matchQuery("acData.status", "true"));
        AggregationBuilder tb = null;
        ValueCountAggregationBuilder countField = null;
        if ("3".equals(type)) { // 流量趋势
            listQ.add(QueryBuilders.matchQuery("acData.type", EsConstants.INDEX_TYPE_DAY));
            listQ.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
            tb = AggregationBuilders.terms("_A_").field("acData.date");
            countField = AggregationBuilders.count("count_name").field("acData.sTme");

        } else if ("4".equals(type)) { // 页面排行
            listQ.add(QueryBuilders.matchQuery("acData.type", EsConstants.INDEX_TYPE_PATH));
            tb = AggregationBuilders.terms("_A_").field("acData.fromPath.keyword");
            countField = AggregationBuilders.count("count_name").field("acData.fromPath.keyword");
        }
        tb.subAggregation(countField);
        searchSourceBuilder.timeout(timeoutTime);
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listQ);
        searchSourceBuilder.aggregation(tb);
        searchSourceBuilder.query(builders);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
        HashMap<String, String> list = new HashMap<>();  //分组在es中是分桶
        if ("3".equals(type)) {
            ParsedTerms termsName = response.getAggregations().get("_A_");
            List<? extends Terms.Bucket> buckets = termsName.getBuckets();
            buckets.forEach(name -> {
                String key = name.getKey() + "";
                ParsedValueCount countName = name.getAggregations().get("count_name");
                Double valueD = countName.value();
                list.put(simpleDate.format(new Date(Long.parseLong(key))), valueD.longValue() + "");
                log.info("name , count {} {}", key, valueD);
            });
        } else if ("4".equals(type)) {
            ParsedStringTerms termsName = response.getAggregations().get("_A_");
            List<? extends Terms.Bucket> buckets = termsName.getBuckets();
            buckets.forEach(name -> {
                String key = name.getKey() + "";
                ParsedValueCount countName = name.getAggregations().get("count_name");
                Double valueD = countName.value();
                list.put(key, valueD.longValue() + "");
                log.info("name , count {} {}", key, valueD);
            });
        }
        return list;
    }

    @Override
    @SneakyThrows
    public Long searchOneViewUserCount(String indexName, String type, Long startTime, Long endTime) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        List<QueryBuilder> listQ = new ArrayList<>();
        listQ.add(QueryBuilders.matchQuery("acData.type", EsConstants.INDEX_TYPE_VIEW));
        listQ.add(QueryBuilders.matchQuery("acData.status", "true"));
        if ("2".equals(type)) { // 实时分析
            listQ.add(QueryBuilders.boolQuery().filter(QueryBuilders.rangeQuery("acData.sTme").gte(startTime).lt(endTime)));
        }
        searchSourceBuilder.timeout(timeoutTime);
        BoolQueryBuilder builders = QueryBuilders.boolQuery();
        builders.must().addAll(listQ);
        searchSourceBuilder.query(builders);
        searchSourceBuilder.size(0);
        SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
        return client.search(searchRequest, RequestOptions.DEFAULT).getHits().getTotalHits().value;
    }
}

分组后并排序分页

# 页面流量排行 浏览量
GET wx_bury_point_test_2021_04_06/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACPAGE"
        }}
      ]
  }},
  "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword",
          "size": 1000,
          "shard_size": 10000
        },
        "aggs": {
          "pv_count": {
            "value_count": {
              "field": "acData.fromPath.keyword"
            }
          },
          "l_bucket_sort": {
            "bucket_sort": {
              "sort": {
                "pv_count": {
                  "order": "desc"
                }
              },
              "from": 2,
              "size": 10
            }
          }
        }
     }
  },
  "from": 0,
  "size": 0
}

  /**
     * 根据页面来分组浏览量
     */
    @Override
    @SneakyThrows
    public HashMap<String, String> searchDocumentCountGroup(String selectColumn, String selectValue, String groupColumn,
                                                            String indexName, List<String> keyNameList, Page page) {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.timeout(timeoutTime);
            List<QueryBuilder> listQ = new ArrayList<>();
            listQ.add(QueryBuilders.matchQuery(selectColumn, selectValue));
            if (CollectionUtil.isNotEmpty(keyNameList)) {
                listQ.add(QueryBuilders.termsQuery("acData.fromPath.keyword", keyNameList));
            }
            BoolQueryBuilder builders = QueryBuilders.boolQuery();
            builders.must().addAll(listQ);
            searchSourceBuilder.query(builders);
            searchSourceBuilder.size(0);
            //根据姓名进行分组统计个数 设置size为2000就是设置预估总页面不超过2000
            TermsAggregationBuilder field = AggregationBuilders.terms("terms_user").field(groupColumn + ".keyword");
            ValueCountAggregationBuilder countField = AggregationBuilders.count("count_name").field(groupColumn + ".keyword");
            field.subAggregation(countField);
            // 字段排序分页
            if (page != null) {
               FieldSortBuilder fieldSortBuilder = new FieldSortBuilder("count_name");
                fieldSortBuilder.order(SortOrder.DESC);
                List<FieldSortBuilder> list = new ArrayList<>();
                list.add(fieldSortBuilder);
                BucketSortPipelineAggregationBuilder bucketSort = new BucketSortPipelineAggregationBuilder("l_bucket_sort", list)
                        .from(page.getPageSize() * (page.getPageNumber() - 1)).size(10);
                field.subAggregation(bucketSort);
                field.size(1000).shardSize(10000);
            }
            searchSourceBuilder.aggregation(field);
            SearchRequest searchRequest = new SearchRequest(indexName).source(searchSourceBuilder);
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            //分组在es中是分桶
            ParsedStringTerms termsName = response.getAggregations().get("terms_user");
            List<? extends Terms.Bucket> buckets = termsName.getBuckets();
            HashMap<String, String> map = new LinkedHashMap<>();
            buckets.forEach(name -> {
                String key = (String) name.getKey();
                ParsedValueCount countName = name.getAggregations().get("count_name");
                Double value = countName.value();
                map.put(key, value.longValue() + "");
                log.info("name , count {} {}", key, value);
            });
            return map;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

in查询

# 页面流量排行 点击量
GET wx_bury_point_test_2021_04_06/_search
{
 "query": {
    "bool": {
      "must": [
        {"match": {
          "acData.type": "ACCLIK"
        }},
        {
          "terms": {
            "acData.fromPath.keyword": [
              "/user_center",
              "/pg_hjeri"
            ]
          }
        }
      ]
    }}
  ,
  "aggs":{
     "_A_": {
       "terms": {
          "field": "acData.fromPath.keyword"
        }
     }
  },
  "from": 0,
  "size": 0
}

哦到凯呀

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
ES的简单筛选功能以及java API调用方式

ES的简单筛选功能以及java API调用方式 <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.6.2
复制链接

扫一扫