《Elasticsearch检索引擎学习指南》第一章基础入门

最新推荐文章于 2024-07-13 02:39:59 发布

0522

最新推荐文章于 2024-07-13 02:39:59 发布

阅读量104

点赞数

分类专栏：数据库文章标签： elasticsearch 数据库

原文链接：https://www.elastic.co/guide/cn/elasticsearch/guide/current/intro.html

版权

数据库专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Elasticsearch检索引擎学习指南

参考与学习资料
前言
安装并运行Elasticsearch
和Elasticsearch交互
- Java API
- RESTful API with JSON over HTTP
面向文档
- JSON
- 创建一个雇员目录
索引员工文档
检索文档
轻量搜索
使用查询表达式搜索
更复杂的搜索
全文搜索
短语搜索
高亮搜索
分析

参考与学习资料

前言

以下内容基于Elasticsearch 2.x版本，有些内容可能已经过时

这个世界已然被数据淹没。系统间流转和产生的大量数据亟待处理。现有的技术都着力于解决数据库存储以及数据的结构化。当需要对数据进行实时分析决策的时候，还是不够理想。
Elasticsearch是一个分布式、可扩展、实时的搜索与数据分析引擎。它可以从项目初始就赋予数据以搜索、分析的能力。
Elasticsearch不仅仅是全文搜索，还涉及到结构化搜索、数据分析、复杂的人类语言处理、地理位置和对象间关联关系等。

安装并运行Elasticsearch

和Elasticsearch交互

和 Elasticsearch 的交互方式取决于你是否使用 Java

Java API

如果你正在使用 Java，在代码中你可以使用 Elasticsearch 内置的两个客户端：

节点客户端（Node client）
节点客户端作为一个非数据节点加入到本地集群中。换句话说，它本身不保存任何数据，但是它知道数据在集群中的哪个节点中，并且可以把请求转发到正确的节点。
传输客户端（Transport client）
轻量级的传输客户端可以将请求发送到远程集群。它本身不加入集群，但是它可以将请求转发到集群中的一个节点上。
两个 Java 客户端都是通过 9300 端口并使用 Elasticsearch 的原生传输协议和集群交互。集群中的节点通过端口 9300 彼此通信。如果这个端口没有打开，节点将无法形成一个集群。

Java 客户端作为节点必须和 Elasticsearch 有相同的主要版本；否则，它们之间将无法互相理解。

更多的 Java 客户端信息可以在 Elasticsearch Clients 中找到。

RESTful API with JSON over HTTP

所有其他语言可以使用 RESTful API 通过端口 9200 和 Elasticsearch 进行通信，你可以用你最喜爱的 web 客户端访问 Elasticsearch 。事实上，正如你所看到的，你甚至可以使用 curl 命令来和 Elasticsearch 交互。

Elasticsearch 为以下语言提供了官方客户端–Groovy、JavaScript、.NET、 PHP、 Perl、 Python 和 Ruby—还有很多社区提供的客户端和插件，所有这些都可以在 Elasticsearch Clients 中找到。

一个 Elasticsearch 请求和任何 HTTP 请求一样由若干相同的部件组成：

curl -X<VERB> '<PROTOCOL>://<HOST>:<PORT>/<PATH>?<QUERY_STRING>'-d'<BODY>'

<>	说明
VERB	适当的Http方法或谓词：GET、POST、HEAD、DELETE
PROTOCOL	http或者https
HOST	集群中任意节点的主机名，或者本地localhost
PORT	默认9200
PATH	API的终端路径
QUERY_STRING	任意可选的查询字符串参数
BODY	一个JSON格式的请求体

例如，计算集群中文档的数量，可以如下命令：

curl -XGET 'http://localhost:9200/_count?pretty' -d'
{
	"query":{
		"match_all":{}
	}
}

ES返回一个HTTP状态码和一个JSION格式的返回值。如下：

{
	"count":0,
	"_shards":{
		"total":5,
		"successful":5,
		"failed":0
	}
}

面向文档

在应用程序中对象很少是一个简单的键和值的列表。通常，他们拥有更复杂的数据结构，可能包括日期、地理信息、其他对象或者数组等。
ES是 面向文档 的，意味着他存储整个对象或文档。ES不仅存储文档，而且索引整个文档的内容，使其可以被检索。ES中，我们对文档进行索引、检索、排序和过滤，而不是对行列数据。这是ES能支持复杂全文检索的原因。

JSON

ES使用JSON作为文档的序列化格式。

创建一个雇员目录

在一个业务场景下，要对Megacorp公司的员工创建一个目录。包含以下业务需求：

支持包含多值标签、数值、以及全文本的数据
检索任一员工的完整信息
允许结构化搜索，条件查询
允许简单的全文搜索以及较为复杂的短语搜索
支持在匹配文档内容中高亮显示搜索片段
支持基于数据创建和管理分析仪表盘

索引员工文档

第一个业务需求是存储员工数据。这将会以员工文档的形式存储：一个文档代表一个员工。存储数据到ES的行为叫做索引，但在索引一个文档之前，需要确定将文档存储在哪里。

索引这个词在ES中有多种含义

作为名词，一个索引类似于传统关系数据库中的一个数据库，是一个存储关系型文档的地方
作为动词，索引一个文档就是存储一个文档到一个存储库中以便被检索和查询。这类似于SQL语句中的insert关键词，当文档已存在时，新文档会替换旧文档

对于员工目录，将作如下操作：

每个员工索引一个文档，文档包含该员工所有信息
每个文档都是employee类型
该类型位于索引megacorp中
该索引保存在ES集群中

可以通过一条命令完成以上动作：

PUT /magecopr/employee/1
{
	"first_name":"John",
	"last_name":"Smith",
	"age":25,
	"about":"I love to go rock climbing",
	"interests":["sports","music"]
}

注意：上述请求路径包含三部分信息：
megacorp 索引名称
employee 类型名称
1 雇员ID

检索文档

执行一个HTTP GET请求并指定文档的地址----索引库、类型和ID。使用这三个信息可以返回原始的JSON文档：

GET /megacorp/employee/1

返回结果包含了文档的一些元数据，以及 _source 属性，内容是 John Smith 雇员的原始 JSON 文档：

{
  "_index" :   "megacorp",
  "_type" :    "employee",
  "_id" :      "1",
  "_version" : 1,
  "found" :    true,
  "_source" :  {
      "first_name" :  "John",
      "last_name" :   "Smith",
      "age" :         25,
      "about" :       "I love to go rock climbing",
      "interests":  [ "sports", "music" ]
  }
}

将 HTTP 命令由 PUT 改为 GET 可以用来检索文档，同样的，可以使用 DELETE 命令来删除文档，以及使用 HEAD 指令来检查文档是否存在。如果想更新已存在的文档，只需再次 PUT 。

轻量搜索

这次使用 _search 。返回结果包括了所有三个文档，放在数组 hits 中。一个搜索默认返回十条结果。

{
   "took":      6,
   "timed_out": false,
   "_shards": { ... },
   "hits": {
      "total":      3,
      "max_score":  1,
      "hits": [
         {
            "_index":         "megacorp",
            "_type":          "employee",
            "_id":            "3",
            "_score":         1,
            "_source": {
               "first_name":  "Douglas",
               "last_name":   "Fir",
               "age":         35,
               "about":       "I like to build cabinets",
               "interests": [ "forestry" ]
            }
         },
         {
            "_index":         "megacorp",
            "_type":          "employee",
            "_id":            "1",
            "_score":         1,
            "_source": {
               "first_name":  "John",
               "last_name":   "Smith",
               "age":         25,
               "about":       "I love to go rock climbing",
               "interests": [ "sports", "music" ]
            }
         },
         {
            "_index":         "megacorp",
            "_type":          "employee",
            "_id":            "2",
            "_score":         1,
            "_source": {
               "first_name":  "Jane",
               "last_name":   "Smith",
               "age":         32,
               "about":       "I like to collect rock albums",
               "interests": [ "music" ]
            }
         }
      ]
   }
}

接下来，尝试下搜索姓氏为 Smith 的雇员。为此，我们将使用一个高亮搜索，很容易通过命令行完成。这个方法一般涉及到一个查询字符串（query-string）搜索，因为我们通过一个URL参数来传递查询信息给搜索接口：

GET /megacorp/employee/_search?q=last_name:Smith

我们仍然在请求路径中使用 _search 端点，并将查询本身赋值给参数 q= 。返回结果给出了所有的 Smith：

{
   ...
   "hits": {
      "total":      2,
      "max_score":  0.30685282,
      "hits": [
         {
            ...
            "_source": {
               "first_name":  "John",
               "last_name":   "Smith",
               "age":         25,
               "about":       "I love to go rock climbing",
               "interests": [ "sports", "music" ]
            }
         },
         {
            ...
            "_source": {
               "first_name":  "Jane",
               "last_name":   "Smith",
               "age":         32,
               "about":       "I like to collect rock albums",
               "interests": [ "music" ]
            }
         }
      ]
   }
}

使用查询表达式搜索

Query-string 搜索通过命令非常方便地进行临时性的即席搜索，但它有自身的局限性（参见轻量搜索）。Elasticsearch 提供一个丰富灵活的查询语言叫做查询表达式，它支持构建更加复杂和健壮的查询。

领域特定语言（DSL），使用 JSON 构造了一个请求。我们可以像这样重写之前的查询所有名为 Smith 的搜索：

GET /megacorp/employee/_search
{
    "query" : {
        "match" : {
            "last_name" : "Smith"
        }
    }
}

返回结果与之前的查询一样，但还是可以看到有一些变化。其中之一是，不再使用 query-string 参数，而是一个请求体替代。这个请求使用 JSON 构造，并使用了一个 match 查询（属于查询类型之一，后面将继续介绍）。

更复杂的搜索

现在尝试下更复杂的搜索。同样搜索姓氏为 Smith 的员工，但这次我们只需要年龄大于 30 的。查询需要稍作调整，使用过滤器 filter ，它支持高效地执行一个结构化查询。

GET /megacorp/employee/_search
{
    "query" : {
        "bool": {
            "must": {
                "match" : {
                    "last_name" : "smith" 
                }
            },
            "filter": {
                "range" : {
                    "age" : { "gt" : 30 } 
                }
            }
        }
    }
}

一个 range 过滤器，它能找到年龄大于 30 的文档，其中 gt 表示_大于_(great than)。

全文搜索

搜索下所有喜欢攀岩（rock climbing）的员工：

GET /megacorp/employee/_search
{
    "query" : {
        "match" : {
            "about" : "rock climbing"
        }
    }
}

显然我们依旧使用之前的 match 查询在about 属性上搜索 “rock climbing” 。得到两个匹配的文档

{
   ...
   "hits": {
      "total":      2,
      "max_score":  0.16273327,
      "hits": [
         {
            ...
            "_score":         0.16273327, 
            "_source": {
               "first_name":  "John",
               "last_name":   "Smith",
               "age":         25,
               "about":       "I love to go rock climbing",
               "interests": [ "sports", "music" ]
            }
         },
         {
            ...
            "_score":         0.016878016, 
            "_source": {
               "first_name":  "Jane",
               "last_name":   "Smith",
               "age":         32,
               "about":       "I like to collect rock albums",
               "interests": [ "music" ]
            }
         }
      ]
   }
}

Elasticsearch 默认按照相关性得分排序，即每个文档跟查询的匹配程度。第一个最高得分的结果很明显：John Smith 的 about 属性清楚地写着 “rock climbing” 。

但为什么 Jane Smith 也作为结果返回了呢？原因是她的 about 属性里提到了 “rock” 。因为只有 “rock” 而没有 “climbing” ，所以她的相关性得分低于 John 的。

这是一个很好的案例，阐明了 Elasticsearch 如何在全文属性上搜索并返回相关性最强的结果。Elasticsearch中的相关性概念非常重要，也是完全区别于传统关系型数据库的一个概念，数据库中的一条记录要么匹配要么不匹配。

短语搜索

找出一个属性中的独立单词是没有问题的，但有时候想要精确匹配一系列单词或者_短语_ 。比如，我们想执行这样一个查询，仅匹配同时包含 “rock” 和 “climbing” ，并且二者以短语 “rock climbing” 的形式紧挨着的雇员记录。

为此对 match 查询稍作调整，使用一个叫做 match_phrase 的查询：

GET /megacorp/employee/_search
{
    "query" : {
        "match_phrase" : {
            "about" : "rock climbing"
        }
    }
}

毫无悬念，返回结果仅有 John Smith 的文档。

高亮搜索

许多应用都倾向于在每个搜索结果中高亮部分文本片段，以便让用户知道为何该文档符合查询条件。在 Elasticsearch 中检索出高亮片段也很容易。

再次执行前面的查询，并增加一个新的 highlight 参数：

GET /megacorp/employee/_search
{
    "query" : {
        "match_phrase" : {
            "about" : "rock climbing"
        }
    },
    "highlight": {
        "fields" : {
            "about" : {}
        }
    }
}

当执行该查询时，返回结果与之前一样，与此同时结果中还多了一个叫做 highlight 的部分。这个部分包含了 about 属性匹配的文本片段，并以 HTML 标签 <em></em> 封装：

{
   ...
   "hits": {
      "total":      1,
      "max_score":  0.23013961,
      "hits": [
         {
            ...
            "_score":         0.23013961,
            "_source": {
               "first_name":  "John",
               "last_name":   "Smith",
               "age":         25,
               "about":       "I love to go rock climbing",
               "interests": [ "sports", "music" ]
            },
            "highlight": {
               "about": [
                  "I love to go <em>rock</em> <em>climbing</em>" 
               ]
            }
         }
      ]
   }
}

分析

终于到了最后一个业务需求：支持管理者对员工目录做分析。 Elasticsearch 有一个功能叫聚合（aggregations），允许我们基于数据生成一些精细的分析结果。聚合与 SQL 中的 GROUP BY 类似但更强大。

举个例子，挖掘出员工中最受欢迎的兴趣爱好：

GET /megacorp/employee/_search
{
  "aggs": {
    "all_interests": {
      "terms": { "field": "interests" }
    }
  }
}

暂时忽略掉语法，直接看看结果：

{
   ...
   "hits": { ... },
   "aggregations": {
      "all_interests": {
         "buckets": [
            {
               "key":       "music",
               "doc_count": 2
            },
            {
               "key":       "forestry",
               "doc_count": 1
            },
            {
               "key":       "sports",
               "doc_count": 1
            }
         ]
      }
   }
}

可以看到，两位员工对音乐感兴趣，一位对林业感兴趣，一位对运动感兴趣。这些聚合的结果数据并非预先统计，而是根据匹配当前查询的文档即时生成的。如果想知道叫 Smith 的员工中最受欢迎的兴趣爱好，可以直接构造一个组合查询：

GET /megacorp/employee/_search
{
  "query": {
    "match": {
      "last_name": "smith"
    }
  },
  "aggs": {
    "all_interests": {
      "terms": {
        "field": "interests"
      }
    }
  }
}

all_interests 聚合已经变为只包含匹配查询的文档：

  ...
  "all_interests": {
     "buckets": [
        {
           "key": "music",
           "doc_count": 2
        },
        {
           "key": "sports",
           "doc_count": 1
        }
     ]
  }

聚合还支持分级汇总。比如，查询特定兴趣爱好员工的平均年龄：

GET /megacorp/employee/_search
{
    "aggs" : {
        "all_interests" : {
            "terms" : { "field" : "interests" },
            "aggs" : {
                "avg_age" : {
                    "avg" : { "field" : "age" }
                }
            }
        }
    }
}

得到的聚合结果有点儿复杂，但理解起来还是很简单的：

  ...
  "all_interests": {
     "buckets": [
        {
           "key": "music",
           "doc_count": 2,
           "avg_age": {
              "value": 28.5
           }
        },
        {
           "key": "forestry",
           "doc_count": 1,
           "avg_age": {
              "value": 35
           }
        },
        {
           "key": "sports",
           "doc_count": 1,
           "avg_age": {
              "value": 25
           }
        }
     ]
  }

输出基本是第一次聚合的加强版。依然有一个兴趣及数量的列表，只不过每个兴趣都有了一个附加的 avg_age 属性，代表有这个兴趣爱好的所有员工的平均年龄。

即使现在不太理解这些语法也没有关系，依然很容易了解到复杂聚合及分组通过 Elasticsearch 特性实现得很完美，能够提取的数据类型也没有任何限制。

0522

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《Elasticsearch检索引擎学习指南》第一章基础入门

Elasticsearch检索引擎学习指南参考资料前言注意内容简介安装并运行Elasticsearch和Elasticsearch交互Java APIRESTful API with JSON over HTTP面向文档JSON创建一个雇员目录索引员工文档参考资料Elasticsearch:权威指南Elasticsearch的GitHub仓库ES中文社区Elasticsearch GuideElastic Stack and Product Documentation前言注意以下内容基
复制链接

扫一扫