ElasticSearch7：安装折腾、基本命令、搜索和高级查询、分词器、字段类型、kibana、实用技能、springboot整合、集群搭建、原理简介

最新推荐文章于 2024-03-20 10:28:28 发布
最新推荐文章于 2024-03-20 10:28:28 发布
阅读量1k 收藏 1
点赞数
分类专栏： 其他 文章标签： elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weisubao/article/details/104666217
版权

文章目录

1、全文搜索说明

搜索，如果是结构化数据库，那么要搜索的内容一般是某个或多个字段，如果完全匹配就是=，如果模糊匹配的话，那么就用like，完全匹配的还好弄，把这个字段设置成索引，那么下次查询的时候直接在索引里面查，查出来之后回表，速度还能接受。但是模糊搜索的话，如果要搜索的词不是在最开头，即使用的是like %xxx%，那么这个索引没法发挥作用，速度慢到怀疑人生。不信的话，可以用一个300万条数据的表试一试。

这个时候，我们就要想怎么弄了。肯定要做一些中间操作，类似于建个索引这种的中间操作。这里用的就是倒排索引，也就是说对某个字段里的内容进行倒排索引的建立，倒排索引也是索引的一种，只是和我们普通的索引原理有些不同而已，倒排索引可以实现把这个字段里面的词都提取出来然后记录下来，记录的数据可能包括是什么词、在什么这段话的位置等等。这样下次要查找的话，先去这个索引查找，这样不仅能找到哪条记录能匹配，还知道了这个词在这段内容的什么位置等信息。

以上就是针对全文索引一般采用的方式，也是Elasticsearch采用的方式。全文索引重点在于针对一大段的内容进行搜索。

所以建立索引的方式就是对已有的内容进行抽取、再重组一下、存起来。索引占用空间，所以是中牺牲空间换取时间的方式。

我们现在学的是Elasticsearch，它和Solr都是基于Lucene的。各有优缺点吧，我们现在学的是Elasticsearch，用的挺多的。

2、单机安装（非集群）

折腾了很多遍，现在捋一下，在拿到一台最新的CentOS（只分配了1G内存）后应该怎么一步步做：

# 先更新一下yum，然后下载net-tools和wget，后面要用ifconfig查看ip，wget下载Elasticsearch文件
yum update -y
yum install -y net-tools
yum install -y wget

# 新增一个用户（如果安装CentOS的时候除了root外没有其他用户的话）
# 因为Elasticsearch需要在非root用户下运行
useradd tom
passwd tom

# 先别着急切换，我们先打开防火墙的9200端口到时候访问用
firewall-cmd --add-port=9200/tcp --permanent
firewall-cmd --reload

# 我们再设置max_map_count为262144，这边你可以先不设置，等报错中让你设置max_map_count的时候再回来设置也行，但到时候注意记得切换成root做这个操作
vi /etc/sysctl.conf
# 在文件最下面增加如下设置后退出
vm.max_map_count=262144
# 然后执行生效
sysctl -p

# 我们再设置用户操作文件数
# 这是针对报错：max file descriptors [4096] for elasticsearch process is too low, increase to at least [65536]
vi /etc/security/limits.conf
# 最下面新增如下
*   soft    nofile  65536
*   hard    nofile  65536

# 我们再设置线程数
# 这是针对报错：max number of threads [3818] for user [es] is too low, increase to at least [4096]
vi /etc/security/limits.conf
# 最下面新增如下
*   soft    nproc  4096
*   hard    nproc  4096


# 切换到tom用户，然后在home目录下下载和配置
# 直接下载的话，建议地址换成国内镜像的地址，如下
wget https://elasticsearch.thans.cn/downloads/elasticsearch/elasticsearch-7.2.0-linux-x86_64.tar.gz
# 如果想直接用官方的地址，那么建议不要直接在服务器中下载，先在本地下，下载之后上传到服务器中
# 比如先下载这个https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.5.2-linux-x86_64.tar.gz
# 下载在本地之后，然后连接远程服务器上传过去，命令如下，输入tom密码即可，以下会上传到tom用户的home目录中
scp Downloads/elasticsearch-7.5.2-linux-x86_64.tar.gz tom@172.16.25.149:~

# 甭管上面是哪种方式获得的文件，解压缩这个文件(选自己的版本)
tar zvxf elasticsearch-7.2.0-linux-x86_64.tar.gz

# 然后修改配置文件，允许外网访问
vi elasticsearch-7.2.0/config/elasticsearch.yml
# 修改如下绑定ip为0.0.0.0
network.host=0.0.0.0
# 取消下面这两行的注释，不然可能出现cluster之类的报错
# 尤其是很多教程只设置了cluster那一行，node那行没有设置
# 会导致，cluster找不到node-1也找不到node-2
# 所以在操作的时候会报错master_not_discovered_exception
node.name = node-1
cluster.initial_master_nodes: ["node-1", "node-2"]


# 先用ifconfig查看一下服务器的ip，比如得到127.16.25.149
ifconfig

# 最后运行
./elasticsearch-7.2.0/bin/elasticsearch

在本机访问http://127.16.25.149:9200，出现以下就是成功了：

{
  "name" : "bogon",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "_na_",
  "version" : {
    "number" : "7.2.0",
    "build_flavor" : "default",
    "build_type" : "tar",
    "build_hash" : "508c38a",
    "build_date" : "2019-06-20T15:54:18.811730Z",
    "build_snapshot" : false,
    "lucene_version" : "8.0.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

3、基本概念

索引（index）类似于数据库。

类型（type）在7.x版本中基本已经不怎么提及。原先5.x中一个索引可以有多种type，6.x中每个index只能有一种type，现在好像直接移除了这个限制。

映射（mapping）就是定义字段信息的。

文档（document）相当于一条记录。

文档中有不同的字段。

节点，相当于一台服务器或者一个Elasticsearch进程。如果很多节点以一定的规则组成的话，那就叫集群。

一个索引Index的数据可以存放在很多台机器的多个分片（shard）中，每个shard可以有主分片（primary shard）和副分片（replica shard）。

4、基本使用

Elasticsearch的接口主要是依照REST风格设计的。

# 新增一个索引
PUT http://172.16.25.149:9200/user
# 查看索引
GET http://172.16.25.149:9200/user
# 查看多个索引
GET http://172.16.25.149:9200/user,post
# 查看所有索引
GET http://172.16.25.149:9200/_all

# 查看所有索引的另一个接口
GET http://172.16.25.149:9200/_cat/indices
# 加上参数v会显示更全的信息
GET http://172.16.25.149:9200/_cat/indices?v

# 只想查看某个索引是否存在，返回200就存在，404就不存在
HEAD http://172.16.25.149:9200/user

# 关闭索引，信息中就会有这个字段"verified_before_close": "true"
POST http://172.16.25.149:9200/user/_close

# 打开索引
POST http://172.16.25.149:9200/user/_open

# 删除索引
DELETE http://172.16.25.149:9200/user

映射Mapping的基本使用。

# 给一个索引新增mapping
# text表示这个字段要全文搜索，会分词
PUT http://172.16.25.149:9200/post/_mapping
{
    "properties":{
        "title": {"type": "text"},
        "content": {"type": "text"},
        "author": {"type": "keyword"}
    }
}

# 修改mapping的话只能新增。不能修改已有字段的类型type
PUT http://172.16.25.149:9200/post/_mapping
{
    "properties":{
        "title": {"type": "text"},
        "content": {"type": "text"},
        "author": {"type": "keyword"},
        "publish_date": {"type": "keyword"}
    }
}

# 查看某个索引的mapping
GET http://172.16.25.149:9200/post/_mapping

# 查看所有的mapping
GET http://172.16.25.149:9200/_mapping
GET http://172.16.25.149:9200/_all/_mapping

文档的增删改查。

# 指定ID新增一个文档，只能指定_doc，不能换成其他自定义的，否则报错
PUT http://172.16.25.149:9200/post/_doc/1
{
    "title": "我的Elasticsearch学习之路",
    "content": "随便什么内容随便什么内容随便什么内容随便什么内容随便什么内容",
    "author": "小张",
    "publish_date": "2020-01-02 18:09:09"
}

# 查看这个文档
GET http://172.16.25.149:9200/post/_doc/1

# 不指定ID新增。需要用POST，这个和指定ID用PUT不一样。
POST http://172.16.25.149:9200/post/_doc
{
    "title": "你在南方的艳阳里",
    "content": "哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈",
    "author": "小王",
    "publish_date": "2020-02-12 09:08:08"
}

# 查询所有文档，可以发现自动生成的id是一串字符串，比如xIexoHABoTcv0s9Mn8Qd
GET http://172.16.25.149:9200/post/_search
{
	"query":{
        "match_all": {}
    }
}

# 如果索引不存在，直接新增文档时顺便指定索引
# 这时候就看自动创建索引那个字段是否设置为true
# 如果不是true，那么就不能再没有索引时新增文档，因为自动创建索引失败
# 查看自定创建索引的字段，发现里面空空的，其实这个时候是默认会自动创建索引的
GET http://172.16.25.149:9200/_cluster/settings
# 不信的话，我们尝试新增一个文档，并且指定一个不存在的索引看看，成功了
PUT http://172.16.25.149:9200/haha/_doc/1
{
    "title": "你在南方的艳阳里",
    "content": "哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈",
    "author": "小王",
    "publish_date": "2020-02-12 09:08:08"
}
# 所以这个时候，我们应该设置自动创建索引为false，试试看
PUT http://172.16.25.149:9200/_cluster/settings
{
	"persistent": {
		"action.auto_create_index": false
	}
}
# 这个时候再新增一个不存在索引的文档试试看，报错:no such index [wow]
PUT http://172.16.25.149:9200/wow/_doc/1
{
    "title": "你在南方的艳阳里",
    "content": "哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈",
    "author": "小王",
    "publish_date": "2020-02-12 09:08:08"
}

# 执行多次这个操作，会更新原有文档，因为ID指定了
PUT http://172.16.25.149:9200/post/_doc/1
{
    "title": "我的Elasticsearch学习之路啊啊啊啊阿",
    "content": "随便什么内容随便什么内容随便什么内容随便什么内容随便什么内容",
    "author": "小张",
    "publish_date": "2020-01-02 18:09:09"
}

# 如果只想新增，不想更新，那么可以执行操作类型，这样如果id为1的已经存在就会报错，不会更新原有文档
PUT http://172.16.25.149:9200/post/_doc/1?op_type=create
{
    "title": "我的Elasticsearch学习之路啊啊啊啊阿",
    "content": "随便什么内容随便什么内容随便什么内容随便什么内容随便什么内容",
    "author": "小张",
    "publish_date": "2020-01-02 18:09:09"
}

# 以下两个_mget，用GET和POST都可以得到结果
# 查询多个文档，查询条件全部写在body中，查哪个index，哪种类型，什么条件，此处条件用了id匹配
GET http://172.16.25.149:9200/_mget
{
	"docs":[
		{
			"_index": "post",
			"_type":"_doc",
			"_id": "1"
		},
		{
			"_index": "post",
			"_type":"_doc",
			"_id": "xIexoHABoTcv0s9Mn8Qd"
		}
	]
}

# 也可以把部分查询条件放在url中，比如index，这样每个查询条件中就不用指定index了
GET http://172.16.25.149:9200/post/_mget
{
	"docs":[
		{
			"_type":"_doc",
			"_id": "1"
		},
		{
			"_type":"_doc",
			"_id": "xIexoHABoTcv0s9Mn8Qd"
		}
	]
}

# 跟进一步
GET http://172.16.25.149:9200/post/_doc/_mget
{
	"docs":[
		{
			"_id": "1"
		},
		{
			"_id": "xIexoHABoTcv0s9Mn8Qd"
		}
	]
}

# 既然上面已经更进一步这么简化了，那索性直接变一下更简单
GET http://172.16.25.149:9200/post/_doc/_mget
{
    "ids": ["1", "xIexoHABoTcv0s9Mn8Qd"]
}

# 更新修改一个文档，指定id。其中author和publish_date字段没有写，那么不会改变还是原有值
POST http://172.16.25.149:9200/post/_update/1
{
    "doc":{
        "title": "hello world",
        "content": "hahahahhaha"
    }
}

# 给文档的_source中新增一个字段
POST http://172.16.25.149:9200/post/_update/1
{
    "script":"ctx._source.gender=1"
}
# 删除这个字段
POST http://172.16.25.149:9200/post/_update/1
{
    "script":"ctx._source.remove(\"gender\")"
}

# 更新，如果不存在就新增一个文档，如果存在就更新
# 如果不存在，则新增这个文档，字段只有一个age
# 第二次执行因为已经存在，所以就按照脚本更新
POST http://172.16.25.149:9200/post/_update/2
{
    "script":{
    	"source": "ctx._source.age += params.age",
	    "params": {
	    	"age": 10
	    }
    },
    "upsert":{
    	"age": 1
    }
}

# 删除文档
DELETE http://172.16.25.149:9200/post/_doc/2

5、搜索的简单使用

先准备一些数据，比如监理一个nba的索引，然后新增几个球员的信息。

# 新增索引，顺便新增了mapping
PUT http://172.16.25.149:9200/nba
{
    "mappings":{
    	"properties": {
    		"name": {"type": "text"},
    		"team_name": {"type": "text"},
    		"position": {"type": "text"},
    		"play_year": {"type": "long"},
    		"jerse_no": {"type": "keyword"}
    	}
    }
}
# 新增几条数据，以下数据的id分别为1、2、3不再重复贴代码
PUT http://172.16.25.149:9200/nba/_doc/1
{
	"name": "哈登",
	"team_name": "火箭",
	"position": "得分后卫",
	"play_year": 10,
	"jerse_no": "13"
}
{
	"name": "库里",
	"team_name": "勇士",
	"position": "控球后卫",
	"play_year": 10,
	"jerse_no": "30"
}
{
	"name": "詹姆斯",
	"team_name": "湖人",
	"position": "小前锋",
	"play_year": 15,
	"jerse_no": "23"
}

term词条查询，这个查询时一种精确查询，不是模糊匹配，比如：

GET http://172.16.25.149:9200/nba/_search
{
	"query": {
		"term":{
			"jerse_no": "23"
		}
	}
}

# 查询多条信息的时候，term变成terms，条件可用数组
{
	"query": {
		"terms":{
			"jerse_no": ["23", "13"]
		}
	}
}

全文查询（full text），这个时候，我们的查询关键字可能会被拆分成多个，只要其中有一个匹配某一条文档，那么这条文档就会被返回。这里的全文查询的字段类型都应该是text，不能是keyword或者其他。

# 这是查询全部，from和size是分页的操作
GET http://172.16.25.149:9200/nba/_search
{
	"query": {
		"match_all":{}
	},
	"from": 0,
	"size": 2
}

# 不用查询全部时，match_all需要改成match
# 下面这个仍然可以查出库里的那条记录，因为拆分成2个词，库里这个词命中了一条记录就返回了
{
	"query": {
		"match":{
			"name": "库里小孩"
		}
	},
	"from": 0,
	"size": 100
}

# 改成库就里也能查出来。
{
	"query": {
		"match":{
			"name": "库就里"
		}
	},
	"from": 0,
	"size": 100
}

# 多个字段匹配搜索，在name和team_name中匹配湖人这个关键字
{
	"query": {
		"multi_match":{
			"query": "湖人",
			"fields": ["name", "team_name"]
		}
	}
}

# 如果是match的话，因为存在拆词，所以得分后卫和控球后卫都被查出来
# 但是用match_phrase的话，只能查出得分后卫
# 这种类似于不拆词，但不是精确查询，因为用得分后还是把得分后卫这条数据查出来，就是不拆词的感觉
{
	"query": {
		"match_phrase":{
			"position": "得分后卫"
		}
	}
}

更改一下数据

POST http://172.16.25.149:9200/nba/_update/2
{
	"doc": {
		"name": "库里",
		"team_name": "勇士",
		"position": "控球后卫",
		"play_year": 10,
		"jerse_no": "30",
		"title": "the best 3-point shooter"
	}
}

# 然后查询，带前缀的，能把库里那条记录查出来
{
	"query": {
		"match_phrase_prefix":{
			"title": "the b"
		}
	}
}

6、分词器

# 标准分词器standard，大写变小写，短横前后分隔
POST http://172.16.25.149:9200/_analyze
{
	"analyzer": "standard",
	"text": "The best 3-points shooter is Curry"
}

# 简单分词器simple，相比于standard，就是去除了数字，也就是上面的3就么有了

# 空格分词器whitespace，只是通过空格分词，不转换成小写，短横也保留，只看空格

# 停止分词器stop，会转小写，但是去除了一些无意义的词，这个词有默认库，也可以自定义库

# 语言分词器，比如english，但不太准确

# 正则分词器pattern，默认的是\W+，去除非字符串的词

举例，如果我事先给某条记录增加一个"title": "the best 3-point shooter is Curry!"，我们查询title为Curry或者curry或者Curry!都能查到。因为默认分词器，会分出curry这个词，我们在查询的时候也会有大小写转换，所以能匹配到。

但是如果我在创建索引的时候，自定义一个分词器，然后让这个title字段用这个分词器，就可能查不到了。比如，用whitespace分词器。
折旧意味着，我新增信息后，title中的信息是按照空格分的，那么久没有Curry了，而是Curry!在一起组成的，所以我直接搜索Curry就搜不到，但是搜索Curry!就能搜到。

PUT http://172.16.25.149:9200/_nba
{
    "settings": {
        "analysis": {
            "analyzer": {
                "my_analyzer": "whitespace"
            }
        }
    },
    "mappings": {
        "properties": {
            ...
            "title": {
                "type": "text",
                "analyzer": "my_analyzer"
            }
        }
    }
}

常用的中文分词器，这里只介绍两种，一种是smartcn，另一种是ik。因为内置的分词器对中文基本是没用的，所以我们需要另外安装，这些都是以插件的形式安装进来的。可以在解压的Elasticsearch中的plugins中查看，如果之前没有安装过任何插件，这个目录下应该是空的，或者使用http://172.16.25.149:9200/_cat/plugins，当然没安装时这个返回结果是空的。

（1）安装smartcn，在bin目录中使用安装插件的命令安装。

./bin/elasticsearch-plugin install analysis-smartcn

安装完成后，可以通过以上的方法查看是否有安装好的这个插件。然后启动Elasticsearch，如果Elasticsearch是启动着的，那么需要重启才能生效。

测试分词效果：

POST http://172.16.25.149:9200/_analyze
{
	"analyzer": "smartcn",
	"text": "我明天去一趟超市买东西"
}

（2）安装ik也一样，可以直接通过命令安装，也可以直接下载压缩包然后解压后把它直接放在plugins目录中都可以，下载的时候注意版本号要和自己的Elasticsearch版本一致。

./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.2.0/elasticsearch-analysis-ik-7.2.0.zip

同样的启动或者重启查看效果。ik有两种模式可以选择，一种是ik_max_word它会把能继续分的词继续分然后返回出来，比如有一趟也有一和趟，ik_smart相当于不再继续分。

POST http://172.16.25.149:9200/_analyze
{
	"analyzer": "ik_max_word",
	"text": "我明天去一趟超市买东西"
}

7、字段类型

（1）核心数据类型

  1. 字符串。text表示用于全文搜索的，keyword表示不分词用于完整搜索匹配的。
  2. 数值型。long，integer，short，byte，double，float，half_float，scaled_float。
  3. 布尔型。boolean。
  4. 二进制。binary，是把文件经过base64转换，默认不存储，且不可搜索。
  5. 范围类型。是一个范围不是一个值。integer_range，float_range，double_range，long_range，date_range等。存储的值可以是，比如age字段存储值为{"gte": 20, "lte": 40}，那么搜索时可以通过这样搜索出来{"query": {"term: {"age": 21}"}}。
  6. 日期类型。date，但因为我们提交的json数据格式是没有日期类型的，所以Elasticsearch是通过格式去判断它是不是一个日期，默认的格式foramt是strict_date_optional_time||epoch_millis，比如2020-01-02这种，或者2020/01/02 12:12:12这种，或者是从1970年1月1日0点开始的毫秒数或者秒数。

（2）复杂数据类型

  1. 数组类型。数组类型存储的元素类型要相同，不然报错。[1, 2]或者[{"name": "aa", "age": 20},{"name": "bb", "age": 30}]等。
  2. 对象类型。比如给一个字段存下面这个数值：
{
    ...
    "address": {
        "country": "china",
        "location": {
            "province": "beijing",
            "city": "beijing"
        }
    }
}

# 那么查询的方法如下
{
    "query":{
        "match": {
            "address.location.city": "beijing"
        }
    }
}

# 那上面这个数组或者对象怎么定义呢，也就是mapping怎么写呢，我们可以查一下就知道了，它追溯到最底一层然后定义为keyword
{
    "nba": {
        "mappings": {
            "properties": {
                "address": {
                    "properties": {
                        "location": {
                            "properties": {
                                "city": {
                                    "type": "text",
                                    "fields": {
                                        "keyword": {
                                            "type": "keyword",
                                            "ignore_above": 256
                                        }
                                    }
                                }
                            }
                        },
                        "region": {
                            "type": "text",
                            "fields": {
                                "keyword": {
                                    "type": "keyword",
                                    "ignore_above": 256
                                }
                            }
                        }
                    }
                },
                "hobbies": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                },
                "jerse_no": {
                    "type": "keyword"
                },
                "name": {
                    "type": "text"
                },
                "play_year": {
                    "type": "long"
                },
                "position": {
                    "type": "text"
                },
                "team_name": {
                    "type": "text"
                },
                "title": {
                    "type": "text",
                    "fields": {
                        "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                        }
                    }
                }
            }
        }
    }
}

（3）专用数据类型

  1. IP类型。本质是一个长整型。定义mapping的时候直接写"type": "ip"。存储的时候直接存储192.168.1.1之类的数值。查询的时候：
# 下面表示查询192.168.0.0~192.168.255.255之间的
{
    "query":{
        "term": {
            "ip_addr": "192.168.0.0/16"
        }
    }
}

8、Kibana的简单实用

# 下载，对应自己Elasticsearch的版本
wget https://artifacts.elastic.co/downloads/kibana/kibana-7.6.0-linux-x86_64.tar.gz
# 解压缩
tar zvxf kibana-7.6.0-linux-x86_64.tar.gz

# 先以后台方式启动Elasticsearch，不然一个控制台就被占据了，然后在启动kibana
./elasticsearch-7.2.0/bin/elasticsearch &
./kibana-7.2.0-linux-x86_64/bin/kibana

# 本机访问http://172.16.25.149:5601发现不行
# 当然不行了，5601端口防火墙没开
# 切换成root用户，开放端口，然后再切换回tom用户启动
su root
firewall-cmd --add-port=5601/tcp --permanent
firewall-cmd --reload
su tom
./kibana-7.2.0-linux-x86_64/bin/kibana

# 发现仍然不行，但是提示中有说可以通过localhost:5601访问
# 看到这，发现，肯定是绑定了localhost，没有允许访问，那么修改吧
vi kibana-7.2.0-linux-x86_64/config/kibana.yml
# 修改下面这一行，保存退出
server.host: "0.0.0.0"
# 然后重新启动，在本机访问http://172.16.25.149:5601就可以了

kibana有很多好用的功能，其中我们可以用它的console控制台，因为kibana直接连接了本机的Elasticsearch，所以我们可以在这边的控制台操作各种命令，它比postman好的地方在于，地址不用写ip地址了，而且输入命令也有智能提示。

9、批量导入测试数据

在kibana中操作，先删除我们之前创建的nba索引。然后创建换一个空的nba索引。

# 查看一下
GET /_cat/indices
# 删除
DELETE nba
# 创建一个新的索引
PUT nba

下载好我们的数据后，可以看一眼，主要格式是一行指定索引类型和id这些，下面一行数具体数据，这样排列下去，最后一行加一个回车保留一个空白行。

{"index":{"_index":"nba","_type":"_doc","_id":"1"}}
{"countryEn":"United States","teamName":"老鹰","birthDay":831182400000,"country":"美国","teamCityEn":"Atlanta","code":"jaylen_adams","displayAffiliation":"United States","displayName":"杰伦 亚当斯","schoolType":"College","teamConference":"东部","teamConferenceEn":"Eastern","weight":"86.2 公斤","teamCity":"亚特兰大","playYear":1,"jerseyNo":"10","teamNameEn":"Hawks","draft":2018,"displayNameEn":"Jaylen Adams","heightValue":1.88,"birthDayStr":"1996-05-04","position":"后卫","age":23,"playerId":"1629121"}
...

我们在本机通过bulk接口把数据批量导入到Elasticsearch中。

# player是文件名，ip换成自己的ip即可
curl -X POST "http://172.16.25.149:9200/_bulk" -H 'Content-Type: application/json' --data-binary @player

然后在kibana中查询试试：

GET nba/_search
{
  "query":{
    "match": {
      "displayName": "詹姆斯"
    }
  }
}

10、高级查询

（1）term的几种查询方式

term查询方式是针对keyword类型的字段查询的，针对text的查询一般虽然不报错但经常是查不出结果的。

# 查询球衣23号
GET nba/_search
{
  "query": {
    "term": {
      "jerseyNo": "23"
    }
  }
}
# 查询jerseyNo字段不为空的
GET nba/_search
{
  "query": {
    "exists": {
      "field": "jerseyNo"
    }
  }
}
# 查询球衣号码数据以2开头的
GET nba/_search
{
  "query": {
    "prefix": {
      "jerseyNo": "2"
    }
  }
}
# 查询球衣号码包含2，用通配符查询，*表示任意多个字符，?表示任意单个字符
GET nba/_search
{
  "query": {
    "wildcard": {
      "jerseyNo": "*2"
    }
  }
}
# 同上，只是用了正则
GET nba/_search
{
  "query": {
    "regexp": {
      "jerseyNo": ".*2"
    }
  }
}
# ids查询
GET nba/_search
{
  "query": {
    "ids": {
      "values": [1,2,3]
    }
  }
}

（2）范围查询

# 查询的是一个数值类型
GET nba/_search
{
  "query": {
    "range": {
      "playYear": {
        "gte": 1,
        "lte": 5
      }
    }
  }
}

# 查询的字段应该是一个日期date，存储的是long
# 如果不是date类型的话，查询会报错，无法用format转换
# 如果发现类型不正确，那么就获取这个索引的mapping，然后删除这个索引。重新修改一下刚刚复制的mapping在创建的时候传进去，然后再导入数据就可以了。
POST nba/_search
{
  "query": {
    "range": {
      "birthDay": {
        "gt": "10-12-1998",
        "lt": "2005",
        "format": "dd-MM-yyyy||yyyy"
      }
    }
  }
}

（3）布尔查询

  1. must必须出现在文档中
  2. must not必须不能出现在文档中
  3. filter和must一样，只是不参与打分
  4. should是应该出现在文档中，如果仅仅只有should那么和没有这个条件查出的结果一样，因为不在should条件中的文档也会被查出来
  5. 但是should设置后，再设置一个"minimum_should_match" : 1的话，相当于说should里面至少要有1个要满足条件，这个时候不满足的就不会被查出来。
POST nba/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "displayNameEn": "james"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "teamConferenceEn": "Eastern"
          }
        }
      ],
      "filter": [
        {
          "match": {
            "displayNameEn": "james"
          }
        }
      ],
      "should": [
        {
          "range": {
            "playYear": {
              "gte": 10,
              "lte": 12
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

（4）排序

POST nba/_search
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  },
  "sort": [
    {
      "playYear": {
        "order": "desc"
      },
      "heightValue": {
        "order": "asc"
      }
    }
  ], 
  "from": 0,
  "size": 10
}

（5）聚合查询之指标聚合

指标聚合就是对一个集合，比如年龄字段，查出总和、平均值等指标。聚合类型有max、min、sum和avg。还有根据字段去统计非空的数量"value_count": {"field": "playYear"}。还有一个去重计算cardinality，和max哪些用法一样。

# 求球龄的平均值
POST nba/_search
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  },
  "aggs": {
    "players_avg_number": {
      "avg": {
        "field": "playYear"
      }
    }
  },
  "size": 0
}

# 查询数量的话，也可以直接使用_count的api，下面查询条件可以任意写
POST nba/_count
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  }
}

有一个强大的类型是stats，一次在可以统计出5个指标。更强大的是extended_stats，这个甚至计算出方差这些指标。

POST nba/_search
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  },
  "aggs": {
    "players_avg_number": {
      "extended_stats": {
        "field": "playYear"
      }
    }
  },
  "size": 0
}

# 截取的部分结果
{
    ...
    "aggregations" : {
        "players_avg_number" : {
          "count" : 21,
          "min" : 0.0,
          "max" : 17.0,
          "avg" : 5.333333333333333,
          "sum" : 112.0,
          "sum_of_squares" : 1140.0,
          "variance" : 25.84126984126984,
          "std_deviation" : 5.083430912412387,
          "std_deviation_bounds" : {
            "upper" : 15.500195158158107,
            "lower" : -4.833528491491442
          }
        }
    }
}

百分位上的值统计

POST nba/_search
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  },
  "aggs": {
    "players_avg_number": {
      "percentiles": {
        "field": "playYear",
        # "percents": [25, 50, 75] # 自定义百分位
      }
    }
  },
  "size": 0
}

# 部分结果截取如下
{
  ...
  "aggregations" : {
    "players_avg_number" : {
      "values" : {
        "1.0" : 0.0,
        "5.0" : 0.0,
        "25.0" : 1.0,
        "50.0" : 3.0,
        "75.0" : 8.5,
        "95.0" : 15.349999999999998,
        "99.0" : 17.0
      }
    }
  }
}

（6）聚合查询之桶聚合

桶查询就是先分组再指标聚合。

# 根据age先分组，取10组，这里是取10组，不是分成10组
# 已经自动分好了，如果取组size数量少的话，可能只能取到部分值
# 可以通过order排序，_key就是每组的年龄,_count就是每组的数量
POST nba/_search
{
  "query": {
    "match": {
      "teamNameEn": "Rockets"
    }
  },
  "aggs": {
    "custom_aggs": {
      "terms": {
        "field": "age",
        "size": 20,
        "order": {
          "_key": "desc"
        }
      }
    }
  },
  "size": 0
}

还可以使用自定义的聚合实现比如：统计每个球队的平均年龄，这里用到了下面的一个聚合，使用名字就可以引用。注意这里的field字段要是keyword类型的，不能是text的。include表示只显示这几个结果，exclude就是不显示这几个的结果，它们是对结果进行筛选。include也可以使用正则不用数组，比如"include": "Lakers|Ro.*|Warr.*"之类的。

POST nba/_search
{
  "aggs": {
    "whateverName": {
      "terms": {
        "field": "teamNameEn",
        "include": ["Lakers", "Rockets", "Warriors"],
        "exclude": ["Warriors"]
        "size": 30,
        "order": {
          "customAggName": "desc"
        }
      },
      "aggs": {
        "customAggName": {
          "avg": {
            "field": "playYear"
          }
        }
      }
    }
  },
  "size": 0
}

自定义对某个字段分组统计，用的是range类型，然后指定字段和ramges。key是别名，不然会根据范围自动默认一个分组名称。

POST nba/_search
{
  "aggs": {
    "my_custom_name": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "to": 20,
            "key": "A"
          },
          {
            "from": 20,
            "to": 30
          },
          {
            "from": 30
          }
        ]
      }
    }
  },
  "size": 0
}

直方图的数据聚合结果，这个interval以后更换为fixed_interval。

POST nba/_search
{
  "aggs": {
    "birthYear": {
      "date_histogram": {
        "field": "birthDay",
        "format": "yyyy",
        "interval": "year"
      }
    }
  },
  "size": 0
}

（7）query_string查询

query_string相当于一句查询语句，Elasticsearch接收到语句后会解析，类似于我们在代码中写原生的SQL语句的感觉。关键字是AND、OR。如果要多个字段的话，就不用default_field，而是用"fields: ["", ""]这样。

POST nba/_search
{
  "query": {
    "query_string": {
      "default_field": "displayNameEn",
      "query": "james OR curry"
    }
  }
}

11、Elasticsearch的高级使用

（1）索引别名

# 所有索引的别名
GET /_alias

# 某个索引的别名
GET /nba/_alias

# 为索引nba新增一个别名nba_v1.0
POST /_aliases
{
  "actions": [
    {
      "add": {
        "index": "nba",
        "alias": "nba_v1.0"
      }
    }
  ]
}

# 删除某个别名
POST /_aliases
{
  "actions": [
    {
      "remove": {
        "index": "nba",
        "alias": "nba_v1.0"
      }
    }
  ]
}

# actions是一个数组，可以进行多个操作

# 比如为多个索引同时指定别名，或者为同一个索引同时指定多个别名等，就当做一个数组组织数据就行了

# 当一个别名同时关联多个索引时，只能有一个有写操作，通过is_write_index设置
# 删除某个别名
POST /_aliases
{
  "actions": [
    {
      "remove": {
        "index": "nba",
        "alias": "nba_v1.0",
        "is_write_index": true
      }
    }
  ]
}

# 如果别名可以写操作的话，那么可以直接用别名进行操作。但是执行为写的别名是不能查数据的。相当于读写分离了。

（2）重建索引

如果一个索引里的mapping等信息我们想要修改，比如字段类型需要修改的话，是不能直接修改的。利用别名我们可以实现这样的操作：

  1. 我们先养成一个习惯，我们大部分时候都会给索引设置别名，并且通过别名操作，也就是说索引真正的名字其实叫什么是无所谓的。
  2. 有了以上这个习惯，我们如果要重建索引的话，直接新建一个索引，然后利用_reindex把旧索引数据同步过去，然后给新的索引设置一个和旧索引相同的别名，然后删除旧索引。这里需要注意的是建立新索引的时候mapping要写成我们想修改后的索引。
  3. 比如我们之前直接导入player数据的时候，如果建立索引时候没有指定mapping它自动创建的可能不符合我们要求，比如birthDay字段它默认不是date，这个时候我们就可以重新建立索引。
# 新建了一个索引
PUT nba20200101
{
    "mappings" : {
      "properties" : {
        "age" : {
          "type" : "long"
        },
        "birthDay" : {
          "type" : "date"
        },
        "displayName" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
        ...
      }
    }
}

# 给新建的索引起别名，和老索引的别名一致，这样我们在使用的时候因为一直是通过别名的，所以不影响
POST _aliases
{
  "actions": [
    {
      "add": {
        "index": "nba20200101",
        "alias": "nba_latest"
      }
    }
  ]
}

# 拷贝数据过来
# 如果数据多，异步操作的话接口增加参数：/_reindex?wait_for_completion=false
POST /_reindex
{
  "source": {
    "index": "nba"
  },
  "dest": {
    "index": "nba20200101"
  }
}

（3）数据同步刷新

我们新增文档后，默认文档在缓冲区，经过一段时间才能被同步到Elasticsearch中，默认时间是1s，我们再新增文档的时候如果增加?refresh参数的话就会立即同步，如果在settings中设置为-1那么就是关闭刷新，不同步了。

# 增加这个参数立即同步
PUT nba_latest/_doc/999?refresh

# 修改刷新间隔时间，如果是-1，那么就是不刷新
PUT nba_latest/_settings
{
  "index": {
    "refresh_interval": "5s"
  }
}

（4）高亮查询

就是在查询的时候增加了highlight的设置，里面指定查哪些字段，然后这些字段中有符合文字的时候怎么对这个文字进行处理，主要就是前后增加html和各种css标签。默认是<em>xx</em>。

POST nba_latest/_search
{
  "query": {
    "match": {
      "displayNameEn": "james"
    }
  },
  "highlight": {
    "fields": {
      "displayNameEn": {
        "pre_tags": ["<span class='red'>"],
        "post_tags": ["</span>"]
      }
    }
  }
}

# 查询得到的结果，除了之前我们得到的结果外，还有一个字段额外标注了高亮值
"hits" : [
  {
    "_index" : "nba20200101",
    "_type" : "_doc",
    "_id" : "214",
    "_score" : 4.699642,
    "_source" : {
      "countryEn" : "United States",
      "teamName" : "火箭",
      "birthDay" : 620107200000,
      "country" : "美国",
      "teamCityEn" : "Houston",
      "code" : "james_harden",
      "displayAffiliation" : "Arizona State/United States",
      "displayName" : "詹姆斯 哈登",
      "schoolType" : "College",
      "teamConference" : "西部",
      "teamConferenceEn" : "Western",
      "weight" : "99.8 公斤",
      "teamCity" : "休斯顿",
      "playYear" : 10,
      "jerseyNo" : "13",
      "teamNameEn" : "Rockets",
      "draft" : 2009,
      "displayNameEn" : "James Harden",
      "heightValue" : 1.96,
      "birthDayStr" : "1989-08-26",
      "position" : "后卫",
      "age" : 30,
      "playerId" : "201935"
    },
    "highlight" : {
      "displayNameEn" : [
        "<span class='red'>James</span> Harden"
      ]
    }
  },
  ...
]

（5）查询建议

第一种是词条的建议，只分词单个词条，如果输入多个单词，也是被分成多个词条一个个提供意见的。

# 自定义一个名字，输入文本，匹配哪个字段。最核心的是模式，默认是missing，就是如果没有完全匹配的才给意见。
POST nba_latest/_search
{
  "suggest": {
    "CUSTOM_SUGGESTER": {
      "text": "jamse harden",
      "term": {
        "suggest_mode": "missing",
        "field": "displayNameEn"
      }
    }
  }
}

# 可以看到以下结果有options，harden就没有options，如果我们的james也写对了，那么也没有options
{
  ...
  "suggest" : {
    "CUSTOM_SUGGESTER" : [
      {
        "text" : "jamse",
        "offset" : 0,
        "length" : 5,
        "options" : [
          {
            "text" : "james",
            "score" : 0.8,
            "freq" : 5
          },
          {
            "text" : "jamal",
            "score" : 0.6,
            "freq" : 2
          }
          ...
        ]
      },
      {
        "text" : "harden",
        "offset" : 6,
        "length" : 6,
        "options" : [ ]
      }
    ]
  }
}

# 以上是默认的missing模式，还有popular（仅提供哪些文档频率比搜索词项高的建议）和always（总是提供建议）

第二种就是词组的建议了。

POST nba_latest/_search
{
  "suggest": {
    "CUSTOM_SUGGESTER": {
      "text": "jamse harden",
      "phrase": {
        "field": "displayNameEn"
      }
    }
  }
}

# 给的建议是以词组为整体的，而不是一个单词给一组options了
# 它会考虑我们输入词之间的关系
{
  ...
  "suggest" : {
    "CUSTOM_SUGGESTER" : [
      {
        "text" : "jamse harden",
        "offset" : 0,
        "length" : 12,
        "options" : [
          {
            "text" : "james harden",
            "score" : 0.0034703047
          },
          {
            "text" : "jamal harden",
            "score" : 0.0022665835
          },
          ...
        ]
      }
    ]
  }
}

第三种是完成建议。

# 我们直接查询的话，可能会报错
# 因为要求我们的字段类型是completion
POST nba_latest/_search
{
  "suggest": {
    "CUSTOM_SUGGESTER": {
      "text": "Miam",
      "completion": {
        "field": "teamCityEn"
      }
    }
  }
}

# 我们可以利用重建索引修改字段类型type为completion
# 查出的结果options中是整个文档的数据

所以查询建议主要为了用户输入搜索关键字的时候给出的查询建议，或者在搜索结果页面，给出一些搜索关键字建议。

12、springboot整合Elasticsearch

（1）假设我们正常的业务数据都在mysql中，然后增加了Elasticsearch，所以我们先本机mysql新建一个nba的数据库名，然后通过脚本把数据导入到数据库中。

（2）使用idea搭建项目。注意使用的依赖，其中Elasticsearch的jar版本尽量与服务器端的保持一致。核心的依赖如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.2.0</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>7.2.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.66</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

（3）配置application.yml。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/nba?useUnicode=true&characterEncoding=utf-8&erverTimeZone=GMT%2B8
    username: root
    password: xxx
    druid:
      initial-size: 5
      min-idle: 10
      max-active: 20
      web-stat-filter:
        exclusions: "*.js,*.jpg,*.png,*.gif,*.css,*.ico,/druid/*" # 不统计这些请求数据
      stat-view-servlet:
        login-username: druid
        login-password: druid
elasticsearch:
  host: 172.16.25.149
  port: 9200

（4）配置一个Elasticsearch的实例，主要是获取Elasticsearch实例，后续都基于这个去调用各个接口。

# config/ESConfig.java
@Configuration
public class ESConfig {
    @Value("${elasticsearch.host}")
    private String host;
    @Value("${elasticsearch.port}")
    private Integer port;

    @Bean
    public RestHighLevelClient client(){
        return new RestHighLevelClient(RestClient.builder(HttpHost.create("http://" + host + ":" + port)));
    }

    # getter和setter
}

（5）配置一下Mybatis。主要是扫描包。

# config/MybatisConfig.java
@Configuration
@MapperScan("com.example.esdemo.dao")
public class MybatisConfig {
}

（6）弄一个实例，model/NBAPlayer.java。

（7）弄一个dao，dao/NBAPlayerDao.java。

@Mapper
@Repository
public interface NBAPlayerDao {
    @Select("select * from nba_player")
    public List<NBAPlayer> selectAll();
}

（8）弄个Controller测试，controller/NBAPlayerController.java。

@RestController
@RequestMapping("/nba")
public class NBAPlayerController {
    @Autowired
    NBAPlayerDao nbaPlayerDao;

    @GetMapping("all")
    public List<NBAPlayer> getAllPlayers(){
        return nbaPlayerDao.selectAll();
    }
}

浏览器访问localhost:8080/nba/all可见结果。

（9）下面主要贴出在controller和service实现类中的代码，怎么使用es的接口实现增删改查的。核心接口文档官方都有详细的说明。

# controller
@RestController
@RequestMapping("/nba")
public class NBAPlayerController {
    @Autowired
    NBAPlayerService nbaPlayerService;

    @GetMapping("importAll")
    public boolean importAllPlayers(){
        return nbaPlayerService.importAllPlayers();
    }

    @GetMapping("deleteAll")
    public boolean deleteAllPlayers(){
        return nbaPlayerService.deleteAllPlayers();
    }

    @GetMapping("getPlayer")
    public Map<String, Object> getPlayer(String id){
        return nbaPlayerService.getPlayer(id);
    }

}

# service的实现类
package com.example.esdemo.service.impl;

@Service
public class NBAPlayerServiceImpl implements NBAPlayerService {

    private static final String NBA_INDEX = "nba_latest";

    @Autowired
    RestHighLevelClient client;

    @Autowired
    NBAPlayerDao nbaPlayerDao;

    @Override
    public boolean addPlayer(NBAPlayer player, String id) {
        IndexRequest request = new IndexRequest(NBA_INDEX).id(id).source(beanToMap(player));
        try {
            IndexResponse response = client.index(request, RequestOptions.DEFAULT);
            System.out.println(JSONObject.toJSON(response));
        }catch (IOException e){
            return false;
        }
        return true;
    }

    @Override
    public Map<String, Object> getPlayer(String id) {
        GetRequest request = new GetRequest(NBA_INDEX, id);
        try {
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            System.out.println(JSONObject.toJSON(response.getSource()));
            return response.getSource();
        }catch (IOException e){
            return null;
        }
    }

    @Override
    public boolean updatePlayer(String id) {
        UpdateRequest request = new UpdateRequest(NBA_INDEX, id);
        try {
            UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
            System.out.println(response);
        }catch (IOException e){
            return false;
        }
        return true;
    }

    @Override
    public boolean deletePlayer(String id) {
        DeleteRequest request = new DeleteRequest(NBA_INDEX, id);
        try {
            DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
            System.out.println(JSONObject.toJSON(response));
        }catch (IOException e){
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteAllPlayers() {
        DeleteByQueryRequest request = new DeleteByQueryRequest(NBA_INDEX);
        try {
            # 需要有个查询条件，但是我们要删除所有，所以查所有
            request.setQuery(QueryBuilders.matchAllQuery());
            BulkByScrollResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
        }catch (IOException e){
            return false;
        }
        return true;
    }

    @Override
    public boolean importAllPlayers() {
        List<NBAPlayer> nbaPlayerList = nbaPlayerDao.selectAll();
        for (NBAPlayer nbaPlayer : nbaPlayerList){
            addPlayer(nbaPlayer, String.valueOf(nbaPlayer.getId()));
        }
        return true;
    }

    public static <T>Map<String, Object> beanToMap(T bean){
        Map<String, Object> map = new HashMap<>();
        if (bean != null){
            BeanMap beanMap = BeanMap.create(bean);
            for (Object key : beanMap.keySet()){
                if (beanMap.get(key) != null){
                    map.put(key + "", beanMap.get(key));
                }
            }
        }
        return map;
    }
}

我们先清空Elasticsearch中的数据，我们代码中用了nba_latest这个索引，索引要保证我们有这个索引，如果没有的话，在kibana中执行PUT nba_latest即可。

然后访问localhost:8080/nba/importAll导入所有数据到ES中。

# kibana中查一下，数据都有了
POST nba_latest/_search
{
  "query": {
    "match_all": {}
  }
}

访问http://localhost:8080/nba/getPlayer?id=1可以查到这个数据。

接下来删除这个数据http://localhost:8080/nba/deleteAll再去kibana中查看发现没有数据了。

（10）模拟搜索

搜索主要用的是Search开头的系列接口，具体文档见官方。下面只列出主要部分。

# controller
@GetMapping("searchMatch")
public List<NBAPlayer> searchMatchNamePlayer(@RequestParam String displayNameEn){
    return nbaPlayerService.searchMatch("displayNameEn", displayNameEn);
}

@GetMapping("searchTerm")
public List<NBAPlayer> searchTerPlayer(@RequestParam(required = false) String country, @RequestParam(required = false) String teamName){
    if (!StringUtils.isEmpty(country)){
        return nbaPlayerService.searchTerm("country", country);
    }else {
        return nbaPlayerService.searchTerm("teamName", teamName);
    }
}

# 实现类
@Override
public List<NBAPlayer> searchMatch(String key, String value) {
    SearchRequest request = new SearchRequest(NBA_INDEX);
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchQuery(key, value));
    sourceBuilder.from(0);
    sourceBuilder.size(100);
    request.source(sourceBuilder);
    try {
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHit[] hits = response.getHits().getHits();
        List<NBAPlayer> nbaPlayers = new ArrayList<>();
        for (SearchHit hit : hits){
            nbaPlayers.add(JSONObject.parseObject(hit.getSourceAsString(), NBAPlayer.class));
        }
        return nbaPlayers;
    }catch (IOException e){
        return null;
    }
}

@Override
public List<NBAPlayer> searchTerm(String key, String value) {
    # 其他部分和上面的matchQuery都一样
    ...
    sourceBuilder.query(QueryBuilders.termQuery(key, value));
    ...
}

访问http://localhost:8080/nba/searchMatch?displayNameEn=james%20harden模拟搜索球员名字。

访问http://localhost:8080/nba/searchTerm?country=%E8%A5%BF%E7%8F%AD%E7%89%99或者http://localhost:8080/nba/searchTerm?teamName=%E7%81%AB%E7%AE%AD是精确搜索球员国家或者球员所在球队的。

首字母匹配的，比如点击索引J可以列出名字首字母是J的球员，这个和上面的类似，只是又换了一个接口，接口名字叫做prefixQuery(key, value)，这里就不展示了。

13、集群

（1）基础概念

集群的好处就不展开说了，提高可用性，还能顺便实现负载均衡，因为多台机器还实现了高性能。

集群（cluster）由多个节点组成。一个节点其实就是一个Elasticsearch实例，我们测试的时候可以在一台机器上开很多个Elasticsearch实例，但是实际生产环境中建议每台服务器部署一个实例，也就是一台服务器上一个节点。

每个节点都设置相同的集群名称，这就意味着它们是一个集群。所以在不在集群中，是看每个节点它们设置的集群名字是否一致。

每个节点可以通过配置文档声明是否准备竞选主节点（通过node.master设置true和false控制）或是否存储数据（通过node.data设置true和false控制）。

# 竞选主节点+存储数据
node.matser: true
node.data: true
# 只存储数据
node.matser: false
node.data: true
# 不竞选也不存储，那干嘛的？主要是用于负载均衡
node.matser: false
node.data: false

每个索引可以设置多个分片（shard），每个分片又有主分片（primary shard）和副分片（replica shard）。副分片作用可以用于读写分离达到负载均衡。在settings中设置，主分片不能动态调整，所以设置前要三思，副分片可以动态调整：

{
    "settings":{
        "idnex": {
            "number_of_shards": 1,
            "number_of_replicas": 1
        }
    }
}

（2）搭建集群

新建3个虚拟主机，CentOS7的。我们之前一直使用的就当做是1号，然后我们还需要安装2台。每台的安装过程参见文档前面，主要说明的是因为这里设置的是集群，所以在elasticsearch.yml上有一些说明：

# 集群名称，都设置一样的就行
cluster.name: hello-word
# 节点名称，三台依次编号即可 
node.name: node-1
# 都设置成网关地址
network.host: 0.0.0.0
# 都设置成端⼝
http.port: 9200
# 各节点ip，用于被服务发现的
discovery.seed_hosts:["172.16.25.149:9300","172.16.25.150:9300","172.16.25.151:9300"]
# 要成为主节点的节点名字
cluster.initial_master_nodes: ["node-1","node-2","node-3"]
# 数据和存储路路径，根据实际服务器设置
path.data: /home/tom/es/data
path.logs: /home/tom/es/logs

# 以下几个配置，因为配置文件中是默认没有的，我也没有设置
# 部分的是否开启或者内部沟通端口应该是采用了默认值
# 都设置成有资格竞选主节点
node.master: true
# 都能设置成存储数据
node.data: true
# 都设置成最⼤集群节点数
node.max_local_storage_nodes: 3
# 都设置成内部节点之间沟通端⼝
transport.tcp.port: 9300

记得防火墙开通9300端口，不然节点之间没有联系，所以集群是组成不了的。看集群是否生效，可以直接访问http://172.16.25.149:9200/或者其他几台看看，返回的是否有cluster uuid。或者访问http://172.16.25.150:9200/_cat/health?v看看具体情况，其中有节点信息。

但是，这个样子没法直观管理集群。我们在第一台上有一个kibana，我们配置一下kibana.yml，让它连接到我们的几台节点。

elasticsearch.hosts: ["http://172.16.25.149:9200", "http://172.16.25.150:9200", "http://172.16.25.151:9200"]

启动kibana，访问172.16.25.149:5601看看，倒数第二个菜单stack monitoring，进到界面中可以发现有集群信息了。标星的是主节点，我们停掉这个主节点所在的实例后刷新试试看看主节点以及节点信息是否有变化：我们3台变成2台后，整个集群状态从绿色变成黄色了，这是直观地监测集群健康状态的。

（3）集群索引管理

7.x版本之前，ES默认为每个索引创建5个主分片，但是在7.x中默认是1个主分片和1个副分片。

我们尝试在kibana的控制台中新建一个索引，设置主分片和副分片。

PUT nba_latest
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  }
}

kibana中可以查看所有Indices的分片情况，总共有几个分片（应该是6），在每个节点上的分布情况等等都可以看到。如果其中一台出故障，分片会重新分配，故障修改也会重新分配。

  1. 分片是ES自动管理的。
  2. 单机上设置副分片没有意义，起不到备份作用，一起挂掉了。
  3. 在集群中，我们也可以看到主分片和副分片是被自动分在不同的节点中的。因为如果把他们放在同一个节点上，那起不到备份作用啊。
  4. 可以手动移动主分片的位置，比如把分片2从node-1移动到node-3，移动过去之后，整个分片会自动被调整，以保证主分片和副分片不在一个节点中。
POST _cluster/reroute
{
  "commands": [
    {
      "move": {
        "index": "nba_latest",
        "shard": 2,
        "from_node": "node-1",
        "to_node": "node-3"
      }
    }
  ]
}
  1. 主分片设置后不能修改，要么就重建索引，所以一开始尽量多设置一些。副分片可以手动调整数量，设置多个副分片相当于设置多个备份。

（4）集群健康管理
我们之前说了，可以通过接口/_cat/health?v查看，green对应kibana里面的健康颜色，我们之前关掉只剩2个节点时变成yellow表示可用但是不可靠了，如果变成red就表示集群不可用了。还有总节点数，数据节点数量、主分片数量等。

epoch      timestamp cluster     status node.total node.data shards pri relo init unassign pending_tasks max_task_wait_time active_shards_percent
1583335854 15:30:54  hello-world green           3         3     14   7    0    0        0             0                  -                100.0%

我们也可以通过这个接口/_cat/indices?v查看索引的分片分布情况等等。

health status index                           uuid                   pri rep docs.count docs.deleted store.size pri.store.size
green  open   nba_latest                      J18qZz3qQ4uNVB-R4aCFVw   3   1          0            0      1.6kb           849b

接口/_cat/allocation?v查看每个节点的磁盘分配情况。

接口/_cat/nodes?v查看节点信息。

_cat下还有其他接口，可以查看官方文档了解。

14、Elasticsearch原理

（1）分布式原理

ES的集群实现还是相对简单的，我们只要启动多个节点，节点设置统一的集群名称，然后给索引设置分片数，里面的分片管理这些都是ES帮我们自动实现的。

master主节点和主分片双重作用原理如下：

  1. master主节点负责管理集群状态和管理分片的分配（比如有节点增减时需要重新分配分片）。
  2. 当一个写操作来了，是直接找到主分片，注意这个主分片不一定在主节点上，主分片写完再同步到副分片上。
  3. 读写的请求可以被任意一个节点接收到，接收到之后如果不在这个节点那么它会转到目标节点上去。
  4. 具体到写，举个例子，如果请求到主节点1，节点1发现主分片在节点3，那么请求转到节点3，节点3写完主分片后，分别同步到节点1和节点2的副分片上。副分片都同步成功后，节点3向节点1报告成功，节点1再成功返回给客户端。
  5. 具体到读，举个例子，如果请求到主节点1，节点1会通过轮询各个副分片达到负载均衡。所以节点多副分片多的情况下，相当于自建了一个负载均衡。

（2）路由原理

当一个索引有多个分片的时候，新增文档时到底放在哪个分片呢？这就是由路由算法决定的。默认的routing是文档的_id。这个公式也说明了为什么主分片数量设置好之后不能修改，因为修改后，之前路由算出来的文档可能永远找不到具体在哪个分片上了。

shard = hash(routing) % number_of_primary_shard

可以通过接口查看某个文档的分片存储情况，可以看到存在哪个分片上，在哪个节点上等等。

# 这个1就是文档id
GET nba/_search_shards?routing=1

（3）乐观锁

因为ES使用场景仍然是读多写少，所以采用乐观锁可以提高性能。乐观锁是通过文档中的_version字段实现的。我们再对文档执行一些操作时，_version字段会自动加1。关于乐观锁和悲观锁的说明，这里不再赘述。

（4）倒排索引

倒排索引也是一种索引。本质上有两个过程：

  1. 建立索引。当一个文档新增过来了，我们要分析它里面的内容，把里面的内容分词后，放在一个地方（就是索引），这个地方记录的是这个单词出现在哪个文档中、哪个位置、出现的频率等等信息，如果这个单词之前已经有记录过了，那么就会和之前的那个记录合并在一起。
  2. 查询索引。到了使用的时候，查某个单词，先查索引，发现这个单词有，并且在哪些文档中，哪些位置，出现频率等等一清二楚，那么可以直接根据文档id把整个文档数据都返回，这就是倒排索引。

（5）ES的分词原理

我们可以对text类型的字段指定分词器，因为默认的是standard对中文不太友好，所以我们可能使用到ik_max_word之类的分词器。

分词器的设置在设置mapping的时候指定，而且不能修改。这样的话，我们新增文档的时候，这个字段就会使用设置的分词器去分词监理索引，这就是写时分词。

那么我们查询这个字段的时候，比如写了一段话或者一个词，也会默认先使用和写时分词同样的分词器分词，分完之后再匹配查询，读写使用相同的分词器可以保证查询匹配最好，举个例子，一段话乔丹很厉害设置了中文分词器，那么监理索引的时候其实只有乔丹，没有乔和丹，这样我们在用关键字乔丹查询的时候，如果故意设置了分词器为standard，那么就会被分成乔和丹导致在索引中找不到，返回空结果。

分词器（analyzer）一般分为3部分：

  1. 字符过滤器（char filter）。可以有0个或多个。
  2. 分词器（tokenizer）。拆分成多个词。有且只能有1个。
  3. token过滤器（token filter）。对拆出来的再过滤一遍，比如在stop中词就删除掉。或者这种过滤是转换的作用，比如转换小写等等。

举例，standard标准分词器的组成：

  1. tokenizer：Standard Tokenizer。
  2. token filter： Standard Token Filter和Lower Case Token Filter。
喂-不吃素的熊宝宝
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Elasticsearch 7.X 进阶实战
08-15
1、Elasticsearch 7.X 进阶实战大纲10个大选题来源于实战业务场景的提炼、总结。Elasticsearch 全貌认知Elasticsearch 索引创建和搜索原理Elasticsearch 集群规划及节点角色规划最佳实践Elasticsearch 集群性能调优及原理Elasticsearch 数据建模实例讲解与实战技巧Elasticsearch 冷温热架构讲解与实战Elasticsearch ILM 索引生命周期管理讲解与实战Elasticsearch CCS 跨集群搜索讲解与实战Elasticsearch 分片分配策略讲解与实战Elasticsearch 安全特性讲解与使用2、课程特色来源于项目实战、应用于实战项目。实战项目经验总结，属于基础后的进阶系列。基于 7.13 版本讲解，市面上教程都没有完整体现过该版本。近 10 个小时的视频，力求相对完整、体系、通透。 3、讲解方式干货凝练总结、侧重原理、深入浅出。每一讲脚本都可以提供下载，跟着学、学的会。视频共11大讲，每讲可以独立成课，方便大家地铁、公交车学习。录播方式，非直播。4、讲师：铭毅天下介绍Elastic认证工程师、Elastic中国合作培训讲师（有世界500强企业用户企业内训经验）；阿里云MVP;死磕Elasticsearch知识星球发起人，全球付费用户1200人+（含中国台湾、美国硅谷、加拿大球友），已带领 60人+ 通过Elasticsearch 认证考试（中国仅通过100人左右）；可能是中国最大Elastic技术公众号——铭毅天下Elasticsearch作者。CSDN博客专家、CSDN2020年度优秀创作者、CSDN2016年、2013年博客征文大赛特等奖得主；CSDN博客地址：elastic.blog.csdn.net；CSDN博客排名：近前150，阅读量近500,0000+；CSDN持续写作近十年（几乎每月都有输出，几乎从未间断），累计使用 Elasticsearch 超过 10000小时；Elastic中文社区日报责任编辑，2018年Elastic中文社区杰出贡献者、社区排名 TOP5；高级工程师、计算机应用技术硕士、近十年工作经验；理想主义者、终身学习者、终身成长者；笃信坚持、积累的力量；自1997年——至今20年+持续思考、积累、总结，从未间断；个人信条：自由不是你想干什么就干什么，而是你不想干什么就有能力不干什么！人因为梦想而伟大，机遇永远属于那些有准备、立即行动并能坚持到底的人！
ElasticSearch7的基本原理和使用(借用Kibana可视化工具)
qq_35170267的博客
03-25 1990
Elastic Search ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。ElasticSearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java...
ES中 minimum_should_match 的用法和误区
最新发布
ycclydy的博客
03-20 182
答案中并未显示的配置minimum_should_match参数，所以此时minimum_should_match的默认值是0。如果bool查询包包含must或 filter子句，则minimum_should_match默认值为0，即：此时minimum_should_match如果没有显示的配置，此时should子句中可以不满足任何条件。minimum_should_match是ES组合查询中的一个常用参数，参数指定should子句返回的文档必须匹配的子句的数量或百分比。上述截图中的两个认知误区。
Elasticsearch7 自学记录一 基础原理和简单查询
mqq00000的博客
08-03 230
Elasticsearch 7 自学记录１——ES基础 第一章 ES 基础 文章目录Elasticsearch 7 自学记录１——ES基础前言一、elasticsearch7搜索的本质及原理1.1结构名词1.2分布式索引原理名词1.3其他名词二、基础使用示例1.索引基础操作2.文档基础操作3.基础查询操作 前言 本人在慕课网学习elasticsearch7的学习笔记总结，并记录一些自己的理解。 一、elasticsearch7搜索的本质及原理 先从es的名词开始了解这个搜索引擎 1.1结构名词
ElasticSearch 7 入门
ycfxhsw的博客
05-11 2181
一、ElasticSearch介绍 Elasticsearch 是一个基于JSON的分布式、高扩展、高实时、RESTful 风格的搜索和数据分析引擎，能够解决不断涌现出的各种用例。 作为 Elastic Stack 的核心，它集中存储您的数据，帮助您发现意料之中以及意料之外的情况。 Elasticsearch是与名为Logstash的数据收集和日志解析引擎以及名为Kibana的分析和可视化平台一起开发的。这三个产品被设计成一个集成解决方案，称为“Elastic Stack”（以前称为“ELK stack”）
Elasticsearch7从入门到精通(简介、部署、原理、开发、ELK)
wt334502157的博客
11-04 5256
Elasticsearch官方网站：https://www.elastic.co/cn/elasticsearch/Elasticsearch是一个基于Lucene的搜索服务器提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Pyt
elasticsearch启动报错：Plugin [analysis-ik] was built for Elasticsearch version7.12.0 but version7.4.0
qq1067012060的博客
05-04 2231
解决办法：修改 plugin-descriptor.properties 文件中的 elasticsearch.version=你的ES版本号
Elasticsearch-7.1.x学习笔记
醉殇无痕的博客
06-13 9049
文章目录1. 单节点安装2. ES安装head插件3. Elasticsearch Rest基本操作REST介绍CURL创建索引库查询索引-GETDSL查询MGET查询HEAD的使用ES更新索引ES删除索引ES批量操作-bulkES版本控制4. Elasticsearch 核心概念Clustershardsreplicasrecoverygatewaydiscovery.zenTransportS...
前言
logonnet的博客
06-21 360
es7.1中文指南
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
centos7使用docker-compose安装es(包括IK分词器扩展)+kibana
04-13
3、docker和docker-compose安装要提前安装完成 4、将下载内容解压一个目录 5、运行 docker-compose up # 此命令环境会在终端前台运行 docker-compose up -d # 加上-d会放入后台进行环境的启动 如有问题，欢迎进行...
ElasticSearch + IK中文分词器 + kibana.zip（6.2.4版本）
10-29
ElasticSearch + IK中文分词器 + kibana.zip（6.2.4版本），SpringBoot 整合 Elasticsearch、IK分词器 实现全文检索所需软件包，文章说明：https://blog.csdn.net/qq_38762237/article/details/89552017
SpringBoot整合Elasticsearch7.2.0的实现方法
08-25
主要介绍了SpringBoot整合Elasticsearch7.2.0的实现方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
elasticsearch-6.2.2，ik分词器，kibana-6.2.2-windows-64
04-29
Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级...
【解决方案】mac：stack Error: `gyp` failed with exit code:1
热门推荐
小小的客栈 大大的江湖
04-12 2万+
1、问题描述 npm安装的时候报错，网上各种卸载重装node-gyp的方法试了都没用，是没找到问题根源： gyp ERR! stack Error: `gyp` failed with exit code: 1 gyp ERR! stack at ChildProcess.onCpExit (/usr/local/lib/node_modules/npm/node_modules/node...
Mac安装文件时提示“文件已损坏，建议移到废纸篓”的问题
小小的客栈 大大的江湖
12-11 1万+
在终端输入如下命令，开启安装来源里面的“任何来源”。sudo spctl --master-disable之后再选择其他来源时，这个“任何来源”貌似就会消失。
微信小程序快速开发-食堂菜单案例
小小的客栈 大大的江湖
07-14 7395
这里面设置的高度用的是百分比，这存在一定的问题。不如css3可以混用百分比和数值来的方便，虽然这种方式存在兼容性问题。其实小程序的开发和AngularJS十分相似。
在CentOS7上安装和配置Oracle19c、启动、CDB和PDB切换、基本使用、远程连接、导入dmp数据
小小的客栈 大大的江湖
09-23 5233
文章目录一、下载和安装二、配置三、启动四、切换容器和创建表空间和用户、远程连接五、导入数据 一、下载和安装 CentOS7的服务器，用root登录。 1、官方有安装介绍文档，主要是通过rpm安装，步骤大体分为下载安装preinstall包，然后再下载和安装oracle的包。 2、下载preinstall的包，主要是安装一些环境： curl -o oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm https://yum.oracle.com/repo/Or
Oracle for in loop循环时expression is of wrong type报错
小小的客栈 大大的江湖
05-27 4263
1、我本来想做一个嵌套的for in loop循环插入。第一层查出代码，然后利用这个代码再查出所有的日期。但是使用这个日期的时候一直报错，如下：BEGIN FOR item IN (SELECT DISTINCT SECINNERCODE,SECURITYCODE FROM FUND_BS_ATYPE WHERE ISUSABLE='1' AND TYPECODE IN (180108) O
es kibana 查询分词
09-06
在 Kibana 中进行查询时，默认情况下会使用 Elasticsearch 中的分词器来对查询进行分词。这意味着你可以使用相同的分词规则来执行查询，以确保查询与文档中储存的数据匹配。 以下是在 Kibana 中执行查询时，使用分词的一些常见方法： 1. 使用简单查询字符串： 在 Kibana 的 Discover 面板中，你可以使用简单查询字符串来执行搜索。这种查询语法支持基本的分词和逻辑操作符。例如，你可以输入 "field:value" 的形式来搜索匹配特定字段和值的文档。 2. 使用 Query DSL： Kibana 还提供了 Query DSL（Domain Specific Language，领域特定语言）来构建更复杂的查询。你可以在 Kibana 的 Dev Tools 面板中使用 Query DSL 来执行高级查询。Query DSL 提供了更多灵活性和控制力，可以更精确地定义分词和搜索行为。 3. 使用全文搜索： 如果你需要执行全文搜索，Kibana 支持使用 `match` 查询类型来执行全文搜索。`match` 查询会将查询的文本分词，并与文档中的分词进行匹配。这样可以找到与查询文本最相关的文档。 请注意，在执行查询时，Kibana 会默认使用 Elasticsearch 中字段的默认分词器。如果你想使用不同的分词器，你可以在查询语句中指定分词器的名称。例如，在查询字符串中使用 `field:value` 形式时，你可以使用 `field.keyword:value` 来确保不对值进行分词。 这些是在 Kibana 中进行查询分词的一些常见方法。希望对你有所帮助！如果有更多问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值