Elasticsearch（十一）elasticsearch搜索--最基本的工具

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/cc907566076/article/details/78666694

我们已经学会了如何使用 Elasticsearch 作为一个简单的 NoSQL 风格的分布式文档存储系统。我们可以将一个 JSON 文档扔到 Elasticsearch 里，然后根据 ID 检索。但 Elasticsearch 真正强大之处在于可以从无规律的数据中找出有意义的信息——从“大数据”到“大信息”。

Elasticsearch 不只会存储（stores） 文档，为了能被搜索到也会为文档添加索引（indexes） ，这也是为什么我们使用结构化的 JSON 文档，而不是无结构的二进制数据。

文档中的每个字段都将被索引并且可以被查询 。不仅如此，在简单查询时，Elasticsearch 可以使用 所有（all） 这些索引字段，以惊人的速度返回结果。这是你永远不会考虑用传统数据库去做的一些事情。

搜索（search） 可以做到：

• 在类似于 gender 或者 age 这样的字段 上使用结构化查询，join_date 这样的字段上使用排序，就像SQL的结构化查询一样。
• 全文检索，找出所有匹配关键字的文档并按照相关性（relevance） 排序后返回结果。
• 以上二者兼而有之。

很多搜索都是开箱即用的，为了充分挖掘 Elasticsearch 的潜力，你需要理解以下三个概念：

映射（Mapping）
描述数据在每个字段内如何存储

分析（Analysis）
全文是如何处理使之可以被搜索的

领域特定查询语言（Query DSL）
Elasticsearch 中强大灵活的查询语言

以上提到的每个点都是一个大话题，我们将在 深入搜索 一章详细阐述它们。本章节我们将介绍这三点的一些基本概念——仅仅帮助你大致了解搜索是如何工作的。

我们将使用最简单的形式开始介绍 search API。
这一节我们只做简单的介绍，使之前的例子能够更清晰。

空搜索

搜索API的最基础的形式是没有指定任何查询的空搜索 ，它简单地返回集群中所有索引下的所有文档：

GET /_search

返回的结果（为了界面简洁编辑过的）像这样：

{
“hits” : {
“total” : 14,
“hits” : [
{
“_index”: “us”,
“_type”: “tweet”,
“_id”: “7”,
“_score”: 1,
“_source”: {
“date”: “2014-09-17”,
“name”: “John Smith”,
“tweet”: “The Query DSL is really powerful and flexible”,
“user_id”: 2
}
},
… 9 RESULTS REMOVED …
],
“max_score” : 1
},
“took” : 4,
“_shards” : {
“failed” : 0,
“successful” : 10,
“total” : 10
},
“timed_out” : false
}

hits

返回结果中最重要的部分是 hits ，它 包含 total 字段来表示匹配到的文档总数，并且一个 hits 数组包含所查询结果的前十个文档。

在 hits 数组中每个结果包含文档的 _index 、 _type 、 _id ，加上 _source 字段。这意味着我们可以直接从返回的搜索结果中使用整个文档。这不像其他的搜索引擎，仅仅返回文档的ID，需要你单独去获取文档。

_score

每个结果还有一个 _score ，它衡量了文档与查询的匹配程度。默认情况下，首先返回最相关的文档结果，就是说，返回的文档是按照 _score 降序排列的。在这个例子中，我们没有指定任何查询，故所有的文档具有相同的相关性，因此对所有的结果而言 1 是中性的 _score 。

max_score

值是与查询所匹配文档的 _score 的最大值。

took

took 值告诉我们执行整个搜索请求耗费了多少毫秒。

shards

_shards 部分 告诉我们在查询中参与分片的总数，以及这些分片成功了多少个失败了多少个。正常情况下我们不希望分片失败，但是分片失败是可能发生的。如果我们遭遇到一种灾难级别的故障，在这个故障中丢失了相同分片的原始数据和副本，那么对这个分片将没有可用副本来对搜索请求作出响应。假若这样，Elasticsearch 将报告这个分片是失败的，但是会继续返回剩余分片的结果。

timeout

timed_out 值告诉我们查询是否超时。默认情况下，搜索请求不会超时。 如果低响应时间比完成结果更重要，你可以指定 timeout 为 10 或者 10ms（10毫秒），或者 1s（1秒）：

GET /_search?timeout=10ms
在请求超时之前，Elasticsearch 将会返回已经成功从每个分片获取的结果。

Warning
应当注意的是 timeout 不是停止执行查询，它仅仅是告知正在协调的节点返回到目前为止收集的结果并且关闭连接。在后台，其他的分片可能仍在执行查询即使是结果已经被发送了。
使用超时是因为 SLA(服务等级协议)对你是很重要的，而不是因为想去中止长时间运行的查询。

Client程序演示

PS：在代码中引入静态
import static org.elasticsearch.index.query.QueryBuilders.*;
就能直接调用它的方法不用每次写出。例如
import static org.elasticsearch.index.query.QueryBuilders.*;
QueryBuilder qb = matchAllQuery();

不引入则：
import org.elasticsearch.index.query.QueryBuilders;
QueryBuilder qb = QueryBuilders.matchAllQuery();

在之前演示雇员例子中，我们已经演示过，这里可以感觉很容易的理解他们了。

/*
     * 空索引
     * 认识搜索响应
     */
    private static void showQueryAll(Client client) {
        SearchResponse response = client.prepareSearch().get();
        //分析查询结果
        // took--执行整个搜索请求耗费了多少毫秒
        long took = response.getTookInMillis();
        System.out.println(took);
        /*
         * timed_out--告诉我们查询是否超时。默认情况下，搜索请求不会超时。 如果低响应时间比完成结果更重要，
         * 你可以指定 timeout 为 10 或者 10ms（10毫秒），或者 1s（1秒）：
         * GET /_search?timeout=10ms
         * 在请求超时之前，Elasticsearch 将会返回已经成功从每个分片获取的结果。
         * Warning
应当注意的是 timeout  不是停止执行查询，它仅仅是告知正在协调的节点返回到目前为止收集的结果并且关闭连接。在后台，其他的分片可能仍在执行查询即使是结果已经被发送了。
使用超时是因为 SLA(服务等级协议)对你是很重要的，而不是因为想去中止长时间运行的查询。
         */
        boolean isTimedOut = response.isTimedOut();
        System.out.println("timed_out:"+isTimedOut);
        /*
         *  _shards--告诉我们在查询中参与分片的总数，以及这些分片成功了多少个失败了多少个。
         *  正常情况下我们不希望分片失败，但是分片失败是可能发生的。如果我们遭遇到一种灾难级别的故障，
         *  在这个故障中丢失了相同分片的原始数据和副本，那么对这个分片将没有可用副本来对搜索请求作出响应。
         *  假若这样，Elasticsearch 将报告这个分片是失败的，但是会继续返回剩余分片的结果。
         */
        int totalShards = response.getTotalShards();
        int successfulShards = response.getSuccessfulShards();
        int failedShards = response.getFailedShards();
        System.out.println("_shards:{ total="+totalShards+" successful="+successfulShards+" failed="+failedShards+"}");


        // hits总结果
        SearchHits searchHits = response.getHits();
        // max_score--与查询所匹配文档的 _score 的最大值
        float maxScore = searchHits.getMaxScore();
        // 一共文档数
        long totalHits = searchHits.getTotalHits();
        System.out.println("total="+totalHits+" max_score="+maxScore);

        // 文档在hit数组中,默认返回前10条
        Iterator<SearchHit> iterator = searchHits.iterator();
        while(iterator.hasNext()) {
            SearchHit hit = iterator.next();
            //索引
            String index = hit.getIndex();
            //类型
            String type = hit.getType();
            //id
            String id = hit.getId();
            //每个结果还有一个 _score   ，它衡量了文档与查询的匹配程度。默认情况下，首先返回最相关的文档结果，就是说，返回的文档是按照 _score 降序排列的。
            float score = hit.getScore();
            System.out.println("index="+index+" type="+type+" id="+id+" score="+score+" source-->"+hit.getSourceAsString());
        }
        System.out.println("查询结束...");
    }

调用：

//1.空索引
showQueryAll(client);

结果显示：
连接成功…
连接成功…
3
timed_out:false
_shards:{ total=30 successful=30 failed=0}
total=53 max_score=1.0
index=logstash-car-msg type=carmsg id=AV9_t-4zDK8yG4k-MolH score=1.0 source–>{“host”:”YFCSPT-SUSE-86”,”vehicleId”:”BCAAAD0005”,”vehicleName”:”巴斯达BBL5054XJE1公共安全监测车”,”searchCode”:”BSD-BBL5054XJE1”,”vehicleClass”:”特种车类”,”vehicleClassPicc”:”C49”,”vehicleType”:”1”,”brandNameNew”:”巴斯达”}
index=logstash-car-msg type=carmsg id=BCAAAD0000 score=1.0 source–>{“host”:”YFCSPT-SUSE-86”,”vehicleId”:”BCAAAD0000”,”vehicleName”:”巴斯达BBL5054XJE1公共安全监测车0”,”searchCode”:”BSD-BBL5054XJE0”,”vehicleClass”:”特种车类”,”vehicleClassPicc”:”C49”,”vehicleType”:”1”,”brandNameNew”:”巴斯达0”,”useYears”:0,”makeDate”:”2017-01-01 11:23:01”}
index=logstash-car-msg type=carmsg id=BCAAAD0005 score=1.0 source–>{“host”:”YFCSPT-SUSE-86”,”vehicleId”:”BCAAAD0005”,”vehicleName”:”巴斯达BBL5054XJE1公共安全监测车5”,”searchCode”:”BSD-BBL5054XJE5”,”vehicleClass”:”特种车类11”,”vehicleClassPicc”:”C49”,”vehicleType”:”1”,”brandNameNew”:”巴斯达5”,”useYears”:5,”makeDate”:”2017-01-01 11:23:01”}
index=logstash-car-msg type=carmsg id=BCAAAD0008 score=1.0 source–>{“vehicleName”:”车88”,”searchCode”:”BSD-BBL5054XJE8”}
index=logstash-car-msg1 type=carmsg1 id=BCAAAD0000 score=1.0 source–>{“host”:”YFCSPT-SUSE-86”,”vehicleId”:”BCAAAD0000”,”vehicleName”:”巴斯达BBL5054XJE1公共安全监测车0”,”searchCode”:”BSD-BBL5054XJE0”,”vehicleClass”:”特种车类”,”vehicleClassPicc”:”C49”,”vehicleType”:”1”,”brandNameNew”:”巴斯达0”,”useYears”:0,”makeDate”:”2017-01-01 11:23:01”}
。。。。。。
查询结束…

Head插件示例

多索引，多类型

你有没有注意到之前的 empty search 的结果，不同类型的文档 — user 和 tweet 来自不同的索引— us 和 gb ？

如果不对某一特殊的索引或者类型做限制，就会搜索集群中的所有文档。Elasticsearch 转发搜索请求到每一个主分片或者副本分片，汇集查询出的前10个结果，并且返回给我们。

然而，经常的情况下，你 想在一个或多个特殊的索引并且在一个或者多个特殊的类型中进行搜索。我们可以通过在URL中指定特殊的索引和类型达到这种效果，如下所示：

/_search 在所有的索引中搜索所有的类型
/gb/_search 在 gb 索引中搜索所有的类型
/gb,us/_search 在 gb 和 us 索引中搜索所有的文档
/g*,u*/_search 在任何以 g 或者 u 开头的索引中搜索所有的类型
/gb/user/_search 在 gb 索引中搜索 user 类型
/gb,us/user,tweet/_search 在 gb 和 us 索引中搜索 user 和 tweet 类型 /_all/user,tweet/_search 在所有的索引中搜索 user 和 tweet 类型
当在单一的索引下进行搜索的时候，Elasticsearch 转发请求到索引的每个分片中，可以是主分片也可以是副本分片，然后从每个分片中收集结果。多索引搜索恰好也是用相同的方式工作的–只是会涉及到更多的分片。

Tip
搜索一个索引有五个主分片和搜索五个索引各有一个分片准确来所说是等价的。

Client演示示例

在之前演示雇员例子中，我们已经演示过，这里可以感觉很容易的理解他们了。

SearchResponse response = client.prepareSearch("logstash-car-msg","logstash-car-msg1")
        .setTypes("carmsg", "carmsg1")
        .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
        .get();

还有MultiGet

MultiGetRequestBuilder builder = client.prepareMultiGet()
                .add("website","blog","1")    //单一ID       
                .add("website","blog","1","2") //多ID
                .add("logstash-car-msg", "carmsg","BCAAAD0005");  

等等，多获取的都能做到如此。

分页

在之前的 空搜索 中说明了集群中有 14 个文档匹配了（empty）query 。 但是在 hits 数组中只有 10 个文档。如何才能看到其他的文档？

和 SQL 使用 LIMIT 关键字返回单个 page 结果的方法相同，Elasticsearch 接受 from 和 size 参数：

size 显示应该返回的结果数量，默认是 10 from 显示应该跳过的初始结果数量，默认是 0
如果每页展示 5 条结果，可以用下面方式请求得到 1 到 3 页的结果：

GET /_search?size=5
GET /_search?size=5&from=5
GET /_search?size=5&from=10
考虑到分页过深以及一次请求太多结果的情况，结果集在返回之前先进行排序。 但请记住一个请求经常跨越多个分片，每个分片都产生自己的排序结果，这些结果需要进行集中排序以保证整体顺序是正确的。

在分布式系统中深度分页

理解为什么深度分页是有问题的，我们可以假设在一个有 5 个主分片的索引中搜索。 当我们请求结果的第一页（结果从 1 到 10 ），每一个分片产生前 10 的结果，并且返回给 协调节点 ，协调节点对 50 个结果排序得到全部结果的前 10 个。

现在假设我们请求第 1000 页–结果从 10001 到 10010 。所有都以相同的方式工作除了每个分片不得不产生前10010个结果以外。 然后协调节点对全部 50050 个结果排序最后丢弃掉这些结果中的 50040 个结果。

可以看到，在分布式系统中，对结果排序的成本随分页的深度成指数上升。这就是 web 搜索引擎对任何查询都不要返回超过 1000 个结果的原因。

Tip
在 重新索引你的数据 中解释了如何 能够 有效获取大量的文档。

Client演示示例

/*
     * 分页
     */
    private static void showScrollQuery(Client client) {
        SearchResponse response = client.prepareSearch("megacorp1")
                .setQuery(termQuery("first_name", "John"))
                .setSize(5).setFrom(0).get(); //size每一页最多5条记录,from跳过多少个数据显示

        SearchHits searchHits = response.getHits();
        // 文档在hit数组中,默认返回前10条
        Iterator<SearchHit> iterator = searchHits.iterator();
        while(iterator.hasNext()) {
            SearchHit hit = iterator.next();
            //为了效果只打印id
            String id = hit.getId();
            System.out.println("id="+id);
        }

    }

调用：

//3.分页
showScrollQuery(client);

结果显示：
连接成功…
id=6
id=11
id=1
id=13
id=5

改为setFrom(3)：
id=13
id=5
id=9
id=10
id=12

Head插件示例

轻量搜索

有两种形式的 搜索 API：一种是 “轻量的” 查询字符串 版本，要求在查询字符串中传递所有的 参数，另一种是更完整的 请求体 版本，要求使用 JSON 格式和更丰富的查询表达式作为搜索语言。

查询字符串搜索非常适用于通过命令行做即席查询。例如，查询在 tweet 类型中 tweet 字段包含 elasticsearch 单词的所有文档：

GET /_all/tweet/_search?q=tweet:elasticsearch

下一个查询在 name 字段中包含 john 并且在 tweet 字段中包含 mary 的文档。实际的查询就是这样
+name:john +tweet:mary

但是查询字符串参数所需要的 百分比编码 （译者注：URL编码）实际上更加难懂：

GET /_search?q=%2Bname%3Ajohn+%2Btweet%3Amary

• 前缀表示必须与查询条件匹配。类似地， - 前缀表示一定不与查询条件匹配。没有 + 或者 - 的所有其他条件都是可选的——匹配的越多，文档就越相关。

_all 字段

这个简单搜索返回包含 mary 的所有文档：

GET /_search?q=mary

之前的例子中，我们在 tweet 和 name 字段中搜索内容。然而，这个查询的结果在三个地方提到了 mary ：

• 有一个用户叫做 Mary
• 6条微博发自 Mary
• 一条微博直接 @mary

Elasticsearch 是如何在三个不同的字段中查找到结果的呢？

当索引一个文档的时候，Elasticsearch 取出所有字段的值拼接成一个大的字符串，作为 _all 字段进行索引。例如，当索引这个文档时：

{
“tweet”: “However did I manage before Elasticsearch?”,
“date”: “2014-09-14”,
“name”: “Mary Jones”,
“user_id”: 1
}

这就好似增加了一个名叫 _all 的额外字段：

“However did I manage before Elasticsearch? 2014-09-14 Mary Jones 1”

除非设置特定字段，否则查询字符串就使用 _all 字段进行搜索。

Tip
在刚开始开发一个应用时，_all 字段是一个很实用的特性。之后，你会发现如果搜索时用指定字段来代替 _all 字段，将会更好控制搜索结果。当 _all 字段不再有用的时候，可以将它置为失效，正如在 元数据: _all 字段 中所解释的。

更复杂的查询

下面的查询针对tweents类型，并使用以下的条件：

• name 字段中包含 mary 或者 john
• date 值大于 2014-09-10
• all 字段包含 aggregations 或者 geo

+name:(mary john) +date:>2014-09-10 +(aggregations geo)

View in Sense

查询字符串在做了适当的编码后，可读性很差：

?q=%2Bname%3A(mary+john)+%2Bdate%3A%3E2014-09-10+%2B(aggregations+geo)

从之前的例子中可以看出，这种 轻量 的查询字符串搜索效果还是挺让人惊喜的。 它的查询语法在相关参考文档中有详细解释，以便简洁的表达很复杂的查询。对于通过命令做一次性查询，或者是在开发阶段，都非常方便。

但同时也可以看到，这种精简让调试更加晦涩和困难。而且很脆弱，一些查询字符串中很小的语法错误，像 - ， : ， / 或者 ” 不匹配等，将会返回错误而不是搜索结果。

最后，查询字符串搜索允许任何用户在索引的任意字段上执行可能较慢且重量级的查询，这可能会暴露隐私信息，甚至将集群拖垮。

Tip

因为这些原因，不推荐直接向用户暴露查询字符串搜索功能，除非对于集群和数据来说非常信任他们。

相反，我们经常在生产环境中更多地使用功能全面的 request body 查询API，除了能完成以上所有功能，还有一些附加功能。但在到达那个阶段之前，首先需要了解数据在 Elasticsearch 中是如何被索引的。

这个很复杂，所以我们例子中一般是使用request body 查询API，这个不做研究