elasticsearch相关 Java

最新推荐文章于 2024-08-15 14:09:45 发布

qws_

最新推荐文章于 2024-08-15 14:09:45 发布

阅读量169

点赞数

文章标签： elasticsearch java

本文链接：https://blog.csdn.net/qq_35696617/article/details/103576959

版权

更新

根据条件更新某个字段

// 标签名称
String tags = params.get("tags").toString();
// ip
String ip = params.get("ip").toString();
// 当前时间
Date date = new Date();
// 开始时间
String start = DateUtil.getDayByDeal(date, -30, "yyyy-MM-dd") + " 00:00:00";
// 结束时间
String end = DateUtil.getDayByDeal(date, 0, "yyyy-MM-dd") + " 23:59:59";
// 构建查询
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
// 查询条件: 时间段
boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
// 查询条件: 目的ip
boolQueryBuilder.must(QueryBuilders.termQuery("destIp", ip));
UpdateByQueryAction.INSTANCE.newRequestBuilder(transportClient)    // 创建新的请求builder
      .source("sflows")    // 设置索引index
      .filter(boolQueryBuilder)    // 设置过滤条件
      .script(new Script(ScriptType.INLINE, "painless", "ctx._source.business='" + tags + "'", Collections.EMPTY_MAP))    // 设置批量修改脚本
      .abortOnVersionConflict(false)    // 设置ES版本导致问题失败是否停止运行
      .get();

根据条件更新多个字段

 if (flag.get("flag").toString().equals("1")) {
      String source = "";
      // 源IP(srcIp)
      if (list.get(i).getType() == 1) {
          // 查询条件: 源ip
          boolQueryBuilder.must(QueryBuilders.termQuery("srcIp", list.get(i).getIp()));
          source = "ctx._source.srcBusiness='" + list.get(i).getBusiness() + "'" + ";ctx._source.lineNum='" + list.get(i).getLineNum() + "'";
      } // 目的IP(destIp)
      else {
          // 查询条件: 目的ip
          boolQueryBuilder.must(QueryBuilders.termQuery("destIp", list.get(i).getIp()));
          source = "ctx._source.business='" + list.get(i).getBusiness() + "'" + ";ctx._source.lineNum='" + list.get(i).getLineNum() + "'";
      }
      // 根据条件更新es
      UpdateByQueryAction.INSTANCE.newRequestBuilder(transportClient)    // 创建新的请求builder
              .source("sflows")    // 设置索引index
              .filter(boolQueryBuilder)    // 设置过滤条件
              .script(new Script(ScriptType.INLINE, "painless", source, Collections.EMPTY_MAP))    // 设置批量修改脚本
              .abortOnVersionConflict(false)    // 设置ES版本导致问题失败是否停止运行
              .get();

查询

根据时间聚合

 	/**
     * 获取开始时间,结束时间,时间间隔
     *
     * @param params 参数
     */
    public Map<String, Object> getData(Map<String, Object> params) {
        // 类型
        int type = Integer.parseInt(params.get("type").toString());
        // 当前时间
        Date date = new Date();
        // 时间间隔
        int x = 1;
        // 开始时间
        String start = "";
        // 结束时间(默认前一天)
        String end = getDayByDeal(date, -1, "yyyy-MM-dd") + " 23:59:59";
        if (type == 2) { // 前1天(1h)
            start = getDayByDeal(date, -1, "yyyy-MM-dd") + " 00:00:00";
        } else if (type == 3) { // 前7天(1d)
            start = getDayByDeal(date, -7, "yyyy-MM-dd") + " 00:00:00";
        } else if (type == 4) { // 前30天(1d)
            start = getDayByDeal(date, -30, "yyyy-MM-dd") + " 00:00:00";
        } else { // 前2个小时(15s)
            start = getTimeByDeal(date, -2);
            end = formatTime(date, "yyyy-MM-dd HH:mm:ss");
            x = 15;
        }
        return getLineLoss(type, start, end, x);
    }
    
	/**
     * 丢包曲线图
     *
     * @param type  聚合类型(1: 按秒 2: 按小时 其他: 按天)
     * @param start 开始时间
     * @param end   结束时间
     * @param x     时间间隔
     * @return
     */
    public Map<String, Object> getLineLoss(int type, String start, String end, int x) {
        // 结果集
        Map<String, Object> result = new HashMap<>();
        // 构建查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 查询条件: 时间段
        boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
        // 查询条件: 丢包非空
        boolQueryBuilder.must(QueryBuilders.existsQuery("dropped_packets"));
        // 聚合时间类型
        DateHistogramInterval dateHistogramInterval = getDateHistogramInterval(type, x);
        //统计时间聚合
        AggregationBuilder timeAggregation = AggregationBuilders.dateHistogram("agg").field("createDate").format("yyyy-MM-dd HH:mm:ss")
                .dateHistogramInterval(dateHistogramInterval).minDocCount(0L).extendedBounds(new ExtendedBounds(start, end));
        if (type > 2) {
            timeAggregation = AggregationBuilders.dateHistogram("agg").field("createDate").format("yyyy-MM-dd")
                    .dateHistogramInterval(dateHistogramInterval).minDocCount(0L).extendedBounds(new ExtendedBounds(start.substring(0, 10), end.substring(0, 10)));
        }
        // 丢包最大值
        MaxAggregationBuilder maxLoss = AggregationBuilders.max("maxLoss").field("dropped_packets");
        timeAggregation.subAggregation(maxLoss);
        // 查询
        SearchResponse response = transportClient.prepareSearch("sflows").setTypes("sflow")
                .addAggregation(timeAggregation).setQuery(boolQueryBuilder).execute().actionGet();

        Aggregations aggregations = response.getAggregations();
        Histogram histogram = aggregations.get("agg");
        // 时间(横坐标)
        List<String> timeList = new ArrayList<>();
        // 纵坐标
        List<String> list = new ArrayList<>();
        // 最大丢包数
        double loss = 0.0;
        // 最大值时间
        result.put("maxDate", "暂无");
        result.put("maxLoss", loss);
        if (histogram.getBuckets().size() > 0) {
            for (Histogram.Bucket entry : histogram.getBuckets()) {
                timeList.add(entry.getKeyAsString());
                // 最大值
                Max max = entry.getAggregations().get("maxLoss");
                if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
                    Double maxLen = max.getValue();
                    if (maxLen.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                        maxLen = 0.0;
                    }
                    list.add(maxLen + "");
                    // 比较丢包大小
                    if (maxLen > loss) {
                        result.put("maxLoss", maxLen);
                        result.put("maxDate", entry.getKeyAsString());
                        loss = maxLen;
                    }
                } else {
                    list.add("0.0");
                }
            }
        }
        result.put("timeList", timeList);
        result.put("seriesData", list);
        return result;
    }

    /**
     * 按时间聚合
     *
     * @param dateType
     * @return
     */
    private DateHistogramInterval getDateHistogramInterval(int dateType, int x) {
        if (dateType == 1) {
            // 某个时间段按某秒数统计一个值
            return DateHistogramInterval.seconds(x);
        } else if (dateType == 2) {
            // 某个时间段按某小时统计一个值
            return DateHistogramInterval.hours(x);
        } else {
            // 某个时间段按某天数统计一个值
            return DateHistogramInterval.days(x);
        }
    }

    /**
     * 小数点保留两位
     *
     * @param value
     * @return
     */
    public double twoDouble(Double value) {
        BigDecimal bg = new BigDecimal(value);
        double doubleValue = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        return doubleValue;
    }

    /**
     * 科学计数法转数字
     *
     * @param num
     * @return
     */
    public String nonScientificNotation(String num) {
        Pattern pattern = Pattern.compile("[0-9]*.[0-9]*E[0-9]*");
        Matcher match = pattern.matcher(num);
        if (match.matches()) {
            BigDecimal decimal = new BigDecimal(num);
            num = decimal.toPlainString();
        }
        return num;
    }
    
	/**
     * 获取自定义时间的前后n个小时
     *
     * @param date 时间
     * @param hour 前后加减 n 个小时(+ 代表 n 小时后,- 代表 n 小时前)
     * @return
     */
    public static String getTimeByDeal(Date date, int hour) {
        SimpleDateFormat sdf = new SimpleDateFormat(FULL_ST_FORMAT);
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        // 前后加减 n 个小时
        c.add(Calendar.HOUR_OF_DAY, hour);
        return sdf.format(c.getTime());
    }

    /**
     * 获取自定义时间的前后n天
     *
     * @param date   时间
     * @param day    前后加减 n 天(+ 代表 n 天后,- 代表 n 天前)
     * @param format 自定义格式化
     * @return
     */
    public static String getDayByDeal(Date date, int day, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        // 前后加减 n 天
        c.add(Calendar.DATE, day);
        return sdf.format(c.getTime());
    }

根据某个字段分组,count计数

    /**
     * 饼图
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return
     */
    public Map<String, Object> getPie(String start, String end) {
        // 结果集
        Map<String, Object> result = new HashMap<>();
        // 构建查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 查询条件: 时间段
        boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
        // 根据业务类型聚合
        TermsAggregationBuilder business = AggregationBuilders.terms("business").field("business").size(Integer.MAX_VALUE);
        // 业务类型次数
        ValueCountAggregationBuilder valueCountAggregationBuilder = AggregationBuilders.count("business").field("business");
        business.subAggregation(valueCountAggregationBuilder);
        // 查询
        SearchResponse response = transportClient.prepareSearch("sflows").setTypes("sflow")
                .addAggregation(business).setQuery(boolQueryBuilder).execute().actionGet();

        Aggregations aggregations = response.getAggregations();
        StringTerms stringTerms = aggregations.get("business");
        // 对象列表
        List<Map<String, Object>> data = new ArrayList<>();
        Map<String, Object> map = new HashMap<>();
        if (stringTerms.getBuckets().size() > 0) {
            for (StringTerms.Bucket terms : stringTerms.getBuckets()) {
                map.put("legendname", terms.getKey().toString());
                map.put("name", terms.getKey().toString());
                InternalValueCount internalValueCount = terms.getAggregations().get("business");
                map.put("value", internalValueCount.getValue());
                data.add(map);
                map = new HashMap<>();
            }
        }
        result.put("data", data);
        return result;
    }

Top5

	/**
     * top5列表
     *
     * @param type  聚合类型(1: 按秒 2: 按小时 其他: 按天)
     * @param start 开始时间
     * @param end   结束时间
     * @param x     时间间隔
     * @return
     */
    public Map<String, Object> queryTop5List(int type, String start, String end, int x) {
        // 结果集
        Map<String, Object> result = new HashMap<>();
        // 构建查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 查询条件: 时间段
        boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
        // 查询条件: 目的ip非空
        boolQueryBuilder.must(QueryBuilders.existsQuery("destIp"));
        // 根据目的ip聚合
        TermsAggregationBuilder destIp = AggregationBuilders.terms("destIp").field("destIp").size(Integer.MAX_VALUE);
        // 源IP
        TermsAggregationBuilder srcIp = AggregationBuilders.terms("srcIp").field("srcIp").size(1);
        // 协议类型
        TermsAggregationBuilder typeOfProtocal = AggregationBuilders.terms("type1").field("type1").size(1);
        // 流量最大值
        MaxAggregationBuilder maxTotalLen = AggregationBuilders.max("maxTotalLen").script(new Script(ScriptType.INLINE, "expression", "(doc['totalLen'].value)", new HashMap<>()));
        // 包数最大值
        MaxAggregationBuilder maxSamplePool = AggregationBuilders.max("maxSamplePool").field("sample_pool");
        // 采样率
        MaxAggregationBuilder maxSamplingRate = AggregationBuilders.max("maxSamplingRate").field("sampling_rate");
        // 次数
        ValueCountAggregationBuilder valueCountAggregationBuilder = AggregationBuilders.count("count").field("destIp");
        // 业务标签
        TermsAggregationBuilder business = AggregationBuilders.terms("business").field("business").size(1);
        // 时间
        TermsAggregationBuilder createDate = AggregationBuilders.terms("createDate").field("createDate").size(1);

        destIp.subAggregation(srcIp);
        destIp.subAggregation(typeOfProtocal);
        destIp.subAggregation(maxTotalLen);
        destIp.subAggregation(maxSamplePool);
        destIp.subAggregation(maxSamplingRate);
        destIp.subAggregation(valueCountAggregationBuilder);
        destIp.subAggregation(business);
        destIp.subAggregation(createDate);
        // 取前5条
        destIp.size(5);
        // 排序
        destIp.order(BucketOrder.compound(BucketOrder.aggregation("maxTotalLen", false)));

        // 查询
        SearchResponse response = transportClient.prepareSearch("sflows").setTypes("sflow")
                .addAggregation(destIp).setQuery(boolQueryBuilder).setSize(5).execute().actionGet();

        Aggregations aggregations = response.getAggregations();
        StringTerms destIpTerms = aggregations.get("destIp");
        SearchHits searchHits = response.getHits();
        // 总数
        long total = searchHits.totalHits;
        // 列表
        List<Map<String, Object>> list = new ArrayList<>();
        // 数据集
        Map<String, Object> map = new HashMap<>();
        // 最大占比
        double maxRate = 0.0;
        if (destIpTerms.getBuckets().size() > 0) {
            for (StringTerms.Bucket terms : destIpTerms.getBuckets()) {
                map = new HashMap<>();
                // 目的ip
                map.put("destIp", terms.getKeyAsString());
                // 源ip
                StringTerms stringTerms = terms.getAggregations().get("srcIp");
                for (StringTerms.Bucket src : stringTerms.getBuckets()) {
                    map.put("srcIp", src.getKeyAsString());
                }
                // 业务
                stringTerms = terms.getAggregations().get("business");
                for (StringTerms.Bucket src : stringTerms.getBuckets()) {
                    map.put("business", src.getKeyAsString());
                }
                // 协议
                stringTerms = terms.getAggregations().get("type1");
                for (StringTerms.Bucket src : stringTerms.getBuckets()) {
                    map.put("type", src.getKeyAsString());
                }
                // 流量
                Max max = terms.getAggregations().get("maxTotalLen");
                if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
                    Double d = max.getValue();
                    if (d.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                        d = 0.0;
                    }
                    map.put("totalLen", d);
                } else {
                    map.put("totalLen", 0.0);
                }
                // 包数
                max = terms.getAggregations().get("maxSamplePool");
                if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
                    Double d = max.getValue();
                    if (d.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                        d = 0.0;
                    }
                    map.put("samplePool", nonScientificNotation(String.valueOf(d)));
                } else {
                    map.put("samplePool", 0.0);
                }
                // 占比
                InternalValueCount internalValueCount = terms.getAggregations().get("count");
                Double rate = twoDouble(((double) internalValueCount.getValue() / (double) total) * 100);
                // 比较占比大小
                if (rate > maxRate) {
                    result.put("maxRate", rate);
                    result.put("maxIp", map.get("destIp"));
                    result.put("maxTotalLen", map.get("totalLen"));
                    LongTerms longTerms = terms.getAggregations().get("createDate");
                    for (LongTerms.Bucket src : longTerms.getBuckets()) {
                        result.put("maxDate", src.getKeyAsString());
                    }
                    max = terms.getAggregations().get("maxSamplingRate");
                    if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
                        Double d = max.getValue();
                        if (d.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                            d = 0.0;
                        }
                        result.put("maxSamplingRate", nonScientificNotation(String.valueOf(d)));
                    } else {
                        result.put("maxSamplingRate", 0.0);
                    }
                    maxRate = rate;
                }
                map.put("rate", rate);
                list.add(map);
            }
        }
        result.put("dataTable", list);
        return result;
    }

根据字段以及时间分组

    /**
     * Top5趋势曲线图
     *
     * @param type  聚合类型(1: 按秒 2: 按小时 其他: 按天)
     * @param start 开始时间
     * @param end   结束时间
     * @param x     时间间隔
     * @return
     */
    public Map<String, Object> getLineTop5(int type, String start, String end, int x) {
        // 结果集
        Map<String, Object> result = new HashMap<>();
        // 构建查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // 查询条件: 时间段
        boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
        // 查询条件: 目的ip非空
        boolQueryBuilder.must(QueryBuilders.existsQuery("destIp"));
        // 根据目的ip聚合
        TermsAggregationBuilder destIp = AggregationBuilders.terms("destIp").field("destIp").size(Integer.MAX_VALUE);
        // 聚合时间类型
        DateHistogramInterval dateHistogramInterval = getDateHistogramInterval(type, x);
        // 统计时间聚合
        AggregationBuilder timeAggregation = AggregationBuilders.dateHistogram("agg").field("createDate").format("yyyy-MM-dd HH:mm:ss")
                .dateHistogramInterval(dateHistogramInterval).minDocCount(0L).extendedBounds(new ExtendedBounds(start, end));
        if (type > 2) {
            timeAggregation = AggregationBuilders.dateHistogram("agg").field("createDate").format("yyyy-MM-dd")
                    .dateHistogramInterval(dateHistogramInterval).minDocCount(0L).extendedBounds(new ExtendedBounds(start.substring(0, 10), end.substring(0, 10)));
        }
        // 流量最大值
        MaxAggregationBuilder maxTotalLen = AggregationBuilders.max("maxTotalLen").script(new Script(ScriptType.INLINE, "expression", "(doc['totalLen'].value)", new HashMap<>()));

        timeAggregation.subAggregation(maxTotalLen);
        destIp.subAggregation(timeAggregation);
        destIp.subAggregation(maxTotalLen);
        destIp.size(5);
        destIp.order(BucketOrder.compound(BucketOrder.aggregation("maxTotalLen", false)));

        // 查询
        SearchResponse response = transportClient.prepareSearch("sflows").setTypes("sflow")
                .addAggregation(destIp).addAggregation(timeAggregation)
                .setQuery(boolQueryBuilder).setSize(5).execute().actionGet();

        Aggregations aggregations = response.getAggregations();
        StringTerms stringTerms = aggregations.get("destIp");

        // 时间(横坐标)
        List<String> timeList = new ArrayList<>();
        // ip(legend)
        List<String> ipList = new ArrayList<>();
        // series
        List<List<String>> dataList = new ArrayList<>();

        if (stringTerms.getBuckets().size() > 0) {
            for (StringTerms.Bucket terms : stringTerms.getBuckets()) {
                ipList.add(terms.getKey().toString());
                Histogram histogram = terms.getAggregations().get("agg");
                List<String> list = new ArrayList<>();
                timeList = new ArrayList<>();
                if (histogram.getBuckets().size() > 0) {
                    for (Histogram.Bucket entry : histogram.getBuckets()) {
                        timeList.add(entry.getKeyAsString());
                        // 最大值
                        Max max = entry.getAggregations().get("maxTotalLen");
                        if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
                            Double maxLen = max.getValue();
                            if (maxLen.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                                maxLen = 0.0;
                            }
                            list.add(maxLen + "");
                        } else {
                            list.add("0.0");
                        }
                    }
                }
                dataList.add(list);
            }
        }
        result.put("timeList", timeList);
        result.put("legend", ipList);
        result.put("seriesData", dataList);
        return result;
    }

分组后分页

/**
* 查询更多(分页)
*
* @param params 参数
* @return
*/
public EsPage queryMore(Map<String, Object> params) throws Exception {
   // 类型
   int type = Integer.parseInt(params.get("type").toString());
   // 当前时间
   Date date = new Date();
   // 时间间隔
   int x = 1;
   // 开始时间
   String start = "";
   // 结束时间(默认前一天)
   String end = getDayByDeal(date, -1, "yyyy-MM-dd") + " 23:59:59";
   if (type == 2) { // 前1天(1h)
       start = getDayByDeal(date, -1, "yyyy-MM-dd") + " 00:00:00";
   } else if (type == 3) { // 前7天(1d)
       start = getDayByDeal(date, -7, "yyyy-MM-dd") + " 00:00:00";
   } else if (type == 4) { // 前30天(1d)
       start = getDayByDeal(date, -30, "yyyy-MM-dd") + " 00:00:00";
   } else { // 前2个小时(15s)
       start = getTimeByDeal(date, -2);
       end = formatTime(date, "yyyy-MM-dd HH:mm:ss");
   }
   // 查询条件: 目的Ip
   String ipQuery = params.get("ip").toString();
   // 查询条件: 目的Ip
   String destIpQuery = params.get("destIp").toString();
   // 查询条件: 协议
   String protocolQuery = params.get("protocol").toString();
   // 查询条件: 业务标签
   String businessQuery = params.get("business").toString();
   // 构建查询
   BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
   // 查询条件: 时间段
   boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd HH:mm:ss").lte(end).gte(start));
   // 查询条件: 目的ip非空
   boolQueryBuilder.must(QueryBuilders.existsQuery("destIp"));
   // 查询条件: ip
   if (!StringUtils.isEmpty(ipQuery)) {
       boolQueryBuilder.must(QueryBuilders.termQuery("ip", ipQuery));
   }
   // 查询条件: destIp
   if (!StringUtils.isEmpty(destIpQuery)) {
       boolQueryBuilder.must(QueryBuilders.termQuery("destIp", destIpQuery));
   }
   // 查询条件: 协议
   if (!StringUtils.isEmpty(protocolQuery)) {
       boolQueryBuilder.must(QueryBuilders.termQuery("type1", protocolQuery));
   }
   // 查询条件: 业务标签
   if (!StringUtils.isEmpty(businessQuery)) {
       boolQueryBuilder.must(QueryBuilders.termQuery("business", businessQuery));
   }
   // 根据目的ip聚合
   TermsAggregationBuilder destIp = AggregationBuilders.terms("destIp").field("destIp").size(Integer.MAX_VALUE);
   // ip
   TermsAggregationBuilder ip = AggregationBuilders.terms("ip").field("ip").size(1);
   // 源IP
   TermsAggregationBuilder srcIp = AggregationBuilders.terms("srcIp").field("srcIp").size(1);
   // 协议类型
   TermsAggregationBuilder typeOfProtocal = AggregationBuilders.terms("type1").field("type1").size(1);
   // 流量最大值
   MaxAggregationBuilder maxTotalLen = AggregationBuilders.max("maxTotalLen").field("totalLen");
   // 包数最大值
   MaxAggregationBuilder maxSamplePool = AggregationBuilders.max("maxSamplePool").field("sample_pool");
   // 采样率
   MaxAggregationBuilder maxSamplingRate = AggregationBuilders.max("maxSamplingRate").field("sampling_rate");
   // 次数
   ValueCountAggregationBuilder valueCountAggregationBuilder = AggregationBuilders.count("count").field("destIp");
   // 业务标签
   TermsAggregationBuilder business = AggregationBuilders.terms("business").field("business").size(1);

   destIp.subAggregation(ip);
   destIp.subAggregation(srcIp);
   destIp.subAggregation(typeOfProtocal);
   destIp.subAggregation(maxTotalLen);
   destIp.subAggregation(maxSamplePool);
   destIp.subAggregation(maxSamplingRate);
   destIp.subAggregation(valueCountAggregationBuilder);
   destIp.subAggregation(business);

   // 查询
   SearchResponse response = transportClient.prepareSearch("sflows").setTypes("sflow")
           .addAggregation(destIp).setQuery(boolQueryBuilder).execute().actionGet();

   Aggregations aggregations = response.getAggregations();
   Map<String, Aggregation> aggregationMap = aggregations.asMap();
   StringTerms stringTerms = (StringTerms) aggregationMap.get("destIp");
   List<StringTerms.Bucket> bucketsList = stringTerms.getBuckets();
   //总页数
   int total = bucketsList.size();
   //开始位置
   int startIndex = (Integer.parseInt(params.get("pageNum").toString()) - 1) * Integer.parseInt(params.get("pageSize").toString());
   //结束位置
   int endIndex = Integer.parseInt(params.get("pageNum").toString()) * Integer.parseInt(params.get("pageSize").toString());
   //分页查询
   response = transportClient.prepareSearch("sflows").setTypes("sflow")
           .addAggregation(destIp.size(endIndex)).setQuery(boolQueryBuilder).execute().actionGet();

   aggregations = response.getAggregations();
   aggregationMap = aggregations.asMap();
   stringTerms = (StringTerms) aggregationMap.get("destIp");
   bucketsList = stringTerms.getBuckets();
   int i = 0;
   // 列表
   List<Map<String, Object>> list = new ArrayList<>();
   // 数据集
   Map<String, Object> map = new HashMap<>();
   if (bucketsList.size() > 0) {
       for (Terms.Bucket entry : bucketsList) {
           i++;
           if (i < startIndex) {
               continue;
           }
           if (i > endIndex) {
               break;
           }
           // 目的ip
           map.put("destIp", entry.getKeyAsString());
           // 源ip
           StringTerms stringTerms1 = entry.getAggregations().get("srcIp");
           for (StringTerms.Bucket src : stringTerms1.getBuckets()) {
               map.put("srcIp", src.getKeyAsString());
           }
           // ip
           stringTerms1 = entry.getAggregations().get("ip");
           for (StringTerms.Bucket src : stringTerms1.getBuckets()) {
               map.put("ip", src.getKeyAsString());
           }
           // 业务
           stringTerms1 = entry.getAggregations().get("business");
           for (StringTerms.Bucket src : stringTerms1.getBuckets()) {
               map.put("business", src.getKeyAsString());
           }
           // 协议
           stringTerms1 = entry.getAggregations().get("type1");
           for (StringTerms.Bucket src : stringTerms1.getBuckets()) {
               map.put("type", src.getKeyAsString());
           }
           // 流量
           Max max = entry.getAggregations().get("maxTotalLen");
           if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
               Double d = max.getValue();
               if (d.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                   d = 0.0;
               }
               map.put("totalLen", d);
           } else {
               map.put("totalLen", 0.0);
           }
           // 包数
           max = entry.getAggregations().get("maxSamplePool");
           if (max != null && !"-Infinity".equals(String.valueOf(max.getValue()))) {
               Double d = max.getValue();
               if (d.equals(Double.NEGATIVE_INFINITY)) { //如果为无穷大，赋值为0
                   d = 0.0;
               }
               map.put("samplePool", nonScientificNotation(String.valueOf(d)));
           } else {
               map.put("samplePool", 0.0);
           }
           // 占比
           InternalValueCount internalValueCount = entry.getAggregations().get("count");
           Double rate = twoDouble(((double) internalValueCount.getValue() / (double) total) * 100);
           map.put("rate", rate);
           list.add(map);
           // 重置
           map = new HashMap<>();
       }
   }
   EsPage esPage = new EsPage();
   esPage.setPageSize(Integer.parseInt(params.get("pageSize").toString()));
   esPage.setCurrentPage(Integer.parseInt(params.get("pageNum").toString()));
   esPage.setRecordCount(total);
   esPage.setRecordList(list);
   return esPage;
}


import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
* 分页实体
*/
@Data
@ToString
public class EsPage {

    /**
     * 当前页
     */
    @JsonProperty("pageIndex")
    private int currentPage;
    /**
     * 每页显示多少条
     */
    @JsonProperty("pageSize")
    private int pageSize;
    /**
     * 总记录数
     */
    @JsonProperty("total")
    private int recordCount;
    /**
     * 本页的数据列表
     */
    @JsonProperty("data")
    private Object recordList;
    /**
     * 总页数
     */
    @JsonProperty("pageCount")
    private int pageCount;
    /**
     * 页码列表的开始索引（包含）
     */
    @JsonProperty("beginPageIndex")
    private int beginPageIndex;
    /**
     * 页码列表的结束索引（包含）
     */
    @JsonProperty("endPageIndex")
    private int endPageIndex;

    /**
     * 只接受前4个必要的属性，会自动的计算出其他3个属性的值
     *
     * @param currentPage
     * @param pageSize
     * @param recordCount
     * @param recordList
     */
    public EsPage(int currentPage, int pageSize, int recordCount, Object recordList) {
        this.currentPage = currentPage;
        this.pageSize = pageSize;
        this.recordCount = recordCount;
        this.recordList = recordList;

        // 计算总页码
        pageCount = (recordCount + pageSize - 1) / pageSize;

        // 计算 beginPageIndex 和 endPageIndex
        // >> 总页数不多于10页，则全部显示
        if (pageCount <= 10) {
            beginPageIndex = 1;
            endPageIndex = pageCount;
        }
        // >> 总页数多于10页，则显示当前页附近的共10个页码
        else {
            // 当前页附近的共10个页码（前4个 + 当前页 + 后5个）
            beginPageIndex = currentPage - 4;
            endPageIndex = currentPage + 5;
            // 当前面的页码不足4个时，则显示前10个页码
            if (beginPageIndex < 1) {
                beginPageIndex = 1;
                endPageIndex = 10;
            }
            // 当后面的页码不足5个时，则显示后10个页码
            if (endPageIndex > pageCount) {
                endPageIndex = pageCount;
                beginPageIndex = pageCount - 10 + 1;
            }
        }
    }

    public EsPage() {

    }
}

模糊查询/自带的分页

public PagerModel pageQuery(Integer pageNo, Integer pageSize, Map<String, Object> params) {
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // keySet获取map集合key的集合  然后在遍历key即可
        for (String key : params.keySet()) {
            String value = params.get(key).toString();
            if (!StringUtils.isEmpty(value)) {
                if (key.equals("start")) {
                    boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd").gte(value));
                } else if (key.equals("end")) {
                    boolQueryBuilder.must(QueryBuilders.rangeQuery("createDate").format("yyyy-MM-dd").lte(value));
                } else if (key.equals("keyword")) {
                    BoolQueryBuilder shouldQueryBuilder = QueryBuilders.boolQuery();
                    value = "*" + value + "*";
                    shouldQueryBuilder.should(QueryBuilders.wildcardQuery("title", value.toLowerCase()));
                    shouldQueryBuilder.should(QueryBuilders.wildcardQuery("label", value.toLowerCase()));
                    shouldQueryBuilder.should(QueryBuilders.wildcardQuery("question", value.toLowerCase()));
                    boolQueryBuilder.must(shouldQueryBuilder);
                } else {
                    boolQueryBuilder.must(QueryBuilders.termQuery(key, value));
                }
            }
        }
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder().withTypes(HOSPITAL)
                .withQuery(boolQueryBuilder).withPageable(PageRequest.of(pageNo, pageSize)).withSort((SortBuilders.fieldSort("lastReplyTime").order(SortOrder.DESC)));
        // 搜索，获取结果
        Page<HospitalBean> items = dao.search(builder.build());

        PagerModel model = new PagerModel();
        model.setRows(items.getContent());
        model.setTotalCount(items.getTotalElements());
        return model;
    }

qws_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
elasticsearch相关 Java

更新根据条件更新// 标签名称String tags = params.get("tags").toString();// ipString ip = params.get("ip").toString();// 当前时间Date date = new Date();// 开始时间String start = DateUtil.getDayByDeal(date, -30, "y...
复制链接

扫一扫