df：默认字段，不指定时会对所有字段进行查询
sort：根据字段名排序
from：返回的索引匹配结果的开始值，默认为 0
size：搜索结果返回的条数，默认为 10
timeout：超时的时间设置
fields：只返回索引中指定的列，多个列中间用逗号分开
analyzer：当分析查询字符串的时候使用的分词器
analyze_wildcard：通配符或者前缀查询是否被分析，默认为 false
explain：在每个返回结果中，将包含评分机制的解释
_source：是否包含元数据，同时支持 _source_includes 和 _source_excludes
lenient：若设置为 true，字段类型转换失败的时候将被忽略，默认为 false
default_operator：默认多个条件的关系，AND 或者 OR，默认为 OR
search_type：搜索的类型，可以为 dfs_query_then_fetch 或 query_then_fetch，默认为 query_then_fetch

指定字段查询

这个例子就是指定字段查询，以下的两条语句都可以达到指定字段查询的目的。

GET /user/_search?q=22&df=age

GET /user/_search?q=age:22

他们的含义是，通过get方式查询user索引中的age字段为22的所有信息

泛查询

GET /user/_search?q=22

这个就是泛查询，会对所有的字段进行查询操作，并返回所有数据

Term Query 和 Phrase Query

比如：

(男士孝子 )等效于男士 OR 孝子；

”男士孝子 “等效于男士 AND 孝子 =》》》》另外还要求前后顺序保存一致。

当为 Term Query 的时候，就需要把这两个词用括号括起来，

请求为 GET /user/_search?q=title:(男士孝子)，意思就是查询 title字段中包括 男士 或者孝子的所有信息。

当为 Phrase Query 的时候就需要用引号包起来，

请求为 GET /user/_search?q=title:"男士孝子"。

布尔，范围查询

布尔

URI Search还支持，比如 AND（&&）、OR（||）、NOT（！），需要注意大写，不能小写。

EG:

GET /user/_search?q=title:(男士 NOT 孝子)

这个请求表示查询 title 中必须包括 男士 不能包括 孝子 的文档。

范围查询

比如指定电影的年份大于 1994：GET /movies/_search?q=year:>=1994。

URI Search 还支持通配符查询（查询效率低，占用内存大，不建议使用，特别是放在最前面），还支持正则表达式，以及模糊匹配和近似查询。

URI Search 好处

操作简单，只要写个 URI 就可以了，方便测试，但是 URI Search 只包含一部分查询语法，不能覆盖所有 ES 支持的查询语法。

Request Body Search

这个比我们的URI Search更牛逼点，但是也更复杂

在 ES 中一些高阶用法只能在 Request Body 里做，所以我们尽量使用 Request Body Search，而且写程序的时候也常用的！！

它支持 GET 和 POST 方式对索引进行查询，需要指定操作的索引名称，

同样也要通过 _search 来标明这个请求为搜索请求，我们可以在请求体中使用 ES 提供的 DSL（领域特定语言），下面这个例子就是简单的 Query DSL：

查询

user中的所有信息

POST /user/_search

  "query": 
    "match_all":

我们可以使用可视化工具执行看看结果，如下

分页

POST /user/_search  "from":10,  "size":20,  "query":    "match_all":

排序

POST /user/_search  "sort":["year":"desc"],  "query":    "match_all":

最好在“数字型”与“日期型”字段上排序，因为对于多值类型或者分析过的字段排序，系统会选一个值，无法得知该值。

desc逆序

返回指定字段

如果 _source 的数据量比较大，有些字段也不需要拿到这个信息，那么就可以对它的 _source 进行过滤，把需要的信息加到 _source 中，比如以下请求就是 _source 中只返回 title：

POST /user/_search  "_source":["title"],  "query":    "match_all":

如果 _source 没有存储，那就只返回匹配的文档的元数据，同时 _source 也支持使用通配符。

脚本字段

脚本字段可以使用 ES 中的 painless 的脚本去算出一个新的字段结果。

GET /movies/_search  "script_fields":     "new_field":       "script":         "lang": "painless",        "source": "doc['year'].value+'_hello'"            ,  "query":     "match_all":

这个例子中就使用 painless 把电影的年份和 _hello 进行拼接形成一个新的字段 new_field

字段类查询

全文匹配：针对 text 类型的字段进行全文检索，会对查询语句先进行分词处理，如 match，match_phrase 等 query 类型
单词匹配：不会对查询语句做分词处理，直接去匹配字段的倒排索引，如 term，terms，range 等 query 类型

可以在 Request Body 中使用在 query match 的方式把信息填在里面，我们先来看下 Match Query，比如下面这个例子，填入两个单词，默认是 wupx or huxy 的查询条件，如果想查询两者同时出现，可以通过加 "operator": "and" 来实现。


POST /users/_search

  "query": 
    "match": 
      "title": "wupx huxy"
      "operator": "and"

首先对查询语句进行分词，分成 wupx 和 huxy 两个 Term，然后 ES 会拿到 username 的倒排索引，对 wupx 和 huxy 去进行匹配的算分，比如 wupx 对应的文档是 1 和 2，huxy 对应的文档为 1，然后 ES 会利用算分算法（比如 TF/IDF 和 BM25，BM25 模型 5.x 之后的默认模型）列出文档跟查询的匹配得分，然后 ES 会对 wupx huxy 的文档的得分结果做一个汇总，最终根据得分排序，返回匹配文档。

Request Body 中还支持 Match Phrase 查询，但在 query 条件中的词必须顺序出现的，可以通过 slop 参数控制单词间的间隔，比如加上 "slop" :1，表示中间可以有一个其他的字符。

POST /movies/_search  "query":     "match_phrase":       "title":        "query": "one love"        "slop":1

了解完 Match Query，让我们再来看下 Term Query：

如果不希望 ES 对输入语句作分词处理的话，可以用 Term Query，将查询语句作为整个单词进行查询，使用方法和 Match 类似，只需要把 match 换为 term 就可以了，如下所示：

POST /users/_search  "query":     "term":         "username":"wupx"

Terms Query 顾名思义就是一次可以传入多个单词进行查询，关键词是 terms，如下所示：

POST /users/_search  "query":     "terms":       "username": [        "wupx",        "huxy"      ]

另外 DSL 还支持特定的 Query String 的查询，比如指定默认查询的字段名 default_field 就和前面介绍的 df 是一样的，在 query 中也可以使用 AND 来实现一个与的操作。

POST users/_search  "query":     "query_string":       "default_field": "username",      "query": "wupx AND huxy"

下面来看下 Simple Query String Query，它其实和 Query String 类似，但是会忽略错误的查询语法，同时只支持部分查询语法，不支持 AND OR NOT，会当作字符串处理，Term 之间默认的关系是 OR，可以指定 default_operator 来实现 AND 或者 OR，支持用 + 替代 AND，用 | 替代 OR，用 - 替代 NOT。

下面这个例子就是查询 username 字段中同时包含 wu 和px 的请求：

  "query":     "simple_query_string":       "query": "wu px",      "fields": ["username"],      "default_operator": "AND"

Response

  "took" : 1,  "timed_out" : false,  "_shards" :     "total" : 1,    "successful" : 1,    "skipped" : 0,    "failed" : 0  ,  "hits" :     "total" :       "value" : 1,      "relation" : "eq"    ,    "max_score" : 0.9808292,    "hits" : [              "_index" : "users",        "_type" : "_doc",        "_id" : "1",        "_score" : 0.9808292,        "_source" :           "username" : "wupx",          "age" : "18"                  ]

其中 took 表示花费的时间；

total 表示符合条件的总文档数；

hits 为结果集，默认是前 10 个文档；

_index 为索引名；

_id 为文档 id；

_score 为相关性评分；

_source 为文档的原始信息。

使用RestHighLevelClient的方式对文档搜索

精确查询

对应的原生查询语句

注意这里的term就是精准查询到关键字

GET user/_search

  "query": 
    "term": 
      "city": "上海"

服务层

    // 文档搜索
    public String searchDocument(String indexName,String city)
        //2 构建搜索请求
        SearchRequest searchRequest = new SearchRequest().indices(indexName);
        //3 构建搜索内容
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("city", city);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(termQueryBuilder);
        //4 填充搜索内容
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try 
            //5 执行搜索操作
            searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
         catch (IOException e) 
            throw new RuntimeException(e);
        
        //6 返回值
        return JSON.toJSONString(searchResponse.getHits().getHits());

控制器


    @GetMapping("/searchUserByCity")
    public String searchUserByCity() throws IOException 
        return service.searchDocument("user","上海");

访问链接localhost:8080/searchUserByCity

分页查询

GET user/_search

  "query": 
    "term": 
      "city": "上海"
    
    
  ,
  "from":0,
  "size":5

服务层

  // 文档搜索--分页查询
    public String searchDocument2(String indexName,String city)
        //2 构建搜索请求
        SearchRequest searchRequest = new SearchRequest().indices(indexName);
        //3 构建搜索内容
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //拿到前5条数据
        searchSourceBuilder
                .query(QueryBuilders.termQuery("city", city))
                .from(0)
                .size(5);

        //4 填充搜索内容
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try 
            //5 执行搜索操作
            searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
         catch (IOException e) 
            throw new RuntimeException(e);
        
        //6 返回值
        return JSON.toJSONString(searchResponse.getHits().getHits());

控制层

    @GetMapping("/searchUserByCity2")
    public String searchUserByCity2() throws IOException 
        return service.searchDocument2("user","上海");

访问localhost:8080/searchUserByCity2

字符匹配AND精准查询

term 与matchphrase的比较 term用于精确查找有点像 mysql里面的"=" match是先将查询关键字分词然后再进行查找。term一般用在keywokrd类型的字段上进行精确查找。

注意这里的bool,表示使用布尔查询，其中的must是相当于SQL语句中的and的意思。

所以就是查找name中包含“妲己”并且年龄为22岁的信息，请注意不能写成"妲",因为我们在新建文档的时候是这样新建的“妲己”，那么我们如果匹配“妲”就会匹配不到，加入这样写就可以匹配到了“妲己”，请注意空格，这是分词的依据之一

ES查询语句。

GET user/_search

  "query": 
    "bool":
      "must": [
        
          "match_phrase": 
            "name": "妲己"
          
        ,
         
          "term": 
            "age": "32"
          
        
      ]
    
    
  ,
  "from":0,
  "size":10

服务层

// 文档分词搜索+精确查询
    public String searchDocument3(String indexName,String name,Integer age)
        //2 构建搜索请求
        SearchRequest searchRequest = new SearchRequest().indices(indexName);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //3 构建复杂的查询语句
        BoolQueryBuilder bq=QueryBuilders
                .boolQuery()
                //分词匹配
                .must(QueryBuilders.matchPhraseQuery("name",name))
                //精确匹配
                .must(QueryBuilders.matchQuery("age",age));
        //4 填充搜索语句
        searchSourceBuilder
                .query(bq)
                .from(0)
                .size(5);

        //4 填充搜索内容
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try 
            //5 执行搜索操作
            searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
         catch (IOException e) 
            throw new RuntimeException(e);
        
        //6 返回值
        return JSON.toJSONString(searchResponse.getHits());

控制层

    @GetMapping("/searchUser3")
    public String searchUser3() throws IOException 
        return service.searchDocument3("user","妲己",32);

字符匹配OR精准查询

原始查询语句

GET user/_search

  "query": 
    "bool":
      "should": [
        
          "match_phrase": 
            "name": "妲己"
          
        ,
         
          "term": 
            "age": "32"
          
        
      ]
    
    
  ,
  "from":0,
  "size":10

服务层

    // 文档分词搜索OR精确查询
    public String searchDocument4(String indexName,String name,Integer age)
        //2 构建搜索请求
        SearchRequest searchRequest = new SearchRequest().indices(indexName);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //3 构建复杂的查询语句
        BoolQueryBuilder bq=QueryBuilders
                .boolQuery()
                //分词匹配
                .should(QueryBuilders.matchPhraseQuery("name",name))
                //精确匹配
                .should(QueryBuilders.matchQuery("age",age));
        //4 填充搜索语句
        searchSourceBuilder
                .query(bq)
                .from(0)
                .size(5);

        //4 填充搜索内容
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try 
            //5 执行搜索操作
            searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
         catch (IOException e) 
            throw new RuntimeException(e);
        
        //6 返回值
        return JSON.toJSONString(searchResponse.getHits());

控制层

    @GetMapping("/searchUser4")
    public String searchUser4() throws IOException 
        return service.searchDocument4("user","妲己",22);

结果

模糊查询

原始语句

GET user/_search

  "query": 
    "wildcard": 
      "city": 
        "value": "上*"

    // 文档模糊查询
    public String searchDocument5(String indexName,String city)
        //2 构建搜索请求
        SearchRequest searchRequest = new SearchRequest().indices(indexName);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //3 构建模糊查询的语句
        WildcardQueryBuilder bq=QueryBuilders
                .wildcardQuery("city",city);
        //4 填充搜索语句
        searchSourceBuilder
                .query(bq);

        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = null;
        try 
            //5 执行搜索操作
            searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
         catch (IOException e) 
            throw new RuntimeException(e);
        
        //6 返回值
        return JSON.toJSONString(searchResponse.getHits());

    @GetMapping("/searchUser5")
    public String searchUser5() throws IOException 
        return service.searchDocument5("user","上*");

结果

OK！下一节我们学习使用ORM框架对ES进行操作，就不用这么麻烦了，哈哈，欢迎订阅我，谢谢谢谢

参考看完这篇还不会 Elasticsearch 搜索,那我就哭了！

ElasticSearch 文档的增删改查都不会？

ElasticSearch的简单增删改查，以及在springboot中如何使用跟项目的结合

Elasticsearch-RestClient基础

参考技术A

tips：Ctrl + F快速定位所需内容阅读吧。

Java REST Client (deprecated) | Elastic
Overview (rest-high-level 7.12.1 API) (elastic.co)

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。

RestClient是提供给Java的客户端。

1、基础准备

创建数据表 tb_hotel ，如下：

插入数据，如下：

elasticsearch相关依赖，如下：

因为SpringBoot默认的ES版本是7.6.2，所以我们需要覆盖默认的ES版本：

其他依赖，如下：

Ⅰ 配置服务端口；
Ⅱ 配置数据源；
Ⅲ 配置日志；
Ⅳ 配置mybatis-plus。

Hotel类

HotelDoc类

geo_point类型属性映射的形式有多种，官方文档见此： Geopoint field type
，常见的形式如下图。此处我们采用第2种形式，做属性映射 "location": "41.12,-71.34" ，所以在类型转换的时候手动拼接了属性值 this.location = hotel.getLatitude() + ", " + hotel.getLongitude(); 。

2、RestClient操作索引库

Ⅰ 编写创建索引库语句：这个步骤可以在自己 Dev Tools 控制台内完成，然后将字段复制到IDEA。

@BeforeEach 内完成client对象的初始化配置， @AfterEach 内完成操作后的资源释放。

不难看出对索引库的操作有一定的相似性：
Ⅰ XXXIndexRequest：Create、Delete、Get的请求request对象；
Ⅱ client.indices().XXX()：create、delete、get方法。

3、RestClient操作文档

添加@SpringBootTest注解，注入hotelService：

不难看出对索引文档的操作也具有一定的相似性：
Ⅰ XXXRequest：Index、Get、Update、Delete、Bulk的请求request对象；
Ⅱ client.XXX()方法：index、get、update、delete、bulk方法。

以上即为RestClient基础的全部内容，感谢阅读。

以上是关于Elasticsearch 学习+SpringBoot实战教程的主要内容，如果未能解决你的问题，请参考以下文章

Spring Boot学习笔记

Spring Boot学习大全（入门）

ElasticSearch-学习笔记04Java客户端操作索引库

Elasticsearch 学习笔记

Elasticsearch 学习+SpringBoot实战教程

Elasticsearch 学习笔记 Elasticsearch及Elasticsearch head安装配置