ElasticSearch学习笔记（三）：CRUD之简单查询

最新推荐文章于 2023-05-25 15:31:19 发布
最新推荐文章于 2023-05-25 15:31:19 发布
阅读量254 收藏
点赞数
分类专栏： ES
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38677458/article/details/116498948
版权

city-event-processing——索引名

一、数据体

索引结构

PUT city-event-processing
{
  "settings": {
    "number_of_shards": 10,
    "number_of_replicas": 1,
    "refresh_interval": "1s"
    
  },
  "mappings": {
    "properties": {
      "address": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "caseNumber": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "causeId": {
        "type": "keyword"
      },
      "createTime": {
        "type": "date",
        "format": "epoch_millis"
      },
      "updateTime": {
        "type": "date",
        "format": "epoch_millis"
      },
      "deviceId": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "deviceName": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "autoCheckPass": {
        "type": "boolean"
      },
      "location": {
        "type": "geo_point"
      },
      "state": {
        "type": "integer"
      },
      "type": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "acceptType": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "videoId": {
        "type": "keyword"
      }
    }
  }
}

数据体

/**
 * @param
 * @Author zhangwei
 * @Date 2021/3/23
 * @Description 告警事件数据库结构
 */
@AllArgsConstructor
@Data
public class AlarmEventPO {
    /**
     * 目标Id
     */
    private String causeId;
    /**
     * 案件编号
     */
    private String caseNumber;
    /**
     * 视频Id
     */
    private String videoId;
    /**
     * 告警地点
     */
    private String address;
    /**
     * 告警地点坐标
     */
    private Coordinate location;
    /**
     * 告警类型
     */
    private String type;
    /**
     * 接受的告警类型
     */
    private String acceptType;
    /**
     * 告警时间
     */
    private Long createTime;
    /**
     * 自动核查是否通过
     */
    private Boolean autoCheckPass;
    /**
     * 案件状态
     */
    private Integer state;
    /**
     * 数据更新时间
     */
    private Long updateTime;
    /**
    * 设备Id
    */
    private String deviceId;
}

二、简单查询

2.1、精准查询某单个案件编号的案件
注：caseNumber为text类型，caseNumber.keyword为keyword类型

2.1.1、DSL语句

GET city-event-processing/_search
{
  "query": {
    "term": {
      "caseNumber.keyword": {
        "value": "2104231001042"
      }
    }
  }
}

2.1.2、RestHighLevelClient实现

    /**
     * @description: 根据案件号查询事件信息
     * @param:
     * @return:
     * @date: 2020/2/25
     */
    @Override
    public Optional<AlarmEventPO> selectAlarmEventByCaseNumber(final String caseNumber) {
        /** 构造查询Request **/
        final QueryBuilder queryBuilder = QueryBuilders.termQuery(“caseNumber.keyword”, caseNumber);
        final SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder).size(1);
        final SearchRequest request = Requests.searchRequest(“city-event-processing”).source(searchSourceBuilder);

        try {
            /** 查询 **/
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            RestStatus restStatus = response.status();
            if (restStatus != RestStatus.OK) {
                throw CommonError.ES_ERROR.exception();
            }
            if (response.getHits().getHits().length == 0L) {
                return Optional.empty();
            } else {
                return Arrays.stream(response.getHits().getHits())
                    .map(hit -> JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class)).findFirst();
            }
        } catch (IOException e) {
            log.error("elastic search failed to search event, caseNumber:[{}]", caseNumber);
            throw CommonError.ES_ERROR.exception(e);
        }
    }

2.2、精准查询某些案件编号的案件
注：caseNumber为text类型，caseNumber.keyword为keyword类型

2.1.1、DSL语句

GET city-event-processing/_search
{
  "query": {
    "terms": {
      "caseNumber.keyword": [
        "2104231001042", "2104231001056"
        ]
    }
  }
}

2.1.2、RestHighLevelClient实现

    /**
     * @description: 根据案件号查询事件信息
     * @param:
     * @return:
     * @date: 2020/2/25
     */
    @Override
    public List<AlarmEventPO> selectAlarmEventByCaseNumber(final String[] caseNumbers) {
        /** 构造查询Request **/
        final QueryBuilder queryBuilder = QueryBuilders.termsQuery(“caseNumber.keyword”, caseNumbers);
        final SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder).size(1);
        final SearchRequest request = Requests.searchRequest(“city-event-processing”).source(searchSourceBuilder);

        try {
            /** 查询 **/
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            RestStatus restStatus = response.status();
            if (restStatus != RestStatus.OK) {
                throw CommonError.ES_ERROR.exception();
            }
            if (response.getHits().getHits().length == 0L) {
                return Collections.emptyList();
            } else {
                return Arrays.stream(response.getHits().getHits())
                    .map(hit -> JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class)).collect(Collectors.toList());
            }
        } catch (IOException e) {
            log.error("elastic search failed to search event, caseNumber:[{}]", caseNumber);
            throw CommonError.ES_ERROR.exception(e);
        }
    }

2.3、查询state为特定值或者state为某些值的案件
注：state为Integer类型

2.3.1、DSL

state为特定值

GET city-event-processing/_search
{
  "query": {
    "terms": {
      "state": [1]
    }
  }
}

state为某些值

GET city-event-processing/_search
{
  "query": {
    "terms": {
      "state": [1,2]
    }
  }
}

2.3.2、RestHighLevelClient实现

state为特定值

	/**
     * @description: 根据state状态查询事件信息
     * @param:
     * @return:
     * @date: 2020/2/25
     */
    @Override
    public List<AlarmEventPO> selectAlarmEventByState(final Integer state) {
        /** 构造查询Request **/
        final QueryBuilder queryBuilder = QueryBuilders.termQuery("state", state);
        final SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder);
        final SearchRequest request = Requests.searchRequest(“city-event-processing”).source(searchSourceBuilder);

        try {
            /** 查询 **/
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);

            if (response.getHits().getHits().length == 0L) {
                return Optional.empty();
            } else {
                return Arrays.stream(response.getHits().getHits())
                    .map(hit -> JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class)).collect(Collectors.toList());
            }
        } catch (IOException e) {
            log.error("elastic search failed to search event, caseNumber:[{}]", caseNumber);
            throw CommonError.ES_ERROR.exception(e);
        }
    }

state为某些值

	/**
     * @description: 根据state状态查询事件信息
     * @param:
     * @return:
     * @date: 2020/2/25
     */
    @Override
    public List<AlarmEventPO> selectAlarmEventByState(final Integer[] states) {
        /** 构造查询Request **/
        final QueryBuilder queryBuilder = QueryBuilders.termsQuery("state", states);
        final SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder);
        final SearchRequest request = Requests.searchRequest(“city-event-processing”).source(searchSourceBuilder);

        try {
            /** 查询 **/
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);

            if (response.getHits().getHits().length == 0L) {
                return Optional.empty();
            } else {
                return Arrays.stream(response.getHits().getHits())
                    .map(hit -> JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class)).collect(Collectors.toList());
            }
        } catch (IOException e) {
            log.error("elastic search failed to search event, caseNumber:[{}]", caseNumber);
            throw CommonError.ES_ERROR.exception(e);
        }
    }

2.4、范围查询，这里以createTime字段实验

2.4.1、DSL

GET city-event-processing/_search
{
  "query": {
    "range": {
      "createTime": {
        "gte": 1617762286042,
        "lte": 1617762286042
      }
    }
  }
}

gte:大于等于
lte:小于等于
gt:大于
lt:小于

2.4.2、RestHighLevelClient实现

	/**
     * @description: 根据createTime范围查询事件信息
     * @param:startTime 起始时间 endTime  结束时间
     * @return:
     * @date: 2020/2/25
     */
    @Override
    public List<AlarmEventPO> selectAlarmEventByTime(final Long startTime, final Long endTime) {
        /** 构造查询Request **/
        final QueryBuilder queryBuilder = QueryBuilders.rangeQuery(CREATE_TIME_KEY).gte(startTime).lte(endTime);
        final SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder);
        final SearchRequest request = Requests.searchRequest(“city-event-processing”).source(searchSourceBuilder);

        try {
            /** 查询 **/
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);

            if (response.getHits().getHits().length == 0L) {
                return Optional.empty();
            } else {
                return Arrays.stream(response.getHits().getHits())
                    .map(hit -> JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class)).collect(Collectors.toList());
            }
        } catch (IOException e) {
            log.error("elastic search failed to search event, caseNumber:[{}]", caseNumber);
            throw CommonError.ES_ERROR.exception(e);
        }
    }

2.5、多查询条件——与/且关系

时间范围查询(createTime)与（&&）案件号(caseNumber)前缀模糊查询

2.5.1、DSL

GET city-event-processing/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "prefix": {
            "caseNumber.keyword": {
              "value": "210508"
            }
          }
        },
        {
          "range": {
            "createTime": {
              "gte": 1619798400000,
              "lte": 1651115440000
            }
          }
        }
      ]
    }
  }
}

2.5.2、RestHighLevelClient实现

package com.elasticsearch.elasticsearchlearning.dao.impl;

import com.alibaba.fastjson.JSON;
import com.elasticsearch.elasticsearchlearning.constant.CommonConstant;
import com.elasticsearch.elasticsearchlearning.constant.CommonError;
import com.elasticsearch.elasticsearchlearning.dao.BaseElasticSearchDao;
import com.elasticsearch.elasticsearchlearning.dao.IAlarmEventDao;
import com.elasticsearch.elasticsearchlearning.modle.po.AlarmEventPO;
import com.elasticsearch.elasticsearchlearning.query.BaseEventPageQuery;
import com.elasticsearch.elasticsearchlearning.query.BaseEventQuery;
import com.elasticsearch.elasticsearchlearning.utils.Page;
import com.elasticsearch.elasticsearchlearning.utils.PageUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.megvii.framework.util.StringUtil;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.stereotype.Repository;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @param
 * @Author zhangwei
 * @Date 2021/4/29
 * @Description  案件dao
 */
@Slf4j
@Repository
public class AlarmEventDao extends BaseElasticSearchDao implements IAlarmEventDao {
    private static final String CASE_NUMBER_KEY = "caseNumber.keyword";
    private static final String CREATE_TIME_KEY = "createTime";
    //索引名
    private static final String INDEX_NAME = "city-event-processing";


    /**
     * 根据基础query查询案件
     * @param pageQuery
     * @return
     */
    @Override
    public List<AlarmEventPO> selectAlarmEventPOByBasePageQuery(BaseEventQuery pageQuery) {
        BoolQueryBuilder boolQueryBuilder = buildQueryBuilderByBaseEventQuery(pageQuery);
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().query(boolQueryBuilder);
        final SearchRequest request = Requests.searchRequest(INDEX_NAME).source(sourceBuilder);

        final List<AlarmEventPO> results = new ArrayList<>();
        try {
            // 处理结果
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            RestStatus restStatus = response.status();
            if (restStatus != RestStatus.OK) {
                throw CommonError.ES_ERROR.exception();
            }

            for (SearchHit hit : response.getHits().getHits()) {
                final AlarmEventPO result = JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class);
                results.add(result);
            }
        } catch (IOException e) {
            throw CommonError.ES_ERROR.exception(e);
        }
        
        return results;

    }

    private BoolQueryBuilder buildQueryBuilderByBaseEventQuery(BaseEventQuery query) {
        BoolQueryBuilder result = QueryBuilders.boolQuery();
        //根据案件号前模糊过滤
        String caseNumber = query.getCaseNumber();
        if (StringUtil.isNotEmpty(caseNumber)) {
            QueryBuilder builder = QueryBuilders.prefixQuery(CASE_NUMBER_KEY, caseNumber);
            result.must(builder);
        }
        Long startTime = query.getStartTime();
        //根据产生时间进行筛选
        if (null != startTime) {
            QueryBuilder builder = QueryBuilders.rangeQuery(CREATE_TIME_KEY).gte(startTime);
            result.must(builder);
        }
        Long endTime = query.getStartTime();
        if (null != endTime) {
            QueryBuilder builder = QueryBuilders.rangeQuery(CREATE_TIME_KEY).lte(endTime);
            result.must(builder);
        }
        return result;
    }
}

2.6、多查询条件并分页——或关系

**案件号(caseNumber)前缀模糊查询（记为A），时间范围查询(createTime)（记为B），地址全模糊查询（记为C） **
实现：A && (B || C)——A必须满足，B、C至少满足一个且实现分页
2.6.1、DSL实现

GET city-event-processing/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "prefix": {
            "caseNumber.keyword": {
              "value": "210517"
            }
          }
        }
      ],
      "should": [
        {
          "range": {
            "createTime": {
              "gte": 1621224018000,
              "lte": 1621245618000
            }
          }
        },
        {
          "wildcard": {
            "address.keyword": {
              "value": "*"
            }
          }
        }
        
      ],
      "minimum_should_match": 1
    }
  },
  "from": 100,
  "size": 20
}

2.6.2、RestHighLevelClient实现

    public Page<AlarmEventPO> selectAlarmShouldTest(BaseEventQuery pageQuery) {
        String caseNumber = pageQuery.getCaseNumber();
        Long startTime = pageQuery.getStartTime();
        Long endTime = pageQuery.getEndTime();
        Integer pageNo = pageQuery.getPageNo();
        Integer pageSize = pageQuery.getPageSize();
        int from = pageSize * (pageNo - 1);
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        /*根据案件号前模糊查询*/
        queryBuilder.must(QueryBuilders.prefixQuery(CASE_NUMBER_KEY, caseNumber));
        /*根据时间进行范围查询*/
        queryBuilder.should(QueryBuilders.rangeQuery(CREATE_TIME_KEY).gte(startTime).lte(endTime));
        /*根据地址全模糊查询*/
        queryBuilder.should(QueryBuilders.wildcardQuery(ADDRESS_KEY, "*友谊路*"));
        /*should条件至少满足一个*/
        queryBuilder.minimumShouldMatch(1);

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().from(from).size(pageSize).query(queryBuilder);
        final SearchRequest request = Requests.searchRequest(INDEX_NAME).source(sourceBuilder);

        final List<AlarmEventPO> results = new ArrayList<>();
        /*构造分页builder*/
        PageUtil.PageBuilder pageBuilder = PageUtil.of(pageNo, pageSize, CommonConstant.MAX_RESULT_WINDOW);
        long totalCounts;
        try {
            // 处理结果
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            RestStatus restStatus = response.status();
            if (restStatus != RestStatus.OK) {
                throw CommonError.ES_ERROR.exception();
            }

            for (SearchHit hit : response.getHits().getHits()) {
                final AlarmEventPO result = JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class);
                results.add(result);
            }
            totalCounts = getDocTotalCount(response.getHits().getTotalHits() , queryBuilder, INDEX_NAME);
        } catch (IOException e) {
            throw CommonError.ES_ERROR.exception(e);
        }

        return pageBuilder.build(totalCounts, results);

    }

    /**
     * @Author zhangwei
     * @Date 2021/3/26 18:59
     * @Description 根据查询条件算出总记录数
     */
    @SneakyThrows
    protected Long getDocTotalCount(QueryBuilder boolQueryBuilder, String... indices) {
        CountRequest countRequest = new CountRequest(indices);
        countRequest.query(boolQueryBuilder);
        CountResponse response = restHighLevelClient.count(countRequest, RequestOptions.DEFAULT);
        return response.getCount();
    }
    /**
     * TotalHits的relation为EQUAL_TO时,totalHits.value数量即为总数量
     */
    public long getDocTotalCount(TotalHits totalHits, QueryBuilder boolQueryBuilder, String... index){
        if (TotalHits.Relation.EQUAL_TO == totalHits.relation) {
            return totalHits.value;
        } else {
            return getDocTotalCount(boolQueryBuilder, index);
        }
    }

2.7、某查询条件下数量查询

2.7.1、DSL实现

GET city-event-processing/_count
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "state": {
              "value": 1
            }
          }
        }
      ]
    }
  }
}

2.7.2、RestHighLevelClient实现

    /**
     * @Author zhangwei
     * @Date 2021/3/26 18:59
     * @Description 根据查询条件算出总记录数
     */
    @SneakyThrows
    protected Long getDocTotalCount(QueryBuilder boolQueryBuilder, String... indices) {
        CountRequest countRequest = new CountRequest(indices);
        countRequest.query(boolQueryBuilder);
        CountResponse response = restHighLevelClient.count(countRequest, RequestOptions.DEFAULT);
        return response.getCount();
    }

2.8、searchAfter分页查询

2.8.1、searchAfter的运用场景
1、查询时会根据某个或某些字段进行排序。
2、排序后，查询排序字段某单边范围的数据。例如:按号码进行升序排序，查询大于等于1000的数据。
2.8.2、DSL实现

GET city-event-processing/_search
{
  "query": {
    "match_all": {}
  },
  "search_after":[
    "2105211000799"
  ],
  "from": 5, 
  "size": 10,
  "sort": [
    {
      "caseNumber.keyword": {
        "order": "asc"
      }
    }
  ]
}

2.8.3、RestHighLevelClient实现

/**
     * searchAfter分页查询测试
     * @param pageQuery
     * @return
     */
    public Page<AlarmEventPO> selectAlarmSearchAfterTest(BaseEventQuery pageQuery) {
        Integer pageNo = pageQuery.getPageNo();
        Integer pageSize = pageQuery.getPageSize();
        int from = pageSize * (pageNo - 1);
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().from(from).size(pageSize).query(queryBuilder);
        //按案件号进行排序
        sourceBuilder.sort(CASE_NUMBER_KEY, SortOrder.ASC);
        //大于某案件号分页查询
        sourceBuilder.searchAfter(new String[]{pageQuery.getCaseNumber()});
        final SearchRequest request = Requests.searchRequest(INDEX_NAME).source(sourceBuilder);

        final List<AlarmEventPO> results = new ArrayList<>();
        /*构造分页builder*/
        PageUtil.PageBuilder pageBuilder = PageUtil.of(pageNo, pageSize, CommonConstant.MAX_RESULT_WINDOW);
        long totalCounts;
        try {
            // 处理结果
            final SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
            RestStatus restStatus = response.status();
            if (restStatus != RestStatus.OK) {
                throw CommonError.ES_ERROR.exception();
            }

            for (SearchHit hit : response.getHits().getHits()) {
                final AlarmEventPO result = JSON.parseObject(hit.getSourceAsString(), AlarmEventPO.class);
                results.add(result);
            }
            totalCounts = getDocTotalCount(response.getHits().getTotalHits() , queryBuilder, INDEX_NAME);
        } catch (IOException e) {
            throw CommonError.ES_ERROR.exception(e);
        }

        return pageBuilder.build(totalCounts, results);

    }
/**
     * @Author zhangwei
     * @Date 2021/3/26 18:59
     * @Description 根据查询条件算出总记录数
     */
    @SneakyThrows
    protected Long getDocTotalCount(QueryBuilder boolQueryBuilder, String... indices) {
        CountRequest countRequest = new CountRequest(indices);
        countRequest.query(boolQueryBuilder);
        CountResponse response = restHighLevelClient.count(countRequest, RequestOptions.DEFAULT);
        return response.getCount();
    }
    /**
     * 在totalHits.relation为EQUAL_TO时，此时的value就是查询的总数
     * 查询统计数量
     */
    public long getDocTotalCount(TotalHits totalHits, QueryBuilder boolQueryBuilder, String... index){
        if (TotalHits.Relation.EQUAL_TO == totalHits.relation) {
            return totalHits.value;
        } else {
            return getDocTotalCount(boolQueryBuilder, index);
        }
    }
鲸落丶南北
关注
专栏目录
Elasticsearch Java API之计数（HighLevelClient）
qq_34810893的博客
03-23 4296
最近项目需要做一些修改，把之前访问MySQL进行查询改为Es查询，Es查询的优点这边就不赘述了。 因为之前是借助PageHelper实现的分页，PageHepler需要结果集的总数，SQL实现的话直接SELECT COUNT(1) FROM TABLE WHERE CONDITION;即可，Es也可以通过sourceBuilder.from(0).size(10000)这样设置一个足够大的siz...
ElasticSearch学习笔记(一)倒排索引、ES和Kibana安装、索引操作
最新发布
挑灯日记 记录自己
06-20 1230
为此，IK分词器提供了强大的停用词功能，让我们在索引时就直接忽略停用词汇表中的内容。但根据关键词查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的关键词，是。倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这又是无法接受的。先查询倒排索引，再查询倒排索引，但是无论是词条、还是文档id都建立了索引，查询速度非常快，而无需全表扫描。但由于网络问题，拉取失败了。则相反，是先找到用户要搜索的词条，根据词条得到保存词条的文档的id，然后根据id获取文档，是。
ElasticSearch系列 - SpringBoot整合ES：restHighLevelClient.count(countRequest, RequestOptions.DEFAULT)
你今天真好看呀
05-25 2155
这个示例代码执行了一个计数请求，查询 my_index 索引中 my_field 字段等于 my_value 的文档数量，并将结果保存在 count 变量中。该方法会返回一个 CountResponse 对象，表示计数请求的结果，包括符合查询条件的文档数量等信息。用于统计某个时间范围内处置状态为“已处置”或“处置中”的告警数量。
java.lang.ClassNotFoundException: org.elasticsearch.action.count.CountRequestBuilder 错误解决
往復不息的博客
07-21 4892
在使用elasticsearch的时候遇到了 java.lang.ClassNotFoundException:org.elasticsearch.action.count.CountRequestBuilder pom.xml配置文件如下 <dependencies> ... <dependency> <gro...
Java操作Elasticsearch6实现group by分组查询
Dream it Possible
11-18 7877
引言 通过上篇博客的总结，我们知道了在Elasticsearch6中count、distinct和count(distinct)方法的使用。本篇博客继续聚合查询的学习，也就是对应mysql中的group by的使用。 公共实体 对于下面要介绍的查询，返回结果为统一实体，代码如下： /** * 单个字段分组返回结果 * * @author : huzhiting * @date : 2020-11-18 15:02 */ @Data public class AggregationForOneDTO
java操作es查询数据总量
mianhuatang__的博客
07-18 7944
java操作es查询count
ElasticSearch学习笔记1
08-08
ElasticSearch学习笔记1 ElasticSearch是基于Lucene的搜索服务器，它提供了高性能的全文搜索功能，支持开箱即用的集群化扩展。ElasticSearch可以通过标准的REST API或特定于编程语言的客户端库与之交互。 一、什么...
Elasticsearch学习笔记之三
新新
11-10 1210
学习Elasticsearch做的笔记之三。 目录 01~05 ElasticSearch 1、什么是搜索。 2、如果用数据库做搜索会怎样。 3、什么是全文检索、倒排索引、Lucene。 （1）全文检索，倒排索引。 （2）Lucene.jar 4、什么是ElasticSearch。 5、ElasticSearch的功能。 （1）分布式的搜索引擎、数据分析引擎。 （2）全文检索、结构化检索、数据分析。 6、ElasticSearch的适用场景。 7、ES的特点。 8、Elas...
Elasticsearch学习笔记 - 04: 配置集群
u011682283的博客
12-24 486
ElasticSearch 共有两个配置文件，都位于 config 目录下，分别是 elasticsearch.yml 和 logging.yml，其中，elasticsearch.yml 是全局配置文件，用于在服务器级别对 ElasticSearch 进行配置。ElasticSearch 的配置选项分为静态设置和动态设置两种，静态设置必须在节点级别（node-level）设置，或配置在 elas...
ES学习笔记.docx
04-28
Kibana 操作笔记 本笔记主要记录了 Kibana 的常用操作，涵盖了...本笔记涵盖了 Kibana 的常用操作，包括 CRUD 操作、批量操作和查询操作，同时也介绍了一些重要的 Elasticsearch 概念，如分词、命中次数和版本控制等。
【Elasticsearch】java.lang.ClassNotFoundException: org.elasticsearch.client.core.CountRequest
Dream it Possible
12-05 4260
引言 之前在Elasticsearch搜索服务中增加了Count方法，可直接根据查询条件得到符合条件的总数，在搜索服务中也已经测试通过，但在引用了该服务的其他业务服务启动报错，如下： 排查 出现类似ClassNotFoundException这种错误，一般是引用的jar包有问题。搜索服务是用的6.8.6版本，并且该方法已经测试通过，所以想到的问题的原因是不是其他业务服务中引用的Elasticsearch版本并不是该版本的。 确实，发现业务服务中引用的elasticsearch版本并不是6.8.6，而是6.
ES的模糊查询，在多个索引或者单个索引，全局查询
qq_35458371的博客
06-12 8662
ES的模糊查询（ES查询），在多个索引或者单个索引，全局查询 官方的简单查询如下图： 可以在new SearchRequest()里的()中加入索引，就会根据下图的代码查询索引下所有数据。 或者可以指定多个索引进行查询： 因为FieldCapabilitiesRequest继承的是SearchRequest,所以只需要直接像FieldCapabilitiesRequest一样把fields()和indices()添加到SearchRequest后面就行了。可以指定多个field和index。 查询某个索
Java引入Elasticsearch实现增删改查
baidu_26819887的博客
07-04 649
Java如何简单引入elasticserache实现增删改查
Elasticsearch搜索辅助功能解析(十)
ntzzzsj的博客
08-06 2557
ES提供的各种搜索辅助功能。例如，为优化搜索性能，需要指定搜索结果返回一部分字段内容。为了更好地呈现结果，需要用到结果计数和分页功能；当遇到性能瓶颈时，需要剖析搜索各个环节的耗时；面对不符合预期的搜索结果时，需要分析各个文档的评分细节。...
分布式搜索Elasticsearch——创建客户端（一）
村长Korbin
12-28 2万+
注：该文及后续的几篇文章为概述，之后会将实例补充到文章中。 在elasticsearch源代码中，进入到org.elasticsearch.client，你会发现下图所示的类： 我们从最外层开始。 1 org.elasticsearch.client.AdminClient接口 AdminClient下有两个方法： 1) cluster()，产生一个允许从集群中执行act
【ElasticSearch教程】--- Elasticsearch文档条件查询(九)
maoye的博客
05-08 834
文档条件查询 在前面我们讲过对文档的查询，但是仅用了id和全查的方式, 这样的查询在实践中往往不能够满足多样化的检索需求。根据条件检索是非常必须的。条件查询的URL地址格式为http://127.0.0.1:9200/shopping/_search/q=查询条件. 例如我们希望直接查询品类为床上用品的所有数据. URL地址为:http://127.0.0.1:9200/shopping/_search?q=category:床上用品. 查询的请求方式为GET。发起请求如下图: 响应结果： { "
Elastic Search之Count API（获取符合条件的记录数）
热门推荐
分享传递价值
01-15 7万+
上篇说到elastic search(简称es)中常用的search api，但有时候我们不需要满足条件的原始文档数据，而是需要返回符合条件的文档数，类似于mysql的select count(*)查询条数，es中进行count查询的api的endpoint为"_count"，如下示例: 返回的count节点即表示符合条件的匹配数目。"_count"支持多个索引同时查询符合条件的匹配数: ...
ES006-Elasticsearch-JAVA客户端
艾文
10-13 3767
添加maven依赖 org.elasticsearch elasticsearch 1.4.4 1、连接到es集群 1.1 通过启动内嵌集群节点 1.2 如果只想做单元测试，不想把节点加入集群，就要启动一个本地的es。它需要把节点的local参数设置为true Node node = NodeBuilder.nodeBuilder().local
java.lang.ClassNotFoundException:org.elasticsearch.action.count.CountRequestBuilder
偶尔写些东西，意思一下我也参与了内卷
06-10 1425
此错误一般是采用springboot-start-data-elasticsearch的包所产生的 分析错误 一般此错误使用的springboot版本是1.* classNotFound说明没有这个包，意思是版本不对 点击start包的pom可以看到start-data-es版本大概是1.5.*的 解决 pom父子工程找到父pom添加指定依赖 这样子工程里面再引入start就是你指定的新版本了，思路大概是这样，有问题欢迎交流 ...
Elasticsearch学习笔记：从入门到精通的结构化搜索实战
"这篇es学习笔记详尽地介绍了如何使用Elasticsearch（ES）进行结构化数据的搜索，包括插入数据、查询映射以及利用term过滤器进行实战搜索。笔记内容适用于初学者到进阶者，通过实例展示了ES的灵活性和优势，并分析了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值