ElasticSearch的高级复杂查询：非聚合查询和聚合查询

一、非聚合复杂查询(这儿展示了非聚合复杂查询的常用流程)

1. 查询条件QueryBuilder的构建方法

• 1.1 精确查询（必须完全匹配上，相当于SQL语句中的“=”）

① 单个匹配 termQuery
//不分词查询 参数1： 字段名，参数2：字段查询值，因为不分词，所以汉字只能查询一个字，英语是一个单词.
QueryBuilder queryBuilder=QueryBuilders.termQuery("fieldName", "fieldlValue");
//分词查询，采用默认的分词器
QueryBuilder queryBuilder2 = QueryBuilders.matchQuery("fieldName", "fieldlValue");

② 多个匹配
//不分词查询，参数1： 字段名，参数2：多个字段查询值,因为不分词，所以汉字只能查询一个字，英语是一个单词.
QueryBuilder queryBuilder=QueryBuilders.termsQuery("fieldName", "fieldlValue1","fieldlValue2...");
//分词查询，采用默认的分词器
QueryBuilder queryBuilder= QueryBuilders.multiMatchQuery("fieldlValue", "fieldName1", "fieldName2", "fieldName3");
//匹配所有文件，相当于就没有设置查询条件
QueryBuilder queryBuilder=QueryBuilders.matchAllQuery();

• 1.2 模糊查询（只要包含即可，相当于SQL语句中的“LIKE”）

① 常用的字符串查询
//左右模糊
QueryBuilders.queryStringQuery("fieldValue").field("fieldName");

② 常用的用于推荐相似内容的查询
//如果不指定filedName，则默认全部，常用在相似内容的推荐上
QueryBuilders.moreLikeThisQuery(new String[] {"fieldName"}).addLikeText("pipeidhua");
③ 前缀查询 如果字段没分词，就匹配整个字段前缀
QueryBuilders.prefixQuery("fieldName","fieldValue");
④fuzzy query:分词模糊查询，通过增加fuzziness模糊属性来查询,如能够匹配hotelName为tel前或后加一个字母的文档，fuzziness 的含义是检索的
term 前后增加或减少n个单词的匹配查询
QueryBuilders.fuzzyQuery("hotelName", "tel").fuzziness(Fuzziness.ONE);
⑤ wildcard query:通配符查询，支持* 任意字符串；？任意一个字符
//前面是fieldname，后面是带匹配字符的字符串
QueryBuilders.wildcardQuery("fieldName","ctr*");
QueryBuilders.wildcardQuery("fieldName","c?r?");

• 1.3 范围查询

① 闭区间查询
QueryBuilder queryBuilder0 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2");
② 开区间查询
//默认是true，也就是包含
QueryBuilder queryBuilder1 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2")
.includeUpper(false).includeLower(false);
③ 大于
QueryBuilder queryBuilder2 = QueryBuilders.rangeQuery("fieldName").gt("fieldValue");
④ 大于等于
QueryBuilder queryBuilder3 = QueryBuilders.rangeQuery("fieldName").gte("fieldValue");
⑤ 小于
QueryBuilder queryBuilder4 = QueryBuilders.rangeQuery("fieldName").lt("fieldValue");
⑥ 小于等于
QueryBuilder queryBuilder5 = QueryBuilders.rangeQuery("fieldName").lte("fieldValue");

• 1.4 组合查询/多条件查询/布尔查询

QueryBuilders.boolQuery()
QueryBuilders.boolQuery().must();//文档必须完全匹配条件，相当于and
QueryBuilders.boolQuery().mustNot();//文档必须不匹配条件，相当于not
QueryBuilders.boolQuery().should();//至少满足一个条件，这个文档就符合should，相当于or

二、聚合查询
　　① 【概念】

Elasticsearch有一个功能叫做 聚合(aggregations) ，它允许你在数据上生成复杂的分析统计。它很像SQL中的 GROUP BY 但是功能更强大。
【注】 更好的理解概念，参考 https://blog.csdn.net/dm_vincent/article/details/42387161
Buckets(桶)：满足某个条件的文档集合。
Metrics(指标)：为某个桶中的文档计算得到的统计信息。
就是这样！每个聚合只是简单地由一个或者多个桶，零个或者多个指标组合而成。
通俗的讲可以粗略转换为SQL：select count(name) from table group by name
以上的COUNT(name)就相当于一个指标。GROUP BY name 则相当于一个桶。
桶和SQL中的组(Grouping)拥有相似的概念，而指标则与COUNT()，SUM()，MAX()等函数相似。
1、桶(Buckets)：一个桶就是满足特定条件的一个文档集合：
一名员工要么属于男性桶，或者女性桶。
城市Albany属于New York州这个桶。
日期2014-10-28属于十月份这个桶。
随着聚合被执行，每份文档中的值会被计算来决定它们是否匹配了桶的条件。如果匹配成功，那么该文档会被置入该桶中，同时聚合会继续执行。
桶也能够嵌套在其它桶中，能让你完成层次或者条件划分这些需求。比如，Cincinnati可以被放置在Ohio州这个桶中，而整个Ohio州则能够被放置在美国这个桶中。
ES中有很多类型的桶，让你可以将文档通过多种方式进行划分(按小时，按最流行的词条，按年龄区间，按地理位置，以及更多)。但是从根本上，它们都根据相同的原理运作：按照条件对文档进行划分。

2、指标(Metrics)：桶能够让我们对文档进行有意义的划分，但是最终我们还是需要对每个桶中的文档进行某种指标计算。分桶是达到最终目的的手段：提供了对文档进行划分的方法，从而让你能够计算需要的指标。多数指标仅仅是简单的数学运算(比如，min，mean，max以及sum)，它们使用文档中的值进行计算。在实际应用中，指标能够让你计算例如平均薪资，最高出售价格，或者百分之95的查询延迟。

3、聚合查询就是将两者结合起来，一个聚合就是一些桶和指标的组合。一个聚合可以只有一个桶，或者一个指标，或者每样一个。在桶中甚至可以有多个嵌套的桶。比如，我们可以将文档按照其所属国家进行分桶，然后对每个桶计算其平均薪资(一个指标)。因为桶是可以嵌套的，我们能够实现一个更加复杂的聚合操作：
将文档按照国家进行分桶。(桶)
然后将每个国家的桶再按照性别分桶。(桶)
然后将每个性别的桶按照年龄区间进行分桶。(桶)
最后，为每个年龄区间计算平均薪资。(指标)

　　② 聚合查询都是使用AggregationBuilders工具类创建，创建的聚合查询如下：

（1）统计某个字段的数量
ValueCountBuilder vcb= AggregationBuilders.count("count_uid").field("uid");
（2）去重统计某个字段的数量（有少量误差）
CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
（3）聚合过滤
FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
（4）按某个字段分组
TermsBuilder tb= AggregationBuilders.terms("group_name").field("name");
（5）求和
SumBuilder sumBuilder= AggregationBuilders.sum("sum_price").field("price");
（6）求平均
AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
（7）求最大值
MaxBuilder mb= AggregationBuilders.max("max_price").field("price");
（8）求最小值
MinBuilder min= AggregationBuilders.min("min_price").field("price");
（9）按日期间隔分组
DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
（10）获取聚合里面的结果
TopHitsBuilder thb= AggregationBuilders.topHits("top_result");
（11）嵌套的聚合
NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
（12）反转嵌套
AggregationBuilders.reverseNested("res_negsted").path("kps ");

三、项目中的具体例子

• 以下例子实现的功能是：使用es查询对数据进行分组然后求和统计，并且倒序排序

　　① 实体类：Project

 package com.adc.da.budget.entity;

 import com.adc.da.base.entity.BaseEntity;
 import com.adc.da.budget.annotation.MatchField;
 import com.adc.da.excel.annotation.Excel;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Getter;
 import lombok.Setter;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.annotations.Field;
 import org.springframework.data.elasticsearch.annotations.FieldType;
 import org.springframework.format.annotation.DateTimeFormat;

 import java.text.Collator;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;

 @Getter
 @Setter
 @Document(indexName = "financial_prd", type = "project")
 public class Project extends BaseEntity implements Comparable<Project> {

     public int compareTo(Project o) {
         return Collator.getInstance(java.util.Locale.CHINA).compare(this.getName(), o.getName());
     }

     //    matchField
 //     项目名称,业务方,人力投入,项目描述,所属业务,创建时间,项目负责人,人员
     //@Excel(name = "项目ID", orderNum = "1")
     @Id
     private String id;

     @Excel(name = "项目名称", orderNum = "")
     @MatchField("项目名称")
     //@Field
     private String name;

     //项目负责人ID
     @MatchField(value = "项目负责人", checkId = true)
     private String projectLeaderId;

     @Excel(name = "项目负责人", orderNum = "")
     @MatchField(value = "项目负责人")
     private String projectLeader;

     private String deptId;

     @Excel(name = "项目组成员", orderNum = "")
     @MatchField("人员")
     private String projectMemberNames;

     private String[] memberNames;

     @MatchField(value = "人员", checkId = true)
     private String[] projectMemberIds;

     // @Excel(name = "所属业务ID", orderNum = "5")
     @MatchField("所属业务ID")
     private String budgetId;

     /**
      * 经营类 （OA 项目编号）
      */
     private String budgetDomainId;

     /**
      * 经营类 （OA 项目编号）
      */
     private String contractNoDomainId;

     @Excel(name = "所属业务", orderNum = "")
     @MatchField("所属业务")
     private String budget;

     //@Excel(name = "业务类型ID", orderNum = "7")
     @MatchField("业务类型ID")
     private String businessId;

     @Excel(name = "业务类型", orderNum = "")
     @MatchField("业务类型")
     private String business;

     @Excel(name = "业务方", orderNum = "")
     @MatchField("业务方")
     private String projectOwner;

     @Excel(name = "创建时间", orderNum = "", exportFormat = "yyyy-MM-dd HH:mm:ss", importFormat = "yyyy-MM-dd HH:mm:ss")
     @MatchField("创建时间")
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date startTime;

     @Excel(name = "项目开始时间", orderNum = "", exportFormat = "yyyy-MM-dd HH:mm:ss", importFormat = "yyyy-MM-dd HH:mm:ss")
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date projectStartTime;

     @Excel(name = "项目完成状态", orderNum = "")
     private String finishedStatus;

     @Excel(name = "人力投入（人/天）", orderNum = "")
     @MatchField("人力投入")
     @Field(type = FieldType.Integer)
     private Integer personInput;

     //项目组成员  name 和 id
     private List<Map<String, String>> mapList;

     private List<Map<String,String>> userIdDeptNameMapList;

     private Date createTime;

     private Date modifyTime;

     //业务 n:1
     //质量考核 1:1
     private GualityInspection gualityInspection;

     //任务 1:n
     private List<Task> raskList;

     //收入费用 1:n
     private List<RevenueExpense> revenueExpenseList;

     // 支出费用 1:n
     private List<ExpensesIncurred> expensesIncurredList;

     @MatchField("项目描述")
     private String projectDescription;

     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String createUserId;

     private String createUserName;

     //删除标记
     private Boolean delFlag;

     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String pm;

     @Field(type = FieldType.String, analyzer = "not_analyzed")
     /*
      * 项目所属业务所在部门
      */
     private String projectTeam;

     @MatchField(value = "合同编号")
     private String contractNo;

     //业务创建人字段
     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String businessCreateUserId;

     //提供给前段判断是否能点状态按钮 0表示进行中
     private String btnFlag;

     private String approveUserId;

     @ApiModelProperty("是否具有修改权限")
     private Boolean manager;

     /**
      * 合同合计，转化为float型，存在失真，所以原始数据用 ，该字段仅应用于范围筛选
      *
      * @see #contractAmountStr
      */
     @Field(type = FieldType.Float)
     private float contractAmount;

     /**
      * 保证 表单中的数据精度
      * 项目搜索中 这个字段表示累计投入工时
      */
     private String contractAmountStr;
     /**
      * 开票金额
      */
     private List<ProjectContractInvoiceEO> projectContractInvoiceEOList;

     /**
      * 开始时间
      */
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date projectBeginTime;

     /**
      * 结束时间
      */
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private Date projectEndTime;

     /** 0. 经营类项目 ， 1.日常类事务项目 ， 2. 科研类项目*/
     private int projectType;

     private int projectYear;

     private int projectMonth;

     /**
      * 商务经理id
      *
      */
     private String businessManagerId;

     /**
      * 商务经理姓名
      *
      */
     private String businessManagerName;

     private String businessAdminId ;

     private String businessAdminName ;

     private String projectAdminId ;

     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String projectAdminName ;

     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String province;

     //乙方
     @Field(type = FieldType.String, analyzer = "not_analyzed")
     private String partyB;

 }

　　② 实现方法

 //根据业务方分组查询其合同金额并且倒序
 public List<Project> getProjectContractAmount(){

 /**本人觉得使用BoolQueryBuilder工具类也是可以的**/
 /* BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
 boolQueryBuilder.mustNot(QueryBuilders.termQuery(DEL_FLAG, true));

 boolQueryBuilder.must(QueryBuilders.termQuery("projectYear",projectYear));
 boolQueryBuilder.must(QueryBuilders.termQuery("projectType",0));

 TermsBuilder projectOwnerAgg = AggregationBuilders.terms("projectOwner").order(Terms.Order.aggregation("contractAmount", false));
 SumBuilder contractAmountAgg = AggregationBuilders.sum("contractAmount").field("contractAmount");

 TermsBuilder aa = projectOwnerAgg.subAggregation(contractAmountAgg);*/

 /**业务查询可以不用管Start**/
 String[] property = new String[1];
 property[0] = "0";
 List<BudgetEO> budgetEOList = budgetEODao.findAllBudgetNameNotLike("旧-%", property);
 //按中文首字母排序
 Collections.sort(budgetEOList);
 List<String> budgetIds = new ArrayList<>();
 for (BudgetEO budgetEO : budgetEOList) {
 budgetIds.add(budgetEO.getId());
 }

 Integer projectYear = Integer.parseInt(new SimpleDateFormat("yyyy").format(new Date()));
 /**业务查询可以不用管end**/

 //创建查询工具类，然后按照条件查询，可以分开也可以合在一起写
 QueryBuilder queryBuilder = QueryBuilders.boolQuery()
 .mustNot(QueryBuilders.termQuery(DEL_FLAG, true))
 .must(QueryBuilders.termQuery("projectYear",projectYear))
 .must(QueryBuilders.termQuery(PROJECT_TYPE,0))
 .must(QueryBuilders.termsQuery(BUDGET_ID, budgetIds));

 //构建查询
 NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder().withQuery(queryBuilder);

 /*
 //这里的作用是查询后显示指定的字段和不显示的字段设置

 String[] fileds = {"projectOwner","contractAmount"};
 nativeSearchQueryBuilder.withFields(fileds);
 String[] filterFileds = {"不需要显示的字段"}
 nativeSearchQueryBuilder.withSourceFilter(new FetchSourceFilter(fileds,filterFileds));

 */

 /**
 *创建聚合函数：本例子是以 projectOwner公司名称分组然后计算其contractAmount合同金额总和并且按照合同金额倒序排序
 * 相当于SQL语句 select projectOwner,sum(contractAmount) as contractAmount from peoject group by projectOwner order by contractAmount desc
 */
 TermsBuilder projectOwnerAgg =
 AggregationBuilders.terms("projectOwner").field("projectOwner").
 order(Terms.Order.aggregation("contractAmount",false));
 SumBuilder contractAmountAgg = AggregationBuilders.sum("contractAmount").field("contractAmount");
 nativeSearchQueryBuilder.addAggregation(projectOwnerAgg.subAggregation(contractAmountAgg));
 SearchQuery searchQuery = nativeSearchQueryBuilder.build();

 /***
 * 执行查询 参考网上有三种方式
 */
 /**
 * ① 通过reporitory执行查询,获得有Page包装了的结果集
 * //Page<Project> projects = projectRepository.search(searchQuery);
 */

 /**
 * ② 通过elasticSearch模板elasticsearchTemplate.queryForList方法查询
 * List<Project> projects = elasticsearchTemplate.queryForList(searchQuery, Project.class);
 */

 /**
 * ③ 通过elasticSearch模板elasticsearchTemplate.query()方法查询,获得聚合(常用)
 */
 Aggregations aggregations = elasticsearchTemplate.query(searchQuery, new ResultsExtractor<Aggregations>() {
 @Override
 public Aggregations extract(SearchResponse searchResponse) {
 return searchResponse.getAggregations();
 }
 });

 /**
 * 对查询结果处理
 */
 //转换成map集合
 Map<String, Aggregation> aggregationMap = aggregations.asMap();
 //获得对应的聚合函数的聚合子类，该聚合子类也是个map集合,里面的value就是桶Bucket，我们要获得Bucket
 StringTerms stringTerms = (StringTerms)aggregationMap.get("projectOwner");
 //获得所有的桶
 List<Terms.Bucket> buckets = stringTerms.getBuckets();

 /* 一 、使用Iterator遍历桶
 //将集合转换成迭代器遍历桶,当然如果你不删除buckets中的元素，直接foreach遍历就可以了
 Iterator<Terms.Bucket> iterator = buckets.iterator();
 List<String> projectOwnerList = new ArrayList<>();
 while (iterator.hasNext()){
 //bucket桶也是一个map对象，我们取它的key值就可以了
 String projectOwner = iterator.next().getKeyAsString();
 //根据projectOwner去结果中查询即可对应的文档，添加存储数据的集合
 projectOwnerList.add(projectOwner);
 }*/

 //② 使用 foreach遍历就可以了
 List<Project> projects = new ArrayList<>();
 for (Terms.Bucket bucket : buckets){
 Project project = new Project();
 String projectOwner = bucket.getKeyAsString();
 //得到所有子聚合
 Map<String, Aggregation> contractAmountSumbuilder = bucket.getAggregations().asMap();
 //sum值获取方法 如果是avg，那么这里就是Avg格式
 Sum contractAmounts = (Sum)contractAmountSumbuilder.get("contractAmount");
 double contractAmount = contractAmounts.getValue();

 project.setProjectOwner(projectOwner);
 project.setContractAmount((float) contractAmount);
 projects.add(project);

 }

 return projects;
 }

四、参考博文地址

https://www.cnblogs.com/xionggeclub/p/7975982.html

https://blog.csdn.net/qq_40885085/article/details/105024625

https://my.oschina.net/guozs/blog/716802

https://blog.csdn.net/topdandan/article/details/81436141

https://blog.csdn.net/justlpf/article/details/88105489

https://blog.csdn.net/topdandan/article/details/81436141