【ElasticSearch8】springboot整合es8（二），实现复杂检索

springboot elasticSearch8开发（二），实现复杂检索

大师兄小灰灰

2796人浏览 · 2022-08-25 15:16:58

大师兄小灰灰 · 2022-08-25 15:16:58 发布

queryPageByFileds：查询分页信息

queryCountByFileds:查询满足复合查询条件的数据量

queryByFiledsWithPage:复合条件分页查询

getFieldValues：构建复合查询条件

官方api：

Connecting | Elasticsearch Java API Client [8.4] | Elastichttps://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current/connecting.html

springboot elasticSearch8开发（一），实现简单查询_大师兄小灰灰的博客-CSDN博客springboot+ElasticSearch8开发，实现简单查询https://blog.csdn.net/qq_24473507/article/details/123924463

上一篇文章发布已经过去了四个月，终于有时间补充一下了。

基于上篇简单查询基础上，新增了复合查询的功能

复合查询

复合查询用到的es查询对象为：

BoolQuery，

BoolQuery内部定义了List类型的Query对象，顾名思义，支持多个关键字复合查询

public class BoolQuery extends QueryBase implements QueryVariant {
    private final List<Query> filter;
    @Nullable
    private final String minimumShouldMatch;
    private final List<Query> must;
    private final List<Query> mustNot;
    private final List<Query> should;

通常都是将多个查询条件组合在一起，常用的有must(and)、must_not(not)、should(or)，今天的案例主要用must实现复合查询

直接上代码：

查询对象实体类

添加了时间范围。关键字数组字段：

package com.hdkj.hdiot.configure.es.bean;

import cn.hutool.core.date.DateUtil;
import co.elastic.clients.elasticsearch._types.SortOrder;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;

import java.util.Date;
import java.util.List;

/**
 * @author liuch
 * @title: EsQueryDTO
 * @description: 查询对象
 * @date 2022/4/2 10:32
 */
@Data
public class EsQueryDTO {
    @ApiModelProperty("索引名称")
    private String indexName;
    @ApiModelProperty("关键字属性")
    private String field;
    @ApiModelProperty("关键字值")
    private String word;
    @ApiModelProperty("关键字值数组")
    private List<String> words;
    @ApiModelProperty("起始行")
    private Integer from;
    @ApiModelProperty("当前页")
    private Integer index;
    @ApiModelProperty("分页条数")
    private Integer size;
    @ApiModelProperty("排序字段")
    private String order;
    @ApiModelProperty("排序方式 asc/desc")
    private String orderType;


    @ApiModelProperty("时间字段")
    private String dateField;
    @ApiModelProperty("时间范围-开始时间")
    private String startTime;
    @ApiModelProperty("时间范围-结束时间")
    private String endTime;

    public String getOrderType() {
        if(StringUtils.isBlank(orderType)){
            orderType = SortOrder.Desc.name();
        }
        return orderType;
    }

    public Integer getSize() {
        return size==0?30:size;
    }

    public Integer getFrom() {
        return  getIndex()!=0?((getIndex()-1)*getSize()):0;
    }

    public Integer getIndex() {
        return null==index?0:index;
    }

    public String getStartTime(int offset) {
        if(StringUtils.isBlank(startTime)){
            startTime = DateUtil.format(DateUtil.offsetDay(new Date(),offset),"yyyy-MM-dd 00:00:00");
            return String.valueOf(DateUtil.parse(startTime,"yyyy-MM-dd 00:00:00").getTime());
        }
        return startTime;
    }

    public String getEndTime() {
        if(StringUtils.isBlank(endTime)){
            endTime = String.valueOf(System.currentTimeMillis());
        }
        return endTime;
    }
}

构件查询条件列表

ElasticClientUtils工具类复合查询方法：

queryPageByFileds：查询分页信息

基于from/size方式实现分页查询，是有查询限制的

为了保证性能，es默认最大查询1W条数据，可以通过调整max_result_window值修改最大查询数量。具体内容兄弟们自行找度娘。

这里直接最大支持查询1W条数据。

 /**
     * @param
     * @param client
     * @param dto
     * @param target
     * @return com.hdkj.hdiot.configure.common.PageData<T>
     * @author liuch
     * @description 查询分页信息-复合查询
     * @date 2022/4/2 17:16
     */
    public PageData<T> queryPageByFileds(ElasticsearchClient client, EsQueryDTO dto, List<Query> queries,Class<T> target) throws Exception {
        if(null == queries){
            queries = new ArrayList<>();
        }
          //查询满足复合查询条件的数据量
        long total = queryCountByFileds(client,queries, dto);
        //总条数超过1万,则只返回一万总条数
        if(total>10000){
            total = 10000;
        }
        List<T> result = queryByFiledsWithPage(client, dto, queries,target);
        PageData<T> pageData = new PageData<>(result, total);
        return pageData;
    }

queryCountByFileds:查询满足复合查询条件的数据量


    /**
     * @param
     * @param client
     * @param dto
     * @return long
     * @author liuch
     * @description 根据关键字查询总条数-复合查询
     * @date 2022/4/2 17:15
     */
    public long queryCountByFileds(ElasticsearchClient client, List<Query> queries, EsQueryDTO dto) throws Exception {
        getFieldValues(dto, queries);
        CountResponse count = client.count(c -> c.index(dto.getIndexName()).query(q->q.bool(b->b.must(queries))));
        long total = count.count();
        return total;
    }

queryByFiledsWithPage:复合条件分页查询


    /**
     * @param client
     * @param dto
     * @param target
     * @return java.util.List<T>
     * @author liuch
     * @description 根据关键字分页查询- 复合查询
     * @date 2022/4/2 17:15
     */
    public List<T> queryByFiledsWithPage(ElasticsearchClient client, EsQueryDTO dto, List<Query> queries,Class<T> target) throws Exception {
        List<T> result = new ArrayList<>();
        List<SortOptions> sorts = new ArrayList<>();
        if (StringUtils.isNotBlank(dto.getOrder())) {
            //设置排序
            SortOptions sortOptions = SortOptions.of(s -> s.field(f -> f.field(dto.getOrder()).order(SortOrder.valueOf(dto.getOrderType()))));
            sorts.add(sortOptions);
        }
        //执行复合查询
        SearchResponse<HashMap> search = client.search(s -> s
                        .index(dto.getIndexName())
                        .query(q->q.bool(b->b.must(queries)))
                        .sort(sorts).from(dto.getFrom()).size(dto.getSize()),
                HashMap.class);
        return getResult(target, result, search);
    }

getFieldValues：构建复合查询条件


    /**
     * 构建复合查询条件
     * @param dto
     * @param queries
     */
    private void getFieldValues(EsQueryDTO dto, List<Query> queries) {
        List<FieldValue> fieldValues = new ArrayList<>();
        //根据关键字列表构件复合查询的值
        dto.getWords().stream().forEach(word -> fieldValues.add(FieldValue.of(word)));
        //给默认查询条件设置多个值
        queries.add(Query.of(q->q.terms(t -> t.field(dto.getField()).terms(v -> v.value(fieldValues)))));
    }

查询：根据实际业务场景，将时间范围作为条件之一，再设置需要的其他条件

/**
     * 获取解码失败报文
     *
     * @param dto
     * @return
     */
    @Override
    public Result getDecodeFailMsg(EsQueryDTO dto) {
        try {
            //查询索引名称
            dto.setIndexName("origin_data");
            //默认查询关键字
            dto.setField("drvid");
            dto.setOrder("created");
            dto.setOrderType(SortOrder.Desc.name());
            List<Query> queryList = new ArrayList<>();
            if (StringUtils.isNotBlank(dto.getStartTime())) {
                //通过range设置时间查询范围
                queryList.add(Query.of(q -> q.range(r -> r.field("created").from(dto.getStartTime()).to(dto.getEndTime()))));
            }
            //添加解码失败条件和值
            queryList.add(Query.of(q -> q.term(t -> t.field("decoded").value(0))));
            PageData<HdiotOriginalDTO> pageData = new ElasticClientUtils<HdiotOriginalDTO>().queryPageByFileds(client, dto, queryList, HdiotOriginalDTO.class);
            return new Result().ok(pageData);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result().error(e.getMessage());
        }
    }

以上就是复合查询的全部内容，可能比较乱，有问题欢迎大家评论区发言指正。

后面会再更新一篇基于scroll的深度分页查询，大家多多支持！

https://blog.csdn.net/qq_24473507/article/details/126525835https://blog.csdn.net/qq_24473507/article/details/126525835

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24473507/article/details/126524062
————————————————
版权声明：本文为CSDN博主「大师兄小灰灰」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_24473507/article/details/126524062