Elasticsearch学习4《Elasticsearch的各种查询》

「爱情、让人受尽委屈。」 2022-11-07 05:56 205阅读 0赞

### 文章目录 ###

*  一、term 和terms 查询
 *   *  1、term 查询
     *  2、terms查询
 *  二、 match查询
 *   *  1、math\_all
     *  2、match 查询
     *  3、布尔match 查询
     *  4、multi\_match
 *  三、其他查询
 *   *  1、id 查询
     *  2、ids查询
     *  3、prefix 查询
     *  4、 fuzzy 查询
     *  5、wildcard 查询
     *  6、rang 查询
     *  8、 regexp 查询
 *  四、深分页 scroll
 *  五、delete-by-query
 *  六、复合查询
 *   *  boosting 查询
 *  七、filter 查询
 *  八、高亮查询
 *  九、聚合查询
 *   *  1、去重计数聚合查询
     *  2、范围统计
     *  3、统计聚合
     *  4、其他聚合查询 查看官方文档
 *  十、 地图经纬度搜索
 *   *  1、ES 的地图检索方式
     *  2、基于RESTFul 实现地图检索
     *  3、 java 实现 geo\_polygon

# 一、term 和terms 查询 #

## 1、term 查询 ##

term 查询是代表完全匹配，搜索之前不会对你搜索的关键字进行分词，直接拿 关键字 去文档分词库中匹配内容

#term查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      #limit ?
      "from": 0,  
      #limit x,?
      "size":5,
      "query": { 
        "term": { 
          "province": { 
            "value": "北京"
          }
        }
      }
    }

public class TermSearch { 
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void termSearchTest() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.from(0);
            builder.size(5);
            builder.query(QueryBuilders.termQuery("province","北京"));
    
            request.source(builder);
    
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                System.out.println(sourceAsMap);
    
            }
        }
    }

## 2、terms查询 ##

*  terms 和 term 查询的机制一样，搜索之前不会对你搜索的关键字进行分词，直接拿 关键字 去文档分词库中匹配内容
 *  terms: 是针对一个字段包含多个值
 *  term : where province = 北京
 *  terms: where province = 北京 or province =? (类似于mysql 中的 in)  
    也可针对 text, 只是在分词库中查询的时候不会进行分词

#terms 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "terms": { 
          "province": [
            "北京",
            "晋城"
          ]
        }
      }
    }

public class TermSearch { 
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void termsSearchTest() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            // 2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.query(QueryBuilders.termsQuery("province","北京","晋城"));
            request.source(builder);
    
            // 3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }
    }

# 二、 match查询 #

match 查询属于高级查询，会根据你查询字段的类型不一样，采用不同的查询方式

*  查询的是日期或者数值，他会将你基于字符串的查询内容转换为日期或数值对待
 *  如果查询的内容是一个不能被分词的内容（keyword）,match 不会将你指定的关键字进行分词
 *  如果查询的内容是一个可以被分词的内容（text）,match 查询会将你指定的内容根据一定的方式进行分词，去分词库中匹配指定的内容

match 查询，实际底层就是多个term 查询，将多个term查询的结果给你封装到一起

## 1、math\_all ##

查询全部内容，不指定查询条件

#match_all 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query":{ 
        "match_all": { }
      }
    }

public class MatchSearch { 
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void matchAllSearch() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.query(QueryBuilders.matchAllQuery());
             //  ES 默认只查询10条数据
            builder.size(20);
            request.source(builder);
    
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
            System.out.println(response.getHits().getHits().length);
        }
    }

## 2、match 查询 ##

指定一个field 作为查询条件

#match 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "match": { 
          "smsContent": "伟大战士"
        }
      }
    }

public class MatchSearch { 
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void matchSearch() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------------------
            builder.query(QueryBuilders.matchQuery("smsContent","伟大战士"));
            //--------------------------------------------------------------
            builder.size(20);
            request.source(builder);
    
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
            System.out.println(response.getHits().getHits().length);
        }
    
    }

## 3、布尔match 查询 ##

基于一个field 匹配的内容，按照 and 或者or的方式连接

#布尔match查询 
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "match": { 
          "smsContent": { 
             # 既包含 战士 也包含 团队
            "query": "战士 团队",
            "operator": "and"
          }
        }
      }
    }
    
    #布尔match查询 
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "match": { 
          "smsContent": { 
             # 既包含 战士 或者 团队
            "query": "战士 团队",
            "operator": "or"
          }
        }
      }
    }

@Test
        public void booleanMatchSearch() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------------------
            builder.query(QueryBuilders.matchQuery("smsContent","战士 团队").operator(Operator.AND));
            //--------------------------------------------------------------
            builder.size(20);
            request.source(builder);
    
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
            System.out.println(response.getHits().getHits().length);
        }

## 4、multi\_match ##

match 针对一个field 做检索，multi\_math 针对多个field 进行检索，多个field对应一个文本。

#multi_math 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query":{ 
        "multi_match": { 
          "query": "北京",
          "fields": ["province","smsContent"]
        }
      }
    }

public void multiMatchSearch() throws IOException { 
            // 1.创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  2.创建查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------------------
            builder.query(QueryBuilders.multiMatchQuery("北京","province","smsContent"));
            //--------------------------------------------------------------
            builder.size(20);
            request.source(builder);
    
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出查询结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
            System.out.println(response.getHits().getHits().length);
        }

# 三、其他查询 #

## 1、id 查询 ##

#id 查询
    GET /sms-logs-index/sms-logs-type/1

public class IdGetSearch { 
    
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void findById() throws IOException { 
            // 创建GetRequest对象
            GetRequest request = new GetRequest(index,type,"1");
    
            //  执行查询
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
    
            // 输出结果
            System.out.println(response.getSourceAsMap());
        }
    }

## 2、ids查询 ##

根据多个id 查询,类似 mysql 中的 where in (id1,id2…)

#ids 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "ids": { 
          "values": ["1","2","3"]
        }
      }
    }

public  void findByIds() throws IOException { 
            //  创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------
            builder.query(QueryBuilders.idsQuery().addIds("1","2","3"));
            //------------------------------------------------------
            request.source(builder);
    
            // 执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

## 3、prefix 查询 ##

前缀查询，可以通过一个关键字去指定一个field 的前缀，从而查询到指定文档

#prefix 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "prefix": { 
          "corpName": { 
            "value": "海"
          }
        }
      }
    }

#match 查询 在这里是什么都查不到的 和上边的prefix 做比较
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "match": { 
          "corpName": "海"
        }
      }
    }

public  void findByPrefix() throws IOException { 
            //  创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------
            builder.query(QueryBuilders.prefixQuery("corpName","阿"));
            //------------------------------------------------------
            request.source(builder);
    
            // 执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

## 4、 fuzzy 查询 ##

模糊查询，我们可以输入一个字符的大概，ES 可以根据输入的大概去匹配内容。查询结果不稳定

#fuzzy 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "fuzzy": { 
          "corpName": { 
            "value": "腾讯客堂",
              #指定前边几个字符是不允许出现错误的
            "prefix_length": 2
          }
        }
      }
    }

public  void findByFuzzy() throws IOException { 
            //  创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------
            builder.query(QueryBuilders.fuzzyQuery("corpName","腾讯客堂").prefixLength(2));
            //------------------------------------------------------
            request.source(builder);
    
            // 执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
        	}
        }

## 5、wildcard 查询 ##

通配查询，同mysql中的like 是一样的，可以在查询时，在字符串中指定通配符\*和占位符？

#wildcard 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "wildcard": { 
          "corpName": { 
            "value": "海尔*"
          }
        }
      }
    }
    
    #wildcard 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "wildcard": { 
          "corpName": { 
            "value": "海尔??"
          }
        }
      }
    }

public  void findByWildCard() throws IOException { 
            //  创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------
            builder.query(QueryBuilders.wildcardQuery("corpName","海尔*"));
            //------------------------------------------------------
            request.source(builder);
    
            // 执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

## 6、rang 查询 ##

范围查询，只针对数值类型，对一个field 进行大于或者小于的范围指定

#rang 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "range": { 
          "fee": { 
            "gte": 10,
            "lte": 20
          }
        }
      }
    }

public  void findByRang() throws IOException { 
            //  创建request对象
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            //  指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //--------------------------------------------------
            builder.query(QueryBuilders.rangeQuery("fee").gt(10).lte(30));
            //------------------------------------------------------
            request.source(builder);
    
            // 执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

## 8、 regexp 查询 ##

正则查询，通过你编写的正则表达式去匹配内容  
Ps:prefix wildcard fuzzy 和regexp 查询效率比较低 ,在要求效率比较高时，避免使用

#regexp 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "regexp": { 
          "mobile": "138[0-9]{8}"
        }
      }
    }

public  void findByRegexp() throws IOException { 
        //  创建request对象
        SearchRequest request = new SearchRequest(index);
        request.types(type);
    
        //  指定查询条件
        SearchSourceBuilder builder = new SearchSourceBuilder();
        //--------------------------------------------------
        builder.query(QueryBuilders.regexpQuery("mobile","138[0-9]{8}"));
        //------------------------------------------------------
        request.source(builder);
    
        // 执行
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
        // 输出结果
        for (SearchHit hit : response.getHits().getHits()) { 
            System.out.println(hit.getSourceAsMap());
        }
    }

# 四、深分页 scroll #

ES 对from +size时又限制的，from +size 之和 不能大于1W,超过后 效率会十分低下  
原理：  
from+size ES查询数据的方式，  
第一步将用户指定的关键词进行分词，  
第二部将词汇去分词库中进行检索，得到多个文档id,  
第三步去各个分片中拉去数据， 耗时相对较长  
第四步根据score 将数据进行排序， 耗时相对较长  
第五步根据from 和size 的值 将部分数据舍弃，  
第六步，返回结果。

scroll +size ES 查询数据的方式  
第一步将用户指定的关键词进行分词，  
第二部将词汇去分词库中进行检索，得到多个文档id,  
第三步，将文档的id放在一个上下文中  
第四步，根据指定的size去ES中检索指定个数数据，拿完数据的文档id,会从上下文中移除  
第五步，如果需要下一页的数据，直接去ES的上下文中找后续内容。  
第六步，循环第四步和第五步  
scroll 不适合做实时查询。

#scroll 查询,返回第一页数据，并将文档id信息存放在ES上下文中，并指定生存时间
    POST /sms-logs-index/sms-logs-type/_search?scroll=1m
    { 
      "query": { 
        "match_all": { }
      },
      "size": 2,
      "sort": [
        { 
          "fee": { 
            "order": "desc"
          }
        }
      ]
    }
    
    
    #根据scroll 查询下一页数据
    POST _search/scroll
    { 
      "scroll_id":"DnF1ZXJ5VGhlbkZldGNoAwAAAAAAABbqFk04VlZ1cjlUU2t1eHpsQWNRY1YwWWcAAAAAAAAW7BZNOFZWdXI5VFNrdXh6bEFjUWNWMFlnAAAAAAAAFusWTThWVnVyOVRTa3V4emxBY1FjVjBZZw==",
      "scroll":"1m"
    }
    
    #删除scroll上下文中的数据
    DELETE _search/scroll/DnF1ZXJ5VGhlbkZldGNoAwAAAAAAABchFk04VlZ1cjlUU2t1eHpsQWNRY1YwWWcAAAAAAAAXIBZNOFZWdXI5VFNrdXh6bEFjUWNWMFlnAAAAAAAAFx8WTThWVnVyOVRTa3V4emxBY1FjVjBZZw==

public class ScrollSearch { 
        ObjectMapper mapper = new ObjectMapper();
        RestHighLevelClient client =  EsClient.getClient();
        String index = "sms-logs-index";
        String type="sms-logs-type";
    
        @Test
        public void scrollSearch() throws IOException { 
    
            // 1.创建request
            SearchRequest searchRequest = new SearchRequest(index);
            searchRequest.types(type);
    
            //  2.指定scroll信息,过期时间
            searchRequest.scroll(TimeValue.timeValueMinutes(1L));
    
            //  3.指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.size(4);
            builder.sort("fee", SortOrder.DESC);
            searchRequest.source(builder);
            // 4.获取返回结果scrollId,获取source
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            String scrollId = response.getScrollId();
            System.out.println("-------------首页数据---------------------");
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
    
            while (true){ 
                // 5.创建scroll request
    
                SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
    
                // 6.指定scroll 有效时间
                scrollRequest.scroll(TimeValue.timeValueMinutes(1L));
    
                // 7.执行查询，返回查询结果
                SearchResponse scroll = client.scroll(scrollRequest, RequestOptions.DEFAULT);
    
                // 8.判断是否查询到数据，查询到输出
                SearchHit[] searchHits =  scroll.getHits().getHits();
                if(searchHits!=null && searchHits.length >0){ 
                    System.out.println("-------------下一页数据---------------------");
                    for (SearchHit hit : searchHits) { 
                        System.out.println(hit.getSourceAsMap());
                    }
                }else{ 
                    //  9.没有数据，结束
                    System.out.println("-------------结束---------------------");
                    break;
                }
            }
    
            // 10.创建 clearScrollRequest
            ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
    
            // 11.指定scrollId
            clearScrollRequest.addScrollId(scrollId);
    
            //12.删除scroll
            ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
    
            // 13.输出结果
            System.out.println("删除scroll:"+clearScrollResponse.isSucceeded());
    
        }
    }

# 五、delete-by-query #

根据term,match 等查询方式去删除大量索引  
PS:如果你要删除的内容，时index下的大部分数据，推荐创建一个新的index,然后把保留的文档内容，添加到全新的索引

#Delet-by-query 删除
    POST /sms-logs-index/sms-logs-type/_delete_by_query
    { 
       "query": { 
        "range": { 
          "fee": { 
            "lt": 20
          }
        }
      }
    }

public void deleteByQuery() throws IOException { 
            // 1.创建DeleteByQueryRequest
            DeleteByQueryRequest request = new DeleteByQueryRequest(index);
            request.types(type);
    
            // 2.指定条件
            request.setQuery(QueryBuilders.rangeQuery("fee").lt(20));
    
            // 3.执行
            BulkByScrollResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
    
            // 4.输出返回结果
            System.out.println(response.toString());
        }

# 六、复合查询 #

复合过滤器，将你的多个查询条件 以一定的逻辑组合在一起，

must:所有条件组合在一起，表示 and 的意思  
must\_not: 将must\_not中的条件，全部都不匹配，表示not的意思  
should:所有条件用should 组合在一起，表示or 的意思

#省是 晋城 或者北京
    # 运营商不能是联通
    #smsContent 包含 战士 和的
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "bool": { 
          "should": [
            { 
              "term": { 
                "province": { 
                  "value": "晋城"
                }
              }
              
            },
             { 
              "term": { 
                "province": { 
                  "value": "北京"
                }
              }
              
            }
          ],
          "must_not": [
            { 
              "term": { 
                "operatorId": { 
                  "value": "2"
                }
              }
            }
          ],
          "must": [
            { 
              "match": { 
                "smsContent": "战士"
              }
            },
            { 
              "match": { 
                "smsContent": "的"
              }
            }
          ]
        }
      }
    }

public void  boolSearch() throws IOException { 
    
            //  1.创建 searchRequest
            SearchRequest request = new SearchRequest(index);
            request.types(type);
            // 2.指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
            // #省是 晋城 或者北京
            boolQueryBuilder.should(QueryBuilders.termQuery("province","北京"));
            boolQueryBuilder.should(QueryBuilders.termQuery("province","晋城"));
    
            //# 运营商不能是联通
            boolQueryBuilder.mustNot(QueryBuilders.termQuery("operatorId",2));
    
            //#smsContent 包含 战士 和的
            boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent","战士"));
            boolQueryBuilder.must(QueryBuilders.matchQuery("smsContent","的"));
    
            builder.query(boolQueryBuilder);
            request.source(builder);
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

## boosting 查询 ##

boosting 查询可以帮助我们去影响查询后的score

*  positive:只有匹配上positive 查询的内容，才会被放到返回的结果集中
 *  negative: 如果匹配上了positive 也匹配上了negative, 就可以 降低这样的文档score.
 *  negative\_boost:指定系数,必须小于1 0.5

关于查询时，分数时如何计算的：

*  搜索的关键字再文档中出现的频次越高，分数越高
 *  指定的文档内容越短，分数越高。
 *  我们再搜索时，指定的关键字也会被分词，这个被分词的内容，被分词库匹配的个数越多，分数就越高。

#boosting 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "boosting": { 
          "positive": { 
            "match": { 
              "smsContent": "战士"
            }
          }, 
          "negative": { 
            "match": { 
              "smsContent": "团队"
            }
          },
          "negative_boost": 0.2
        }
      }
    }

public void  boostSearch() throws IOException { 
    
            //  1.创建 searchRequest
            SearchRequest request = new SearchRequest(index);
            request.types(type);
            // 2.指定查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            BoostingQueryBuilder boost = QueryBuilders.boostingQuery(
                    QueryBuilders.matchQuery("smsContent", "战士"),
                    QueryBuilders.matchQuery("smsContent", "团队")
            ).negativeBoost(0.2f);
            builder.query(boost);
            request.source(builder);
            //  3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
            }
        }

# 七、filter 查询 #

query 查询：根据你的查询条件，去计算文档的匹配度得到一个分数，并根据分数排序，不会做缓存的。

filter 查询：根据查询条件去查询文档，不去计算分数，而且filter会对经常被过滤的数据进行缓存。

#filter 查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "bool": { 
          "filter": [
            { 
              "term": { 
                "corpName": "海尔智家公司"
               }
            },
            { 
              "range":{ 
                "fee":{ 
                  "lte":50
                }
              }
            }
          ]
        }
      }
    }

public void filter() throws IOException { 
    
            // 1.searchRequest
            SearchRequest searchRequest = new SearchRequest(index);
            searchRequest.types(type);
    
            // 2.指定查询条件
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();
            boolBuilder.filter(QueryBuilders.termQuery("corpName","海尔智家公司"));
            boolBuilder.filter(QueryBuilders.rangeQuery("fee").gt(20));
            sourceBuilder.query(boolBuilder);
            searchRequest.source(sourceBuilder);
    
            //  3.执行
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            
            //  4. 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getSourceAsMap());
                System.out.println(hit.getId()+"的分数是："+hit.getScore());
            }
        }

# 八、高亮查询 #

高亮查询就是用户输入的关键字，以一定特殊样式展示给用户，让用户知道为什么这个结果被检索出来  
高亮展示的数据，本身就是文档中的一个field,单独将field以highlight的形式返回给用户

ES提供了一个highlight 属性，他和query 同级别。

*  frament\_size: 指定高亮数据展示多少个字符回来
 *  pre\_tags:指定前缀标签
 *  post\_tags:指定后缀标签

#highlight 高亮查询
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "query": { 
        "match": { 
          "smsContent": "团队"
        }
      },
      "highlight": { 
        "fields": { 
          "smsContent":{ }
        },
        "pre_tags":"<font color='red'>",
        "post_tags":"</font>",
        "fragment_size":10
      }
    }

public void highLightQuery() throws IOException { 
          // 1.创建request
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
          // 2.指定查询条件，指定高亮
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.query(QueryBuilders.matchQuery("smsContent","团队"));
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("smsContent",10)
                    .preTags("<font colr='red'>")
                    .postTags("</font>");
            builder.highlighter(highlightBuilder);
            request.source(builder);
    
          // 3.执行
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            //4. 输出结果
            for (SearchHit hit : response.getHits().getHits()) { 
                System.out.println(hit.getHighlightFields().get("smsContent"));
            }
        }

# 九、聚合查询 #

ES的聚合查询和mysql 的聚合查询类似，ES的聚合查询相比mysql 要强大得多。ES提供的统计数据的方式多种多样。

#ES 聚合查询的RSTFul 语法
    POST /index/type/_search
    { 
        "aggs":{ 
            "(名字)agg":{ 
                "agg_type":{ 
                    "属性"："值"
                }
            }
        }
    }

## 1、去重计数聚合查询 ##

去重计数，cardinality 先将返回的文档中的一个指定的field进行去重，统计一共有多少条

# 去重计数 查询 province
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "aggs": { 
        "provinceAgg": { 
          "cardinality": { 
            "field": "province"
          }
        }
      }
    }

public void aggCardinalityC() throws IOException { 
    
            // 1.创建request
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            // 2. 指定使用聚合查询方式
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.aggregation(AggregationBuilders.cardinality("provinceAgg").field("province"));
            request.source(builder);
    
            // 3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 4.输出返回结果
            Cardinality agg = response.getAggregations().get("provinceAgg");
            System.out.println(agg.getValue());
        }

## 2、范围统计 ##

统计一定范围内出现的文档个数，比如，针对某一个field 的值再0100,100200,200~300 之间文档出现的个数分别是多少  
范围统计 可以针对 普通的数值，针对时间类型，针对ip类型都可以响应。  
数值 rang  
时间 date\_rang  
ip ip\_rang

#针对数值方式的范围统计 from 带等于效果 ，to 不带等于效果
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "aggs": { 
        "agg": { 
          "range": { 
            "field": "fee",
            "ranges": [
              { 
                "to": 30
              },
               { 
                "from": 30,
                "to": 60
              },
              { 
                "from": 60
              }
            ]
          }
        }
      }
    }
    #时间方式统计
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "aggs": { 
        "agg": { 
          "date_range": { 
            "field": "sendDate",
            "format": "yyyy", 
            "ranges": [
              { 
                "to": "2000"
              },{ 
                "from": "2000"
              }
            ]
          }
        }
      }
    }
    #ip 方式 范围统计
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "aggs": { 
        "agg": { 
          "ip_range": { 
            "field": "ipAddr",
            "ranges": [
              { 
                "to": "127.0.0.8"
              },
              { 
                "from": "127.0.0.8"
              }
            ]
          }
        }
      }
    }

public void aggRang() throws IOException { 
            // 1.创建request
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            // 2. 指定使用聚合查询方式
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.aggregation(AggregationBuilders.range("agg").field("fee")
                                .addUnboundedTo(30)
                                .addRange(30,60)
                                .addUnboundedFrom(60));
            request.source(builder);
    
            // 3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 4.输出返回结果
            Range agg = response.getAggregations().get("agg");
            for (Range.Bucket bucket : agg.getBuckets()) { 
                String key = bucket.getKeyAsString();
                Object from = bucket.getFrom();
                Object to = bucket.getTo();
                long docCount = bucket.getDocCount();
                System.out.println(String.format("key: %s ,from: %s ,to: %s ,docCount: %s",key,from,to,docCount));
            }
        }

## 3、统计聚合 ##

他可以帮你查询指定field 的最大值，最小值，平均值，平方和…  
使用 extended\_stats

#统计聚合查询 extended_stats
    POST /sms-logs-index/sms-logs-type/_search
    { 
      "aggs": { 
        "agg": { 
          "extended_stats": { 
            "field": "fee"
          }
        }
      }
    }

// java实现   
    public void aggExtendedStats() throws IOException { 
            // 1.创建request
            SearchRequest request = new SearchRequest(index);
            request.types(type);
    
            // 2. 指定使用聚合查询方式
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.aggregation(AggregationBuilders.extendedStats("agg").field("fee"));
            request.source(builder);
    
            // 3.执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
            // 4.输出返回结果
           ExtendedStats extendedStats =  response.getAggregations().get("agg");
            System.out.println("最大值："+extendedStats.getMaxAsString()+",最小值："+extendedStats.getMinAsString());
        }

## 4、其他聚合查询 查看官方文档 ##

[https://www.elastic.co/guide/en/elasticsearch/reference/6.8/search-aggregations-metrics-weight-avg-aggregation.html][https_www.elastic.co_guide_en_elasticsearch_reference_6.8_search-aggregations-metrics-weight-avg-aggregation.html]

# 十、 地图经纬度搜索 #

#创建一个经纬度索引,指定一个 name ,一个location
    PUT /map
    { 
      "settings": { 
        "number_of_shards": 5,
        "number_of_replicas": 1
      },
      "mappings": { 
        "map":{ 
          "properties":{ 
            "name":{ 
              "type":"text"
            },
            "location":{ 
              "type":"geo_point"
            }
          }
        }
      }
    }
    
    #添加测试数据
    PUT /map/map/1
    { 
      "name":"天安门",
      "location":{ 
        "lon": 116.403694,
        "lat":39.914492
      }
    }
    
    PUT /map/map/2
    { 
      "name":"百望山",
      "location":{ 
        "lon": 116.26284,
        "lat":40.036576
      }
    }
    
    PUT /map/map/3
    { 
      "name":"北京动物园",
      "location":{ 
        "lon": 116.347352,
        "lat":39.947468
      }
    }

## 1、ES 的地图检索方式 ##

geo\_distance :直线距离检索方式  
geo\_bounding\_box: 以2个点确定一个矩形，获取再矩形内的数据  
geo\_polygon:以多个点，确定一个多边形，获取多边形的全部数据

## 2、基于RESTFul 实现地图检索 ##

geo\_distance

#geo_distance 
    POST /map/map/_search
    { 
      "query": { 
        "geo_distance":{ 
            #确定一个点
          "location":{ 
            "lon":116.434739,
            "lat":39.909843
          },
          #确定半径
          "distance":20000,
          #指定形状为圆形
          "distance_type":"arc"
        }
      }
    }

#geo_bounding_box
    POST /map/map/_search
    { 
      "query":{ 
        "geo_bounding_box":{ 
          "location":{ 
            "top_left":{ 
              "lon":116.327805,
              "lat":39.95499
            },
            "bottom_right":{ 
              "lon": 116.363162,
              "lat":39.938395
            }
          }
        }
      }
    }

#geo_polygon
    POST /map/map/_search
    { 
      "query":{ 
        "geo_polygon":{ 
          "location":{ 
              # 指定多个点确定 位置
           "points":[
             { 
               "lon":116.220296,
               "lat":40.075013
             },
              { 
               "lon":116.346777,
               "lat":40.044751
             },
             { 
               "lon":116.236106,
               "lat":39.981533
             } 
            ]
          }
        }
      }
    }

## 3、 java 实现 geo\_polygon ##

public class GeoDemo { 
        RestHighLevelClient client =  EsClient.getClient();
        String index = "map";
        String type="map";
    
        @Test
        public void  GeoPolygon() throws IOException { 
                //  1.创建searchRequest
                SearchRequest request  = new SearchRequest(index);
                request.types(type);
    
                //  2.指定 检索方式
    
                SearchSourceBuilder builder =  new SearchSourceBuilder();
                List<GeoPoint> points = new ArrayList<>();
                points.add(new GeoPoint(40.075013,116.220296));
                points.add(new GeoPoint(40.044751,116.346777));
                points.add(new GeoPoint(39.981533,116.236106));
                builder.query(QueryBuilders.geoPolygonQuery("location",points));
                request.source(builder);
                // 3.执行
                SearchResponse response = client.search(request, RequestOptions.DEFAULT);
                // 4.输出结果
                for (SearchHit hit : response.getHits().getHits()) { 
                    System.out.println(hit.getSourceAsMap());
                }
        }
    }

参考：https://github.com/changxuepeng/ElasticsearchStudy/blob/master/ES%E7%AC%94%E8%AE%B0/ES%E7%AC%94%E8%AE%B0.md

[https_www.elastic.co_guide_en_elasticsearch_reference_6.8_search-aggregations-metrics-weight-avg-aggregation.html]: https://www.elastic.co/guide/en/elasticsearch/reference/6.8/search-aggregations-metrics-weight-avg-aggregation.html