solr快速上手：聚合分组查询｜嵌套分组指南（十二）

清疚 2024-03-23 23:24 88阅读 0赞

## 0. 引言 ##

solr作为搜索引擎经常用于各类查询场景，我们之前讲解了[solr的查询语法][solr]，而除了普通的查询语法，有时我们还需要实现聚合查询来统计一些指标，所以今天我们接着来查看solr的聚合查询语法

## 1. 常用聚合查询语法 ##

以下演示我们基于之前创建的核心数据进行，可以参考专栏之前的文章

核心字段结构如下：

> order\_no : 订单号  
> address: 地址  
> product\_name: 商品  
> status: 状态  
> labels: 标签  
> remarks: 备注

### 1.1 group 分组查询 ###

#### 1.1.1 简介 ####

group用于实现简单的聚合分组查询、数值计算等

官网文档：[https://solr.apache.org/guide/8\_2/result-grouping.html][https_solr.apache.org_guide_8_2_result-grouping.html]

#### 1.1.2 参数 ####

*  group: 设置为true后，查询按分组显示，group:true
 *  group.field: 根据哪个字段设置分组，配合group:true使用

q=*:*&group=true&group.field=product_name

![在这里插入图片描述][eea3a4b08e004f42b321b4bf876ef7d8.png]

*  group.limit：限制返回的docs条数，默认为1，如上所示的示例中，我们发现，每个分组不仅返回的分组数，也返回了命中的详细数据，有的时候我们不需要详细数据，这时就可以将group.limit设置为0来控制返回条数

q=*:*&group=true&group.field=product_name&group.limit=0

![在这里插入图片描述][e7304f2724294576a6e687c6c6d30fe4.png]

*  group.func: 根据函数计算出来的值进行分组，函数支持：求和sum,最小值min,最大值max

q=*:*&group=true&group.func=sum(status)

![在这里插入图片描述][6a785ef545ec4d9ab9ef1d35135eb60f.png]

*  group.query：根据查询条件进行分组。比如将数据按照0<=id<=2, 3<=id<=5, 6<=id<=20进行分组

q=*:*&group=true&group.query=id:[0 TO 2]&group.query=id:[3 TO 5]&group.query=id:[6 TO 20]

![在这里插入图片描述][dcad145abc524b7aa05f9203903b17c1.png]

*  group.format, 支持两个值：grouped和simple，默认为grouped, 按分组结果展示，如果设置为simple，则会将匹配的结果按平面列表展示，具体可见下图

q=*:*&group=true&group.field=product_name&group.format=simple
    q=*:*&group=true&group.field=product_name&group.format=grouped

![在这里插入图片描述][b288d8b3f5654ccaa5da334a80af80c4.png]

*  group.main，是否将第一个字段分组的结果作为返回数据的主结果集，有点类似于group.format=simple (以下解释暂为个人理解，待深入验证，可能存在误解，仅供参考)

q=*:*&group=true&group.field=product_name&group.main=true

![在这里插入图片描述][5c069e4a87254b0f91b47480f6942ae2.png]  
多个分组条件时，显示的就是按照优先级排序后的第一个分组条件的结果详情列表

> 这里满足group.field=status分组的列表个数是10个，满足group.query:id\[0 TO 4\]的是4个，因为排序下来group.query:id\[0 TO 4\]是第一个分组结果集，所以返回的是4个  
> ![在这里插入图片描述][dd8d788bb63a4fc992798b1e559d5f1d.png]

*  group.sort：每个分组内文档的排序方式，如下所示，根据status分组，每个分组内docs返回根据id逆序

q=*:*&group=true&group.field=status&group.sort=id desc&group.limit=5

![在这里插入图片描述][729edbd376be42cb96fe99e532402aa8.png]

*  group.offset：每个分组返回的docs的起点位位置，如下所示，设置group.offset=6，则从id>6后的数据开始显示

q=*:*&group=true&group.field=status&group.limit=4&group.offset=6

![在这里插入图片描述][bee6f3d5cb48422bbe037c595b6cc3ac.png]

*  group.ngroups：是否显示分组数，默认为false

q=*:*&group=true&group.field=status&group.limit=4&group.ngroups=true

![在这里插入图片描述][aa160087102a4e27b020546c71c9b1bf.png]

*  group.truncate，默认为false， 当为ture时，facet计数将基于每组中与查询条件相关度高的文档，而不是全部文档（研究中，暂未找到合适案例）
 *  row：显示分桶数量，默认为10，有时我们分桶数据不止10个，需要增加显示，可以用row参数设置，相当于sql中的limit
 *  start：从第几个开始，与row配合，共同组成分页显示
 *  sort: 根据指定字段进行组间排序，有该字段的桶也将排序在前。与group.sort的区别是：sort用于控制组间排序，group.sort控制组内排序。

q=*:*&group=true&group.field=product_name&group.limit=10&rows=10&sort=status desc

![在这里插入图片描述][040b41c9007e4917a12428141867a239.png]

*  group.cache.percent：分组搜索结果占用堆内存的百分比，当设置大于0时即开启搜索结果缓存，数值越大允许缓存占用的堆内存大小越大。根据官方的解释，该配置会提升布尔、通配符、模糊查询的效率，但却会降低普通查询效率

#### 1.1.3 案例 ####

*  1、统计销量排行前5的商品

> 思路：在开始之前我们需要注意，单纯使用group实际上是无法完成此题的，因为group不支持按照各个桶数量进行排序，需要使用facet，我们将在下文讲解，但如果只使用group的话，排序需要借助java代码再来实现

DSL:

q=*:*&group=true&group.field=product_name&group.limit=0&rows=100

查询结果：  
![在这里插入图片描述][0dd600c83e084f0e9762ca7c1b58b9d2.png]

solrJ客户端代码：

@RestController
    @RequestMapping("group")
    @AllArgsConstructor
    public class GroupSearchController {
        
        private final HttpSolrClient solrClient;
    
        @GetMapping("sellTopFive")
        public Map<String, Long> sellTopFive() {
        
            Map<String, Long> result = new HashMap<>();
            // 设置查询条件
            SolrQuery query = new SolrQuery().setQuery("*:*").setRows(100);
            // 设置分组条件
            query.set(GroupParams.GROUP, true)
                    .set(GroupParams.GROUP_FIELD, "product_name")
                    .set(GroupParams.GROUP_LIMIT, 0);
            try {
        
                QueryResponse response = solrClient.query("orders",query);
                GroupResponse groupResponse = response.getGroupResponse();
    
                List<GroupCommand> values = groupResponse.getValues();
                GroupCommand group = values.get(0);
                List<Group> productGroups = group.getValues();
                for (Group productGroup : productGroups) {
        
                    result.put(productGroup.getGroupValue(), productGroup.getResult().getNumFound());
                }
                // 根据数量逆序排序，截取前5
                return result.entrySet().stream()
                        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                        .limit(5)
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
            } catch (SolrServerException | IOException e) {
        
                e.printStackTrace();
                return result;
            }
        }
    }

spring-data-solr客户端代码：

@RestController
    @RequestMapping("group")
    @AllArgsConstructor
    public class GroupSearchController {
        
        private final SolrTemplate solrTemplate;
    
        @GetMapping("sellTopFive2")
        public Map<String, Long> sellTopFive2() {
        
            Map<String, Long> result = new HashMap<>();
    
            // 设置分组条件
            Field field = new SimpleField("product_name");
            SimpleQuery groupQuery = new SimpleQuery(new SimpleStringCriteria("*:*")).setRows(100);
            GroupOptions groupOptions = new GroupOptions()
                    .addGroupByField(field)
                    .setLimit(0);
            groupQuery.setGroupOptions(groupOptions);
    
            try {
        
                GroupPage<Orders> page = solrTemplate.queryForGroupPage("orders", groupQuery, Orders.class);
                GroupResult<Orders> fieldGroup = page.getGroupResult(field);
    
                List<GroupEntry<Orders>> content = fieldGroup.getGroupEntries().getContent();
                for (GroupEntry<Orders> ordersGroupEntry : content) {
        
                    result.put(ordersGroupEntry.getGroupValue(), ordersGroupEntry.getResult().getTotalElements());
                }
    
                // 根据数量逆序排序，截取前5
                return result.entrySet().stream()
                        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                        .limit(5)
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
            }catch (Exception e){
        
                e.printStackTrace();
                return result;
            }
    
        }
    }

执行结果：  
![在这里插入图片描述][0f5fe23f5f2c435581d3eba5c190e2e7.png]

*  2、各个标签的订单数

> 思路：此题与上述的区别，就在于分组的字段labels是Nested类型，但group分组不支持Nested字段的分组，因此使用group是无法实现的，我们将在Facet中讲解用法

![在这里插入图片描述][44360ba376f84c15b52e3c0a8f1d40e8.png]

### 1.2 facet 分组查询 ###

#### 1.2.1 简介 ####

facet与group有些相近，都是做分组查询的，但是facet允许用户再对结果集进行二次处理，也就是支持嵌套聚合，也可以对分组数量进行排序、过滤等，group会返回每个分组详细的数据列表docs，而facet并不会返回每个分组的docs，只是返回一个统计指标。facet与group可以结合使用。

官方文档：[https://solr.apache.org/guide/8\_2/faceting.html][https_solr.apache.org_guide_8_2_faceting.html]

facet分组查询支持4大类型：  
facet.query: 自定义查询分组  
facet.field：按字段分组  
facet.range: 范围查询分组  
facet.date：日期分组

#### 1.2.2 参数 ####

*  facet: 设置为true则开启facet分组查询
 *  facet.field：以什么字段作为分组统计字段，如下所示，可以看到与group明显的区别，是没有返回每个分组的docs了。

q=*:*&facet=true&facet.field=product_name

![在这里插入图片描述][b1225dbfae274fe3939022c1fc6594dd.png]  
与group.field一样，也可以设置多个分组字段

q=*:*&facet=true&facet.field=product_name&facet.field=status

![在这里插入图片描述][826f7e9b19714b9f8d28f35b31e6233c.png]

*  facet.pivot：多字段嵌套分组，如上所示的分组是分割开单独分组的，某些场景下我们需要嵌套分组，基于前一个分组结果继续做分组，这就需要用到facet.pivot， 比如，统计每种状态下各个商品的个数

q=*:*&facet=true&facet.pivot=status,product_name

![在这里插入图片描述][f0a7364c008642f3bf44858e44679f75.png]

*  facet.pivot.mincount，嵌套分组显示最小数量，有时我们希望显示的分组是具有一定数量的，数量比较小的就不要显示了，这就需要用到facet.pivot.mincount，默认值为1

q=*:*&facet=true&facet.pivot=status,product_name&facet.pivot.mincount=2

![在这里插入图片描述][b1d2bcc61a9a4cd58a5a470f07485de1.png]

*  facet.mincount：分组最小数量，与facet.pivot.mincount不同的是，这个是控制facet.field产生的普通分组
 *  facet.query: 根据查询条件来进行分类，可以设置多个facet.query，来实现自定义的分组统计

q=*:*&facet=true&facet.query=status:1&facet.query=status:2

![在这里插入图片描述][6dd386764a264b2ea800102671d3617d.png]

*  facet.prefix：分组字段的值满足该前缀的才会被统计

q=*:*&facet=true&facet.field=product_name&facet.prefix=小米

![在这里插入图片描述][a8f76e84a7fe4406b6511a5703a38980.png]

*  facet.contains：分组字段包含该值的才会被分组统计

q=*:*&facet=true&facet.field=product_name&facet.contains=小米

![在这里插入图片描述][5941e7887c804926b74b159be86d148b.png]

*  facet.contains.ignoreCase: 与facet.contains的区别就是不区分大小写
 *  facet.matches：分组字段值满足该正则表达式的才会被分组统计（未实际使用，待验证）

q=*:*&facet=true&facet.field=product_name&facet.matches=米*

facet.sort：分组排序条件，允许设置两个值：count 按照每个桶的数量逆序排序、index：按照各分组桶名字符排序，默认为count

q=*:*&facet=true&rows=0&facet.field=product_name&facet.sort=index

![在这里插入图片描述][e00fc303af584e329f8bf6ff8f58aa13.png]

*  facet.limit：返回的桶数量，默认100

q=*:*&facet=true&rows=0&facet.field=product_name&facet.limit=5

![在这里插入图片描述][b8464c41e2b14056b450fc9b3b38ef85.png]

*  facet.offset：从第几个桶开始显示

q=*:*&facet=true&rows=0&facet.field=product_name&facet.limit=5&facet.offset=2

![在这里插入图片描述][499a901aba164c2d98de17bcbce48a40.png]

*  facet.missing：文档数据（每一行数据）中分组字段facet.field没有值的是否统计，默认为false
 *  facet.method：指定分组算法，支持三种分组算法：fc, enum, filterCache，默认为fc。详细解释可见官方文档
 *  facet.threads：分组查询创建的线程数，最大值`Integer.MAX_VALUE`，最小值0，这时只会创建一个主线程

**范围查询分组**

*  facet.range: 定义范围查询的字段
 *  facet.range.start：范围查询的最小值
 *  facet.range.end：范围查询的最大值
 *  facet.range.gap：范围查询的步长（每组间隔）
 *  facet.range.hardend：是否将`facet.range.end`最为最后一组的上限，值为true/false，默认为false，false时将会把最后一组上限设置为大于`facet.range.end`的最小可能上限。比如facet.range.end=4，文档中大于4的还有5、6、7，则如果为false时会取5最为上限

q=*:*&facet=true&rows=0&facet.range=status&facet.range.start=1&facet.range.end=5&facet.range.gap=3&facet.range.hardend=true

![在这里插入图片描述][337b6654106242a194ad5b4feeaa5682.png]  
也可以实现按日期月份分组的效果，`%2B`表示URL中的`+`

q=*:*&facet=true&rows=0&facet.range=create_time&facet.range.start=NOW/MONTH-12MONTH&facet.range.end=NOW/MONTH&facet.range.gap=%2B1MONTH

![在这里插入图片描述][de1ca5c7b5834f989bed931b47325f90.png]

*  facet.range.include：指定每个区间中，是否包含上下限

> lower：所有区间都包含其下限  
> upper：所有区间都包含其上限  
> edge：即使未指定相应的上限/下限选项，第一个和最后一个间隙范围也包括其边缘边界（第一个间隙范围较低，最后一个间隙范围较高）  
> outer：第一个或最后一个区间包含其边界  
> all：包含上述所有选项

*  facet.range.other：其他区间统计规则，值为before、after、between、none、all，默认为none

> before：对start之前的值做统计  
> after：对end之后的值做统计  
> between：对start至end之间所有值做统计，如果hardend为true的话,那么该值就是各个时间段统计值的和  
> none：表示该项禁用  
> all：表示before,after,all都会统计

如果指定了多个范围字段的话，通过facet.<field\_id>的形式区分

facet.range=price&facet.range=age&facet.range=lastModified_dt
    &f.price.facet.range.end=1000.0
    &f.age.facet.range.start=99
    &f.lastModified_dt.facet.range.end=NOW/DAY+30DAYS

**指定间隔分组**

*  facet.interval：间隔统计字段
 *  facet.interval.set：间隔统计指定区间

q=*:*&facet=true&rows=0&facet.interval=status&facet.interval.set=(0,1]&facet.interval.set=[1,3]

![在这里插入图片描述][0e5a9ed625c84461bd1d8758f5227ba0.png]  
**时间类型分组**

*  facet.date：该参数表示需要进行按时间分组的字段名,与facet.field一样,该参数可以设置多个
 *  facet.date.start：起始时间
 *  facet.date.end：结束时间
 *  facet.date.gap：时间间隔.如果start为2023-01-01,end为2024-01-01，gap设置为`+1MONTH`则表示间隔1个月,那么将会把这段时间划分为12个间隔段
 *  facet.date.hardend ：与facet.range.hardend类似  
    facet.date.other 其他区间统计规则，与facet.range.other类似

#### 1.2.3 案例 ####

*  1、统计销量排行前5的商品

> facet中默认就根据每组桶数逆序排序，无需特殊指定，如果需要根据桶名排序的，修改facet.sort=index即可

q=*:*&facet=true&rows=0&facet.field=product_name&facet.limit=5

![在这里插入图片描述][00a981f2ea7644eb9cd08112e44a1a2c.png]  
SolrJ实现代码：

@RestController
    @RequestMapping("facet")
    @AllArgsConstructor
    public class FacetSearchController {
        
    
        private final HttpSolrClient solrClient;
    
        /**
         * 统计销量排行前5的商品
         * @return
         */
        @GetMapping("sellTopFive")
        public Map<String, Long> sellTopFive(){
        
            Map<String, Long> result = new HashMap<>();
    
            // 设置查询条件
            SolrQuery query = new SolrQuery().setQuery("*:*").setRows(0);
            // 设置分组条件
            query.set(FacetParams.FACET, true)
                    .set(FacetParams.FACET_FIELD, "product_name")
                    .set(FacetParams.FACET_LIMIT, 5);
    
            try {
        
                QueryResponse response = solrClient.query("orders",query);
                FacetField facetFields = response.getFacetField("product_name");
                for (FacetField.Count value : facetFields.getValues()) {
        
                    result.put(value.getName(), value.getCount());
                }
    
                // 根据value排序, 若无需排序则可删除此段
                return result.entrySet().stream()
                        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
            } catch (SolrServerException | IOException e) {
        
                e.printStackTrace();
            }
            return result;
        }
    }

spring-data-solr代码

@GetMapping("sellTopFive2")
        public Map<String, Long> sellTopFive2() {
        
            Map<String, Long> result = new HashMap<>();
    
            // 设置分组条件
            Field field = new SimpleField("product_name");
            SimpleFacetQuery query = new SimpleFacetQuery(new SimpleStringCriteria("*:*")).setRows(0);
            FacetOptions facetOptions = new FacetOptions()
                    .addFacetOnField(field)
                    .setFacetLimit(5);
            query.setFacetOptions(facetOptions);
    
            try {
        
                FacetPage<Orders> page = solrTemplate.queryForFacetPage("orders", query, Orders.class);
    
                Page<FacetFieldEntry> pageResult = page.getFacetResultPage("product_name");
                List<FacetFieldEntry> content = pageResult.getContent();
                for (FacetFieldEntry facetFieldEntry : content) {
        
                    result.put(facetFieldEntry.getValue(), facetFieldEntry.getValueCount());
                }
    
                // 根据数量逆序排序
                return result.entrySet().stream()
                        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                        .limit(5)
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
            }catch (Exception e){
        
                e.printStackTrace();
                return result;
            }
        }

![在这里插入图片描述][e7cbfd5c460e4e68b733ba8b5d91310f.png]

*  2、各个标签的订单数

> facet.field支持Nested类型的字段，直接查询即可，这里标签分类没超过10个，就未设置rows了

q=*:*&facet=true&rows=0&facet.field=labels

![在这里插入图片描述][59a205a027a841b9a04a99f9492df180.png]  
SolrJ代码：

@GetMapping("labelCount")
        public Map<String, Long> labelCount(){
        
            Map<String, Long> result = new HashMap<>();
    
            // 设置查询条件
            SolrQuery query = new SolrQuery().setQuery("*:*").setRows(0);
            // 设置分组条件
            query.set(FacetParams.FACET, true)
                    .set(FacetParams.FACET_FIELD, "labels")
                    .set(FacetParams.FACET_LIMIT, 100);
    
            try {
        
                QueryResponse response = solrClient.query("orders",query);
                FacetField facetFields = response.getFacetField("labels");
                for (FacetField.Count value : facetFields.getValues()) {
        
                    result.put(value.getName(), value.getCount());
                }
    
            } catch (SolrServerException | IOException e) {
        
                e.printStackTrace();
            }
            return result;
        }

*  3、统计近一年内每月的畅销商品TOP5

> 思路：我们要统计每月的商品中的TOP5，很明显要根据月份+商品进行分组，这属于嵌套分组，因此要使用到facet.pivot。我们有一个创建日期字段create\_time。实现方式分为如下几种：  
> 1、创建一个冗余一个月份字段month，用于此处的嵌套查询，这种要修改schema\_manage且要重新加载索引，这里solr不支持类似es的动态字段还是不太方便，此方案如果索引数据量较大，重新加载索引影响线上使用，可以考虑直接新建一个核心，待同步完成，直接将查询核心切换到新的核心，然后删除旧核心  
> 2、先按照年月份进行时间分组，然后客户端代码中循环对有值的年份月最为query条件，分别按商品进行分组，得到每个年月的商品分组详情，这种方式的弊端是网络IO较多，如果查询对耗时有较高要求可能不能满足  
> 3、如果数据本身是按照天汇总的，及create\_time格式是YYYY-MM-dd，没有到秒，或者一天的数据量并不大，那么可以先按照facet.pivot=create\_time,product\_name的形式按天把数据汇总出来，然后在java代码把数据再按月份进行二次计算得出，适用于本身按天数据量不大的场景，近一年的话按天分桶也就365个，相对还能接受  
> 4、最友好的方式，就是能有将日期转换为月份的函数，类似month(create\_time)，然后facet.pivot=month(create\_time),product\_name来实现统计，但目前我还没有找到相关函数，solr本身好像也不支持这种操作，对于聚合上的支持还是和es有比较大的差距，如果后续大家有更好的方式可以留言告知，互相学习

这里因为我的数据量并不大，就直接采用方式3来实现了

q=*:*&facet=true&rows=0&facet.pivot=create_time,product_name&facet.sort=index

SolrJ客户端代码：

@GetMapping("productTopFiveMonthlyNearYear")
        public Map<String, Map<String, Integer>> productTopFiveMonthlyNearYear(){
        
            Map<String, Map<String, Integer>> result = new TreeMap<>();
    
            // 设置查询条件
            SolrQuery query = new SolrQuery().setQuery("*:*").setRows(0);
            // 设置分组条件
            query.set(FacetParams.FACET, true)
                    .set(FacetParams.FACET_PIVOT, "create_time,product_name")
                    .set(FacetParams.FACET_SORT, FacetParams.FACET_SORT_INDEX);
    
            try {
        
                QueryResponse response = solrClient.query("orders",query);
    
                List<PivotField> pivotFields = response.getFacetPivot().get("create_time,product_name");
    
                // 组装返回结果，按年月分组
                for (PivotField field : pivotFields) {
        
                    SimpleDateFormat format = new SimpleDateFormat("yyyyMM");
                    String month = format.format(field.getValue());
                    if(!result.containsKey(month)){
        
                        Map<String, Integer> monthMap = new LinkedHashMap<>();
                        for (PivotField pivotField : field.getPivot()) {
        
                            monthMap.put(pivotField.getValue().toString(), pivotField.getCount());
                        }
                        result.put(month, monthMap);
                    }else{
        
                        Map<String, Integer> monthMap = result.get(month);
                        for (PivotField pivotField : field.getPivot()) {
        
                            String productName = pivotField.getValue().toString();
                            if(!monthMap.containsKey(productName)){
        
                                monthMap.put(productName, pivotField.getCount());
                            }else{
        
                                // 重复的商品 叠加销量
                                monthMap.put(productName,monthMap.get(productName) + pivotField.getCount());
    
                            }
                        }
                    }
                }
                // 每月商品截取前5
                for (String month : result.keySet()) {
        
                    Map<String, Integer> sortMap = result.get(month).entrySet().stream()
                            .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                            .limit(5)
                            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
                    result.put(month, sortMap);
                }
            } catch (SolrServerException | IOException e) {
        
                e.printStackTrace();
            }
            return result;
        }

![\#\#\# 1.3.3 案例!\[][1.3.3]

### 1.3 拓展：stats 查询 ###

当需要统计某字段的平均、最大、最小等统计值时，可以结合stats来查询，具体用法可查看官网文档

官网文档：[https://solr.apache.org/guide/8\_2/the-stats-component.html][https_solr.apache.org_guide_8_2_the-stats-component.html]

![在这里插入图片描述][8600f61542ff46478de5c42b29954f82.png]

## 2. 总结 ##

如上，我们对于solr实现分组聚合查询的讲解就到此结束了，可以看出group适合与简单的分组查询，而facet则更加适合场景复杂的分组查询。具体选型还要根据大家的业务场景而定

[solr]: https://wu55555.blog.csdn.net/article/details/131141526
[https_solr.apache.org_guide_8_2_result-grouping.html]: https://solr.apache.org/guide/8_2/result-grouping.html
[eea3a4b08e004f42b321b4bf876ef7d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/bbeede08a80c4074b8c55588a9233cb4.png
[e7304f2724294576a6e687c6c6d30fe4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/5816d47c54dc4938b5baa6a0e75cf8f0.png
[6a785ef545ec4d9ab9ef1d35135eb60f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/ce9b4b551ddb4403851e3c9ad7d3f721.png
[dcad145abc524b7aa05f9203903b17c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/e0fc0a23ec9c4a15b314c6ae3304fe74.png
[b288d8b3f5654ccaa5da334a80af80c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/0b108c7eda5b40aca384c8f9537d0129.png
[5c069e4a87254b0f91b47480f6942ae2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/5248852740f64458950e6ce3fc14266e.png
[dd8d788bb63a4fc992798b1e559d5f1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f4f0ce1b8df740c9b0b18c44e43b42c7.png
[729edbd376be42cb96fe99e532402aa8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/05411ddf95d945009aaf6dc1df142f2f.png
[bee6f3d5cb48422bbe037c595b6cc3ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/067a23eccf7f4cae8b54f3959417e388.png
[aa160087102a4e27b020546c71c9b1bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/98f63485612141fca5cbea8ab8d57cfa.png
[040b41c9007e4917a12428141867a239.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/1bd30f8b0c3041529539415fcb01e5a5.png
[0dd600c83e084f0e9762ca7c1b58b9d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/2964fc204cf646d583a1d06eeebd64a9.png
[0f5fe23f5f2c435581d3eba5c190e2e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b74eef2d9b314525a3eb2760c14e5a33.png
[44360ba376f84c15b52e3c0a8f1d40e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/e48e22488b0c49bda8e5c914ad43dad4.png
[https_solr.apache.org_guide_8_2_faceting.html]: https://solr.apache.org/guide/8_2/faceting.html
[b1225dbfae274fe3939022c1fc6594dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b5719c1302a248c9958ccd41a83eaa71.png
[826f7e9b19714b9f8d28f35b31e6233c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/554fac4b940d4ca68f3563717bc457c4.png
[f0a7364c008642f3bf44858e44679f75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/32ed7d99d3e5477c937881622202e3d5.png
[b1d2bcc61a9a4cd58a5a470f07485de1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/af664c6022dc44c2bcea22131df14288.png
[6dd386764a264b2ea800102671d3617d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/4a1e22940ca148d49f433a7ba6840393.png
[a8f76e84a7fe4406b6511a5703a38980.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/255705e1beab424bac9bc19251f5b490.png
[5941e7887c804926b74b159be86d148b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/9cedc7fcc2cd4b2d9169877cdbf057c9.png
[e00fc303af584e329f8bf6ff8f58aa13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/321dedc2d4d741ea9d885347bbd1bf5a.png
[b8464c41e2b14056b450fc9b3b38ef85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/2521f5779bce48b08391b9c79f568a72.png
[499a901aba164c2d98de17bcbce48a40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c0c97f58602e4b0882c2653eba4bdad6.png
[337b6654106242a194ad5b4feeaa5682.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/371a96523d7e46818df2da289db7b2d3.png
[de1ca5c7b5834f989bed931b47325f90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/12ddcd5d44304ee492fb10b40ffbdeda.png
[0e5a9ed625c84461bd1d8758f5227ba0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/52fa36ad90e4493b8e6441a54321846e.png
[00a981f2ea7644eb9cd08112e44a1a2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/a9e807c8a34e4ff7ac4cc70ede5f09c6.png
[e7cbfd5c460e4e68b733ba8b5d91310f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/dcded9803f184d689108304b51a42859.png
[59a205a027a841b9a04a99f9492df180.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/c05251a591024cf5a896a5c5d8525054.png
[1.3.3]: https://img-blog.csdnimg.cn/5d7413e2da9f4624ba68632e722d1eaa.png
[https_solr.apache.org_guide_8_2_the-stats-component.html]: https://solr.apache.org/guide/8_2/the-stats-component.html
[8600f61542ff46478de5c42b29954f82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/8a39214843a54ac68b013e9ceb761b02.png